1 // Copyright 2012 The Chromium Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 #ifndef CHROME_BROWSER_PROCESS_SINGLETON_H_
6 #define CHROME_BROWSER_PROCESS_SINGLETON_H_
8 #include "base/sequence_checker.h"
9 #include "build/build_config.h"
12 #include "base/win/windows_types.h"
13 #endif // BUILDFLAG(IS_WIN)
15 #include "base/check.h"
16 #include "base/command_line.h"
17 #include "base/files/file_path.h"
18 #include "base/functional/callback.h"
19 #include "base/memory/ref_counted.h"
20 #include "base/process/process.h"
21 #include "ui/gfx/native_widget_types.h"
23 #if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID)
24 #include "base/files/scoped_temp_dir.h"
28 #include "base/win/message_window.h"
29 #endif // BUILDFLAG(IS_WIN)
35 // ProcessSingleton ----------------------------------------------------------
37 // This class allows different browser processes to communicate with
38 // each other. It is named according to the user data directory, so
39 // we can be sure that no more than one copy of the application can be
40 // running at once with a given data directory.
42 // Implementation notes:
43 // - the Windows implementation uses an invisible global message window;
44 // - the Linux implementation uses a Unix domain socket in the user data dir.
46 class ProcessSingleton {
48 // Used to send the reason of remote hang process termination as histogram.
49 enum RemoteHungProcessTerminateReason {
51 USER_ACCEPTED_TERMINATION = 1,
52 NO_VISIBLE_WINDOW_FOUND = 2,
53 #elif BUILDFLAG(IS_POSIX)
54 NOTIFY_ATTEMPTS_EXCEEDED = 3,
55 SOCKET_WRITE_FAILED = 4,
56 SOCKET_READ_FAILED = 5,
58 REMOTE_HUNG_PROCESS_TERMINATE_REASON_COUNT
61 // Used to send the result of interaction with remote process as histograms in
62 // case when remote process influences on start.
63 enum RemoteProcessInteractionResult {
64 TERMINATE_SUCCEEDED = 0,
66 REMOTE_PROCESS_NOT_FOUND = 2,
68 TERMINATE_WAIT_TIMEOUT = 3,
69 RUNNING_PROCESS_NOTIFY_ERROR = 4,
70 #elif BUILDFLAG(IS_POSIX)
71 TERMINATE_NOT_ENOUGH_PERMISSIONS = 5,
72 REMOTE_PROCESS_SHUTTING_DOWN = 6,
74 PROFILE_UNLOCKED_BEFORE_KILL = 8,
75 SAME_BROWSER_INSTANCE = 9,
76 SAME_BROWSER_INSTANCE_BEFORE_KILL = 10,
77 FAILED_TO_EXTRACT_PID = 11,
78 INVALID_LOCK_FILE = 12,
79 ORPHANED_LOCK_FILE = 13,
81 USER_REFUSED_TERMINATION = 14,
82 REMOTE_PROCESS_INTERACTION_RESULT_COUNT
85 // Logged as histograms, do not modify these values.
91 LAST_VALUE = LOCK_ERROR
94 static constexpr int kNumNotifyResults = LAST_VALUE + 1;
96 // Implement this callback to handle notifications from other processes. The
97 // callback will receive the command line and directory with which the other
98 // Chrome process was launched. Return true if the command line will be
99 // handled within the current browser instance or false if the remote process
100 // should handle it (i.e., because the current process is shutting down).
101 using NotificationCallback =
102 base::RepeatingCallback<bool(const base::CommandLine& command_line,
103 const base::FilePath& current_directory)>;
105 ProcessSingleton(const base::FilePath& user_data_dir,
106 const NotificationCallback& notification_callback);
108 ProcessSingleton(const ProcessSingleton&) = delete;
109 ProcessSingleton& operator=(const ProcessSingleton&) = delete;
113 // Notify another process, if available. Otherwise sets ourselves as the
114 // singleton instance. Returns PROCESS_NONE if we became the singleton
115 // instance. Callers are guaranteed to either have notified an existing
116 // process or have grabbed the singleton (unless the profile is locked by an
117 // unreachable process).
118 // TODO(brettw): Make the implementation of this method non-platform-specific
119 // by making Linux re-use the Windows implementation.
120 NotifyResult NotifyOtherProcessOrCreate();
122 // Sets ourself up as the singleton instance. Returns true on success. If
123 // false is returned, we are not the singleton instance and the caller must
125 // NOTE: Most callers should generally prefer NotifyOtherProcessOrCreate() to
126 // this method, only callers for whom failure is preferred to notifying
127 // another process should call this directly.
130 // Start watching for notifications from other processes.
131 void StartWatching();
133 // Clear any lock state during shutdown.
136 #if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID)
137 static void DisablePromptForTesting();
138 static void SkipIsChromeProcessCheckForTesting(bool skip);
139 static void SetUserOptedUnlockInUseProfileForTesting(bool set_unlock);
141 #if BUILDFLAG(IS_WIN)
142 // Called to query whether to kill a hung browser process that has visible
143 // windows. Return true to allow killing the hung process.
144 using ShouldKillRemoteProcessCallback = base::RepeatingCallback<bool()>;
145 void OverrideShouldKillRemoteProcessCallbackForTesting(
146 const ShouldKillRemoteProcessCallback& display_dialog_callback);
150 // Notify another process, if available.
151 // Returns true if another process was found and notified, false if we should
152 // continue with the current process.
153 // On Windows, Create() has to be called before this.
154 NotifyResult NotifyOtherProcess();
156 #if BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID)
157 // Exposed for testing. We use a timeout on Linux, and in tests we want
158 // this timeout to be short.
159 NotifyResult NotifyOtherProcessWithTimeout(
160 const base::CommandLine& command_line,
162 const base::TimeDelta& timeout,
163 bool kill_unresponsive);
164 NotifyResult NotifyOtherProcessWithTimeoutOrCreate(
165 const base::CommandLine& command_line,
167 const base::TimeDelta& timeout);
168 void OverrideCurrentPidForTesting(base::ProcessId pid);
169 void OverrideKillCallbackForTesting(
170 const base::RepeatingCallback<void(int)>& callback);
174 NotificationCallback notification_callback_; // Handler for notifications.
176 #if BUILDFLAG(IS_WIN)
177 bool EscapeVirtualization(const base::FilePath& user_data_dir);
179 HWND remote_window_; // The HWND_MESSAGE of another browser.
180 base::win::MessageWindow window_; // The message-only window.
181 bool is_virtualized_; // Stuck inside Microsoft Softricity VM environment.
183 base::FilePath user_data_dir_;
184 ShouldKillRemoteProcessCallback should_kill_remote_process_callback_;
185 #elif BUILDFLAG(IS_POSIX) && !BUILDFLAG(IS_ANDROID)
186 // Return true if the given pid is one of our child processes.
187 // Assumes that the current pid is the root of all pids of the current
189 bool IsSameChromeInstance(pid_t pid);
191 // Extract the process's pid from a symbol link path and if it is on
192 // the same host or is_connected_to_socket is true, kill the process, unlink
193 // the lock file and return true.
194 // If the process is part of the same chrome instance, unlink the lock file
195 // and return true without killing it.
196 // If the process is on a different host and is_connected_to_socket is false,
197 // display profile in use error dialog (on Linux). If user opted to unlock
198 // profile (on Mac OS X by default), unlink the lock file and return true.
199 // Otherwise return false.
200 bool KillProcessByLockPath(bool is_connected_to_socket);
202 // Default function to kill a process, overridable by tests.
203 void KillProcess(int pid);
205 // Allow overriding for tests.
206 base::ProcessId current_pid_;
208 // Function to call when the other process is hung and needs to be killed.
209 // Allows overriding for tests.
210 base::RepeatingCallback<void(int)> kill_callback_;
212 // Path in file system to the socket.
213 base::FilePath socket_path_;
215 // Path in file system to the lock.
216 base::FilePath lock_path_;
218 // Path in file system to the cookie file.
219 base::FilePath cookie_path_;
221 // Temporary directory to hold the socket.
222 base::ScopedTempDir socket_dir_;
225 // Helper class for linux specific messages. LinuxWatcher is ref counted
226 // because it posts messages between threads.
228 scoped_refptr<LinuxWatcher> watcher_;
231 #if BUILDFLAG(IS_MAC)
232 // macOS 10.13 tries to open a new Chrome instance if a user tries to
233 // open an external link after Chrome has updated, but not relaunched.
234 // This method extracts any waiting "open URL" AppleEvent and forwards
235 // it to the running process. Returns true if an event was found and
238 bool WaitForAndForwardOpenURLEvent(pid_t event_destination_pid);
241 SEQUENCE_CHECKER(sequence_checker_);
244 #endif // CHROME_BROWSER_PROCESS_SINGLETON_H_