1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_PROCESS_SINGLETON_H_ 6 #define CHROME_BROWSER_PROCESS_SINGLETON_H_ 7 8 #include "build/build_config.h" 9 10 #if defined(OS_WIN) 11 #include <windows.h> 12 #endif // defined(OS_WIN) 13 14 #include <set> 15 #include <vector> 16 17 #include "base/basictypes.h" 18 #include "base/callback.h" 19 #include "base/command_line.h" 20 #include "base/files/file_path.h" 21 #include "base/logging.h" 22 #include "base/memory/ref_counted.h" 23 #include "base/process/process.h" 24 #include "base/threading/non_thread_safe.h" 25 #include "ui/gfx/native_widget_types.h" 26 27 #if defined(OS_POSIX) && !defined(OS_ANDROID) 28 #include "base/files/scoped_temp_dir.h" 29 #endif 30 31 #if defined(OS_WIN) 32 #include "base/win/message_window.h" 33 #endif // defined(OS_WIN) 34 35 namespace base { 36 class CommandLine; 37 } 38 39 // ProcessSingleton ---------------------------------------------------------- 40 // 41 // This class allows different browser processes to communicate with 42 // each other. It is named according to the user data directory, so 43 // we can be sure that no more than one copy of the application can be 44 // running at once with a given data directory. 45 // 46 // Implementation notes: 47 // - the Windows implementation uses an invisible global message window; 48 // - the Linux implementation uses a Unix domain socket in the user data dir. 49 50 class ProcessSingleton : public base::NonThreadSafe { 51 public: 52 enum NotifyResult { 53 PROCESS_NONE, 54 PROCESS_NOTIFIED, 55 PROFILE_IN_USE, 56 LOCK_ERROR, 57 }; 58 59 // Implement this callback to handle notifications from other processes. The 60 // callback will receive the command line and directory with which the other 61 // Chrome process was launched. Return true if the command line will be 62 // handled within the current browser instance or false if the remote process 63 // should handle it (i.e., because the current process is shutting down). 64 typedef base::Callback<bool( 65 const base::CommandLine& command_line, 66 const base::FilePath& current_directory)> NotificationCallback; 67 68 ProcessSingleton(const base::FilePath& user_data_dir, 69 const NotificationCallback& notification_callback); 70 ~ProcessSingleton(); 71 72 // Notify another process, if available. Otherwise sets ourselves as the 73 // singleton instance. Returns PROCESS_NONE if we became the singleton 74 // instance. Callers are guaranteed to either have notified an existing 75 // process or have grabbed the singleton (unless the profile is locked by an 76 // unreachable process). 77 // TODO(brettw): Make the implementation of this method non-platform-specific 78 // by making Linux re-use the Windows implementation. 79 NotifyResult NotifyOtherProcessOrCreate(); 80 81 // Sets ourself up as the singleton instance. Returns true on success. If 82 // false is returned, we are not the singleton instance and the caller must 83 // exit. 84 // NOTE: Most callers should generally prefer NotifyOtherProcessOrCreate() to 85 // this method, only callers for whom failure is prefered to notifying another 86 // process should call this directly. 87 bool Create(); 88 89 // Clear any lock state during shutdown. 90 void Cleanup(); 91 92 #if defined(OS_POSIX) && !defined(OS_ANDROID) 93 static void DisablePromptForTesting(); 94 #endif 95 96 protected: 97 // Notify another process, if available. 98 // Returns true if another process was found and notified, false if we should 99 // continue with the current process. 100 // On Windows, Create() has to be called before this. 101 NotifyResult NotifyOtherProcess(); 102 103 #if defined(OS_POSIX) && !defined(OS_ANDROID) 104 // Exposed for testing. We use a timeout on Linux, and in tests we want 105 // this timeout to be short. 106 NotifyResult NotifyOtherProcessWithTimeout( 107 const base::CommandLine& command_line, 108 int timeout_seconds, 109 bool kill_unresponsive); 110 NotifyResult NotifyOtherProcessWithTimeoutOrCreate( 111 const base::CommandLine& command_line, 112 int timeout_seconds); 113 void OverrideCurrentPidForTesting(base::ProcessId pid); 114 void OverrideKillCallbackForTesting( 115 const base::Callback<void(int)>& callback); 116 #endif 117 118 private: 119 // Timeout for the current browser process to respond. 20 seconds should be 120 // enough. 121 static const int kTimeoutInSeconds = 20; 122 123 NotificationCallback notification_callback_; // Handler for notifications. 124 125 #if defined(OS_WIN) 126 bool EscapeVirtualization(const base::FilePath& user_data_dir); 127 128 HWND remote_window_; // The HWND_MESSAGE of another browser. 129 base::win::MessageWindow window_; // The message-only window. 130 bool is_virtualized_; // Stuck inside Microsoft Softricity VM environment. 131 HANDLE lock_file_; 132 base::FilePath user_data_dir_; 133 #elif defined(OS_POSIX) && !defined(OS_ANDROID) 134 // Return true if the given pid is one of our child processes. 135 // Assumes that the current pid is the root of all pids of the current 136 // instance. 137 bool IsSameChromeInstance(pid_t pid); 138 139 // Extract the process's pid from a symbol link path and if it is on 140 // the same host, kill the process, unlink the lock file and return true. 141 // If the process is part of the same chrome instance, unlink the lock file 142 // and return true without killing it. 143 // If the process is on a different host, return false. 144 bool KillProcessByLockPath(); 145 146 // Default function to kill a process, overridable by tests. 147 void KillProcess(int pid); 148 149 // Allow overriding for tests. 150 base::ProcessId current_pid_; 151 152 // Function to call when the other process is hung and needs to be killed. 153 // Allows overriding for tests. 154 base::Callback<void(int)> kill_callback_; 155 156 // Path in file system to the socket. 157 base::FilePath socket_path_; 158 159 // Path in file system to the lock. 160 base::FilePath lock_path_; 161 162 // Path in file system to the cookie file. 163 base::FilePath cookie_path_; 164 165 // Temporary directory to hold the socket. 166 base::ScopedTempDir socket_dir_; 167 168 // Helper class for linux specific messages. LinuxWatcher is ref counted 169 // because it posts messages between threads. 170 class LinuxWatcher; 171 scoped_refptr<LinuxWatcher> watcher_; 172 #endif 173 174 DISALLOW_COPY_AND_ASSIGN(ProcessSingleton); 175 }; 176 177 #endif // CHROME_BROWSER_PROCESS_SINGLETON_H_ 178