1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
|
// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_PROCESS_SINGLETON_H_
#define CHROME_BROWSER_PROCESS_SINGLETON_H_
#pragma once
#include "build/build_config.h"
#if defined(OS_WIN)
#include <windows.h>
#endif // defined(OS_WIN)
#include "base/basictypes.h"
#include "base/logging.h"
#include "base/non_thread_safe.h"
#include "base/ref_counted.h"
#include "gfx/native_widget_types.h"
#if defined(OS_POSIX)
#include "base/file_path.h"
#endif // defined(OS_POSIX)
#if defined(USE_X11)
#include "base/scoped_temp_dir.h"
#endif // defined(USE_X11)
class CommandLine;
class FilePath;
// ProcessSingleton ----------------------------------------------------------
//
// This class allows different browser processes to communicate with
// each other. It is named according to the user data directory, so
// we can be sure that no more than one copy of the application can be
// running at once with a given data directory.
//
// Implementation notes:
// - the Windows implementation uses an invisible global message window;
// - the Linux implementation uses a Unix domain socket in the user data dir.
class ProcessSingleton : public NonThreadSafe {
public:
enum NotifyResult {
PROCESS_NONE,
PROCESS_NOTIFIED,
PROFILE_IN_USE,
LOCK_ERROR,
};
explicit ProcessSingleton(const FilePath& user_data_dir);
~ProcessSingleton();
// Notify another process, if available.
// Returns true if another process was found and notified, false if we
// should continue with this process.
// Windows code roughly based on Mozilla.
//
// TODO(brettw): this will not handle all cases. If two process start up too
// close to each other, the Create() might not yet have happened for the
// first one, so this function won't find it.
NotifyResult NotifyOtherProcess();
// Notify another process, if available. Otherwise sets ourselves as the
// singleton instance. Returns PROCESS_NONE if we became the singleton
// instance.
NotifyResult NotifyOtherProcessOrCreate();
#if defined(OS_LINUX)
// Exposed for testing. We use a timeout on Linux, and in tests we want
// this timeout to be short.
NotifyResult NotifyOtherProcessWithTimeout(const CommandLine& command_line,
int timeout_seconds,
bool kill_unresponsive);
NotifyResult NotifyOtherProcessWithTimeoutOrCreate(
const CommandLine& command_line,
int timeout_seconds);
#endif // defined(OS_LINUX)
// Sets ourself up as the singleton instance. Returns true on success. If
// false is returned, we are not the singleton instance and the caller must
// exit.
bool Create();
// Clear any lock state during shutdown.
void Cleanup();
// Blocks the dispatch of CopyData messages. foreground_window refers
// to the window that should be set to the foreground if a CopyData message
// is received while the ProcessSingleton is locked.
void Lock(gfx::NativeWindow foreground_window) {
DCHECK(CalledOnValidThread());
locked_ = true;
foreground_window_ = foreground_window;
}
// Allows the dispatch of CopyData messages.
void Unlock() {
DCHECK(CalledOnValidThread());
locked_ = false;
foreground_window_ = NULL;
}
bool locked() {
DCHECK(CalledOnValidThread());
return locked_;
}
private:
#if !defined(OS_MACOSX)
// Timeout for the current browser process to respond. 20 seconds should be
// enough. It's only used in Windows and Linux implementations.
static const int kTimeoutInSeconds = 20;
#endif
bool locked_;
gfx::NativeWindow foreground_window_;
#if defined(OS_WIN)
// This ugly behemoth handles startup commands sent from another process.
LRESULT OnCopyData(HWND hwnd, const COPYDATASTRUCT* cds);
LRESULT CALLBACK WndProc(HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam);
static LRESULT CALLBACK WndProcStatic(HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam) {
ProcessSingleton* msg_wnd = reinterpret_cast<ProcessSingleton*>(
GetWindowLongPtr(hwnd, GWLP_USERDATA));
return msg_wnd->WndProc(hwnd, message, wparam, lparam);
}
HWND remote_window_; // The HWND_MESSAGE of another browser.
HWND window_; // The HWND_MESSAGE window.
#elif defined(USE_X11)
// Path in file system to the socket.
FilePath socket_path_;
// Path in file system to the lock.
FilePath lock_path_;
// Path in file system to the cookie file.
FilePath cookie_path_;
// Temporary directory to hold the socket.
ScopedTempDir socket_dir_;
// Helper class for linux specific messages. LinuxWatcher is ref counted
// because it posts messages between threads.
class LinuxWatcher;
scoped_refptr<LinuxWatcher> watcher_;
#elif defined(OS_MACOSX)
// Path in file system to the lock.
FilePath lock_path_;
// File descriptor associated with the lockfile, valid between
// |Create()| and |Cleanup()|. Two instances cannot have a lock on
// the same file at the same time.
int lock_fd_;
#endif
DISALLOW_COPY_AND_ASSIGN(ProcessSingleton);
};
#endif // CHROME_BROWSER_PROCESS_SINGLETON_H_
|
