1 // Copyright (c) 2011 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 #include "chrome/browser/process_singleton.h" 6 7 #include "base/base_paths.h" 8 #include "base/command_line.h" 9 #include "base/file_path.h" 10 #include "base/path_service.h" 11 #include "base/process_util.h" 12 #include "base/utf_string_conversions.h" 13 #include "base/win/scoped_handle.h" 14 #include "base/win/wrapped_window_proc.h" 15 #include "chrome/browser/browser_process.h" 16 #include "chrome/browser/extensions/extensions_startup.h" 17 #include "chrome/browser/platform_util.h" 18 #include "chrome/browser/profiles/profile.h" 19 #include "chrome/browser/profiles/profile_manager.h" 20 #include "chrome/browser/ui/browser_init.h" 21 #include "chrome/common/chrome_constants.h" 22 #include "chrome/common/chrome_paths.h" 23 #include "chrome/common/chrome_switches.h" 24 #include "content/common/result_codes.h" 25 #include "grit/chromium_strings.h" 26 #include "grit/generated_resources.h" 27 #include "ui/base/l10n/l10n_util.h" 28 #include "ui/base/win/hwnd_util.h" 29 30 namespace { 31 32 // Checks the visibility of the enumerated window and signals once a visible 33 // window has been found. 34 BOOL CALLBACK BrowserWindowEnumeration(HWND window, LPARAM param) { 35 bool* result = reinterpret_cast<bool*>(param); 36 *result = IsWindowVisible(window) != 0; 37 // Stops enumeration if a visible window has been found. 38 return !*result; 39 } 40 41 } // namespace 42 43 // Look for a Chrome instance that uses the same profile directory. 44 ProcessSingleton::ProcessSingleton(const FilePath& user_data_dir) 45 : window_(NULL), locked_(false), foreground_window_(NULL) { 46 remote_window_ = FindWindowEx(HWND_MESSAGE, NULL, 47 chrome::kMessageWindowClass, 48 user_data_dir.value().c_str()); 49 if (!remote_window_) { 50 // Make sure we will be the one and only process creating the window. 51 // We use a named Mutex since we are protecting against multi-process 52 // access. As documented, it's clearer to NOT request ownership on creation 53 // since it isn't guaranteed we will get it. It is better to create it 54 // without ownership and explicitly get the ownership afterward. 55 std::wstring mutex_name(L"Local\\ChromeProcessSingletonStartup!"); 56 base::win::ScopedHandle only_me( 57 CreateMutex(NULL, FALSE, mutex_name.c_str())); 58 DCHECK(only_me.Get() != NULL) << "GetLastError = " << GetLastError(); 59 60 // This is how we acquire the mutex (as opposed to the initial ownership). 61 DWORD result = WaitForSingleObject(only_me, INFINITE); 62 DCHECK(result == WAIT_OBJECT_0) << "Result = " << result << 63 "GetLastError = " << GetLastError(); 64 65 // We now own the mutex so we are the only process that can create the 66 // window at this time, but we must still check if someone created it 67 // between the time where we looked for it above and the time the mutex 68 // was given to us. 69 remote_window_ = FindWindowEx(HWND_MESSAGE, NULL, 70 chrome::kMessageWindowClass, 71 user_data_dir.value().c_str()); 72 if (!remote_window_) 73 Create(); 74 BOOL success = ReleaseMutex(only_me); 75 DCHECK(success) << "GetLastError = " << GetLastError(); 76 } 77 } 78 79 ProcessSingleton::~ProcessSingleton() { 80 if (window_) { 81 DestroyWindow(window_); 82 UnregisterClass(chrome::kMessageWindowClass, GetModuleHandle(NULL)); 83 } 84 } 85 86 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() { 87 if (!remote_window_) 88 return PROCESS_NONE; 89 90 // Found another window, send our command line to it 91 // format is "START\0<<<current directory>>>\0<<<commandline>>>". 92 std::wstring to_send(L"START\0", 6); // want the NULL in the string. 93 FilePath cur_dir; 94 if (!PathService::Get(base::DIR_CURRENT, &cur_dir)) 95 return PROCESS_NONE; 96 to_send.append(cur_dir.value()); 97 to_send.append(L"\0", 1); // Null separator. 98 to_send.append(GetCommandLineW()); 99 to_send.append(L"\0", 1); // Null separator. 100 101 // Allow the current running browser window making itself the foreground 102 // window (otherwise it will just flash in the taskbar). 103 DWORD process_id = 0; 104 DWORD thread_id = GetWindowThreadProcessId(remote_window_, &process_id); 105 // It is possible that the process owning this window may have died by now. 106 if (!thread_id || !process_id) { 107 remote_window_ = NULL; 108 return PROCESS_NONE; 109 } 110 111 AllowSetForegroundWindow(process_id); 112 113 COPYDATASTRUCT cds; 114 cds.dwData = 0; 115 cds.cbData = static_cast<DWORD>((to_send.length() + 1) * sizeof(wchar_t)); 116 cds.lpData = const_cast<wchar_t*>(to_send.c_str()); 117 DWORD_PTR result = 0; 118 if (SendMessageTimeout(remote_window_, 119 WM_COPYDATA, 120 NULL, 121 reinterpret_cast<LPARAM>(&cds), 122 SMTO_ABORTIFHUNG, 123 kTimeoutInSeconds * 1000, 124 &result)) { 125 // It is possible that the process owning this window may have died by now. 126 if (!result) { 127 remote_window_ = NULL; 128 return PROCESS_NONE; 129 } 130 return PROCESS_NOTIFIED; 131 } 132 133 // It is possible that the process owning this window may have died by now. 134 if (!IsWindow(remote_window_)) { 135 remote_window_ = NULL; 136 return PROCESS_NONE; 137 } 138 139 // The window is hung. Scan for every window to find a visible one. 140 bool visible_window = false; 141 EnumThreadWindows(thread_id, 142 &BrowserWindowEnumeration, 143 reinterpret_cast<LPARAM>(&visible_window)); 144 145 // If there is a visible browser window, ask the user before killing it. 146 if (visible_window) { 147 std::wstring text = 148 UTF16ToWide(l10n_util::GetStringUTF16(IDS_BROWSER_HUNGBROWSER_MESSAGE)); 149 std::wstring caption = 150 UTF16ToWide(l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)); 151 if (!platform_util::SimpleYesNoBox(NULL, caption, text)) { 152 // The user denied. Quit silently. 153 return PROCESS_NOTIFIED; 154 } 155 } 156 157 // Time to take action. Kill the browser process. 158 base::KillProcessById(process_id, ResultCodes::HUNG, true); 159 remote_window_ = NULL; 160 return PROCESS_NONE; 161 } 162 163 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() { 164 NotifyResult result = NotifyOtherProcess(); 165 if (result != PROCESS_NONE) 166 return result; 167 return Create() ? PROCESS_NONE : PROFILE_IN_USE; 168 } 169 170 // For windows, there is no need to call Create() since the call is made in 171 // the constructor but to avoid having more platform specific code in 172 // browser_main.cc we tolerate a second call which will do nothing. 173 bool ProcessSingleton::Create() { 174 DCHECK(!remote_window_); 175 if (window_) 176 return true; 177 178 HINSTANCE hinst = GetModuleHandle(NULL); 179 180 WNDCLASSEX wc = {0}; 181 wc.cbSize = sizeof(wc); 182 wc.lpfnWndProc = 183 base::win::WrappedWindowProc<ProcessSingleton::WndProcStatic>; 184 wc.hInstance = hinst; 185 wc.lpszClassName = chrome::kMessageWindowClass; 186 ATOM clazz = RegisterClassEx(&wc); 187 DCHECK(clazz); 188 189 FilePath user_data_dir; 190 PathService::Get(chrome::DIR_USER_DATA, &user_data_dir); 191 192 // Set the window's title to the path of our user data directory so other 193 // Chrome instances can decide if they should forward to us or not. 194 window_ = CreateWindow(chrome::kMessageWindowClass, 195 user_data_dir.value().c_str(), 196 0, 0, 0, 0, 0, HWND_MESSAGE, 0, hinst, 0); 197 ui::CheckWindowCreated(window_); 198 ui::SetWindowUserData(window_, this); 199 return true; 200 } 201 202 void ProcessSingleton::Cleanup() { 203 } 204 205 LRESULT ProcessSingleton::OnCopyData(HWND hwnd, const COPYDATASTRUCT* cds) { 206 // If locked, it means we are not ready to process this message because 207 // we are probably in a first run critical phase. 208 if (locked_) { 209 // Attempt to place ourselves in the foreground / flash the task bar. 210 if (IsWindow(foreground_window_)) 211 SetForegroundWindow(foreground_window_); 212 return TRUE; 213 } 214 215 // Ignore the request if the browser process is already in shutdown path. 216 if (!g_browser_process || g_browser_process->IsShuttingDown()) { 217 LOG(WARNING) << "Not handling WM_COPYDATA as browser is shutting down"; 218 return FALSE; 219 } 220 221 // We should have enough room for the shortest command (min_message_size) 222 // and also be a multiple of wchar_t bytes. The shortest command 223 // possible is L"START\0\0" (empty current directory and command line). 224 static const int min_message_size = 7; 225 if (cds->cbData < min_message_size * sizeof(wchar_t) || 226 cds->cbData % sizeof(wchar_t) != 0) { 227 LOG(WARNING) << "Invalid WM_COPYDATA, length = " << cds->cbData; 228 return TRUE; 229 } 230 231 // We split the string into 4 parts on NULLs. 232 DCHECK(cds->lpData); 233 const std::wstring msg(static_cast<wchar_t*>(cds->lpData), 234 cds->cbData / sizeof(wchar_t)); 235 const std::wstring::size_type first_null = msg.find_first_of(L'\0'); 236 if (first_null == 0 || first_null == std::wstring::npos) { 237 // no NULL byte, don't know what to do 238 LOG(WARNING) << "Invalid WM_COPYDATA, length = " << msg.length() << 239 ", first null = " << first_null; 240 return TRUE; 241 } 242 243 // Decode the command, which is everything until the first NULL. 244 if (msg.substr(0, first_null) == L"START") { 245 // Another instance is starting parse the command line & do what it would 246 // have done. 247 VLOG(1) << "Handling STARTUP request from another process"; 248 const std::wstring::size_type second_null = 249 msg.find_first_of(L'\0', first_null + 1); 250 if (second_null == std::wstring::npos || 251 first_null == msg.length() - 1 || second_null == msg.length()) { 252 LOG(WARNING) << "Invalid format for start command, we need a string in 4 " 253 "parts separated by NULLs"; 254 return TRUE; 255 } 256 257 // Get current directory. 258 const FilePath cur_dir(msg.substr(first_null + 1, 259 second_null - first_null)); 260 261 const std::wstring::size_type third_null = 262 msg.find_first_of(L'\0', second_null + 1); 263 if (third_null == std::wstring::npos || 264 third_null == msg.length()) { 265 LOG(WARNING) << "Invalid format for start command, we need a string in 4 " 266 "parts separated by NULLs"; 267 } 268 269 // Get command line. 270 const std::wstring cmd_line = 271 msg.substr(second_null + 1, third_null - second_null); 272 273 CommandLine parsed_command_line = CommandLine::FromString(cmd_line); 274 PrefService* prefs = g_browser_process->local_state(); 275 DCHECK(prefs); 276 277 Profile* profile = ProfileManager::GetDefaultProfile(); 278 if (!profile) { 279 // We should only be able to get here if the profile already exists and 280 // has been created. 281 NOTREACHED(); 282 return TRUE; 283 } 284 285 // Handle the --uninstall-extension startup action. This needs to done here 286 // in the process that is running with the target profile, otherwise the 287 // uninstall will fail to unload and remove all components. 288 if (parsed_command_line.HasSwitch(switches::kUninstallExtension)) { 289 ExtensionsStartupUtil ext_startup_util; 290 ext_startup_util.UninstallExtension(parsed_command_line, profile); 291 return TRUE; 292 } 293 294 // Run the browser startup sequence again, with the command line of the 295 // signalling process. 296 BrowserInit::ProcessCommandLine(parsed_command_line, cur_dir, false, 297 profile, NULL); 298 return TRUE; 299 } 300 return TRUE; 301 } 302 303 LRESULT CALLBACK ProcessSingleton::WndProc(HWND hwnd, UINT message, 304 WPARAM wparam, LPARAM lparam) { 305 switch (message) { 306 case WM_COPYDATA: 307 return OnCopyData(reinterpret_cast<HWND>(wparam), 308 reinterpret_cast<COPYDATASTRUCT*>(lparam)); 309 default: 310 break; 311 } 312 313 return ::DefWindowProc(hwnd, message, wparam, lparam); 314 } 315
