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 preferred to notifying 86 // another 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 retry_attempts, 109 const base::TimeDelta& timeout, 110 bool kill_unresponsive); 111 NotifyResult NotifyOtherProcessWithTimeoutOrCreate( 112 const base::CommandLine& command_line, 113 int retry_attempts, 114 const base::TimeDelta& timeout); 115 void OverrideCurrentPidForTesting(base::ProcessId pid); 116 void OverrideKillCallbackForTesting( 117 const base::Callback<void(int)>& callback); 118 #endif 119 120 private: 121 NotificationCallback notification_callback_; // Handler for notifications. 122 123 #if defined(OS_WIN) 124 bool EscapeVirtualization(const base::FilePath& user_data_dir); 125 126 HWND remote_window_; // The HWND_MESSAGE of another browser. 127 base::win::MessageWindow window_; // The message-only window. 128 bool is_virtualized_; // Stuck inside Microsoft Softricity VM environment. 129 HANDLE lock_file_; 130 base::FilePath user_data_dir_; 131 #elif defined(OS_POSIX) && !defined(OS_ANDROID) 132 // Return true if the given pid is one of our child processes. 133 // Assumes that the current pid is the root of all pids of the current 134 // instance. 135 bool IsSameChromeInstance(pid_t pid); 136 137 // Extract the process's pid from a symbol link path and if it is on 138 // the same host, kill the process, unlink the lock file and return true. 139 // If the process is part of the same chrome instance, unlink the lock file 140 // and return true without killing it. 141 // If the process is on a different host, return false. 142 bool KillProcessByLockPath(); 143 144 // Default function to kill a process, overridable by tests. 145 void KillProcess(int pid); 146 147 // Allow overriding for tests. 148 base::ProcessId current_pid_; 149 150 // Function to call when the other process is hung and needs to be killed. 151 // Allows overriding for tests. 152 base::Callback<void(int)> kill_callback_; 153 154 // Path in file system to the socket. 155 base::FilePath socket_path_; 156 157 // Path in file system to the lock. 158 base::FilePath lock_path_; 159 160 // Path in file system to the cookie file. 161 base::FilePath cookie_path_; 162 163 // Temporary directory to hold the socket. 164 base::ScopedTempDir socket_dir_; 165 166 // Helper class for linux specific messages. LinuxWatcher is ref counted 167 // because it posts messages between threads. 168 class LinuxWatcher; 169 scoped_refptr<LinuxWatcher> watcher_; 170 #endif 171 172 DISALLOW_COPY_AND_ASSIGN(ProcessSingleton); 173 }; 174 175 #endif // CHROME_BROWSER_PROCESS_SINGLETON_H_ 176