Cleanup in ProcessSingleton.

chrome/browser/process_singleton_win.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/process_singleton.h"
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
@@ skipping 73 matching lines @@
         break;
       }
       ::Sleep(10);
     }
     return true;
   }
   return false;
 }
 
 // Look for a Chrome instance that uses the same profile directory.
+// If there isn't one, create a message window with its title set to
+// the profile directory path.
 ProcessSingleton::ProcessSingleton(const FilePath& user_data_dir)
     : window_(NULL), locked_(false), foreground_window_(NULL),
     is_virtualized_(false) {
   remote_window_ = FindWindowEx(HWND_MESSAGE, NULL,
                                 chrome::kMessageWindowClass,
                                 user_data_dir.value().c_str());
   if (!remote_window_ && !EscapeVirtualization(user_data_dir)) {
     // Make sure we will be the one and only process creating the window.
     // We use a named Mutex since we are protecting against multi-process
     // access. As documented, it's clearer to NOT request ownership on creation
     // since it isn't guaranteed we will get it. It is better to create it
     // without ownership and explicitly get the ownership afterward.
     std::wstring mutex_name(L"Local\\ChromeProcessSingletonStartup!");
     base::win::ScopedHandle only_me(
         CreateMutex(NULL, FALSE, mutex_name.c_str()));
     DCHECK(only_me.Get() != NULL) << "GetLastError = " << GetLastError();
 
     // This is how we acquire the mutex (as opposed to the initial ownership).
     DWORD result = WaitForSingleObject(only_me, INFINITE);
     DCHECK(result == WAIT_OBJECT_0) << "Result = " << result <<
         "GetLastError = " << GetLastError();
 
     // We now own the mutex so we are the only process that can create the
     // window at this time, but we must still check if someone created it
     // between the time where we looked for it above and the time the mutex
     // was given to us.
     remote_window_ = FindWindowEx(HWND_MESSAGE, NULL,
                                   chrome::kMessageWindowClass,
                                   user_data_dir.value().c_str());
-    if (!remote_window_)
-      Create();
+    if (!remote_window_) {
+      HINSTANCE hinst = base::GetModuleFromAddress(&ThunkWndProc);
+
+      WNDCLASSEX wc = {0};
+      wc.cbSize = sizeof(wc);
+      wc.lpfnWndProc = base::win::WrappedWindowProc<ThunkWndProc>;
+      wc.hInstance = hinst;
+      wc.lpszClassName = chrome::kMessageWindowClass;
+      ATOM clazz = ::RegisterClassEx(&wc);
+      DCHECK(clazz);
+
+      FilePath user_data_dir;
+      PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+
+      // Set the window's title to the path of our user data directory so other
+      // Chrome instances can decide if they should forward to us or not.
+      window_ = ::CreateWindow(MAKEINTATOM(clazz),
+                               user_data_dir.value().c_str(),
+                               0, 0, 0, 0, 0, HWND_MESSAGE, 0, hinst, this);
+      CHECK(window_);
+    }
     BOOL success = ReleaseMutex(only_me);
     DCHECK(success) << "GetLastError = " << GetLastError();
   }
 }
 
 ProcessSingleton::~ProcessSingleton() {
-  if (window_) {
-    ::DestroyWindow(window_);
-    ::UnregisterClass(chrome::kMessageWindowClass, GetModuleHandle(NULL));
-  }
+  Cleanup();
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcess() {
   if (is_virtualized_)
     return PROCESS_NOTIFIED;  // We already spawned the process in this case.
   else if (!remote_window_)
     return PROCESS_NONE;
 
   // Found another window, send our command line to it
   // format is "START\0<<<current directory>>>\0<<<commandline>>>".
@@ skipping 63 matching lines @@
   // Time to take action. Kill the browser process.
   base::KillProcessById(process_id, content::RESULT_CODE_HUNG, true);
   remote_window_ = NULL;
   return PROCESS_NONE;
 }
 
 ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
   NotifyResult result = NotifyOtherProcess();
   if (result != PROCESS_NONE)
     return result;
-  return Create() ? PROCESS_NONE : PROFILE_IN_USE;
+  return window_ ? PROCESS_NONE : PROFILE_IN_USE;
 }
 
-// For windows, there is no need to call Create() since the call is made in
-// the constructor but to avoid having more platform specific code in
-// browser_main.cc we tolerate a second call which will do nothing.
+// On Windows, there is no need to call Create() since the message
+// window is created in the constructor but to avoid having more
+// platform specific code in browser_main.cc we tolerate calls to
+// Create(), which will do nothing.
 bool ProcessSingleton::Create() {
   DCHECK(!remote_window_);
-  if (window_)
-    return true;
-
-  HINSTANCE hinst = 0;
-  if (!::GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
-                            reinterpret_cast<char*>(&ThunkWndProc),
-                            &hinst)) {
-    NOTREACHED();
-  }
-
-  WNDCLASSEX wc = {0};
-  wc.cbSize = sizeof(wc);
-  wc.lpfnWndProc = base::win::WrappedWindowProc<ThunkWndProc>;
-  wc.hInstance = hinst;
-  wc.lpszClassName = chrome::kMessageWindowClass;
-  ATOM clazz = ::RegisterClassEx(&wc);
-  DCHECK(clazz);
-
-  FilePath user_data_dir;
-  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-
-  // Set the window's title to the path of our user data directory so other
-  // Chrome instances can decide if they should forward to us or not.
-  window_ = ::CreateWindow(MAKEINTATOM(clazz),
-                           user_data_dir.value().c_str(),
-                           0, 0, 0, 0, 0, HWND_MESSAGE, 0, hinst, this);
-  CHECK(window_);
-  return true;
+  return window_ != NULL;
 }
 
 void ProcessSingleton::Cleanup() {
+  // Window classes registered by DLLs are not cleaned up automatically on
+  // process exit, so we must unregister at the earliest chance possible.
+  // During the fast shutdown sequence, ProcessSingleton::Cleanup() is
+  // called if our process was the first to start.  Therefore we try cleaning
+  // up here, and again in the destructor if needed to catch as many cases
+  // as possible.
+  if (window_) {
+    ::DestroyWindow(window_);
+    ::UnregisterClass(chrome::kMessageWindowClass,
+                      base::GetModuleFromAddress(&ThunkWndProc));
+    window_ = NULL;
+  }
 }
 
 LRESULT ProcessSingleton::OnCopyData(HWND hwnd, const COPYDATASTRUCT* cds) {
   // If locked, it means we are not ready to process this message because
   // we are probably in a first run critical phase.
   if (locked_) {
 #if defined(USE_AURA)
     NOTIMPLEMENTED();
 #else
     // Attempt to place ourselves in the foreground / flash the task bar.
@@ skipping 99 matching lines @@
   switch (message) {
     case WM_COPYDATA:
       return OnCopyData(reinterpret_cast<HWND>(wparam),
                         reinterpret_cast<COPYDATASTRUCT*>(lparam));
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }