Refactor ProcessSingleton so that it may be used distinctly from a full browser process.

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"
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/wrapped_window_proc.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/extensions/extensions_startup.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/simple_message_box.h"
-#include "chrome/browser/ui/browser_init.h"
 #include "chrome/common/chrome_constants.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/installer/util/wmi.h"
 #include "content/public/common/result_codes.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/win/hwnd_util.h"
 
 namespace {
 
 // Checks the visibility of the enumerated window and signals once a visible
@@ skipping 152 matching lines @@
       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();
   }
@@ skipping 73 matching lines @@
       return PROCESS_NOTIFIED;
     }
   }
 
   // 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() {
+ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate(
+    const NotificationCallback& notification_callback) {
   NotifyResult result = NotifyOtherProcess();
   if (result != PROCESS_NONE)
     return result;
-  return window_ ? PROCESS_NONE : PROFILE_IN_USE;
+  return Create(notification_callback) ? PROCESS_NONE : PROFILE_IN_USE;
 }
 
 // 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() {
+// Create().
+bool ProcessSingleton::Create(
+    const NotificationCallback& notification_callback) {
   DCHECK(!remote_window_);
+  DCHECK(notification_callback_.is_null());
+
+  if (window_ != NULL)
+    notification_callback_ = notification_callback;
+
   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.
@@ skipping 21 matching lines @@
       CommandLine parsed_command_line(CommandLine::NO_PROGRAM);
       FilePath current_directory;
       if (ParseCommandLine(cds, &parsed_command_line, &current_directory))
         saved_startup_messages_.push_back(
             std::make_pair(parsed_command_line.argv(), current_directory));
     }
 #endif
     return TRUE;
   }
 
-  // Ignore the request if the browser process is already in shutdown path.
-  if (!g_browser_process || g_browser_process->IsShuttingDown()) {
-    LOG(WARNING) << "Not handling WM_COPYDATA as browser is shutting down";
-    return FALSE;
-  }
-
   CommandLine parsed_command_line(CommandLine::NO_PROGRAM);
   FilePath current_directory;
   if (!ParseCommandLine(cds, &parsed_command_line, &current_directory))
     return TRUE;
-  ProcessCommandLine(parsed_command_line, current_directory);
-  return TRUE;
+  return notification_callback_.Run(parsed_command_line, current_directory) ?
+      TRUE : FALSE;
 }
 
 LRESULT ProcessSingleton::WndProc(HWND hwnd, UINT message,
                                   WPARAM wparam, LPARAM lparam) {
   switch (message) {
     case WM_COPYDATA:
       return OnCopyData(reinterpret_cast<HWND>(wparam),
                         reinterpret_cast<COPYDATASTRUCT*>(lparam));
     default:
       break;
   }
 
   return ::DefWindowProc(hwnd, message, wparam, lparam);
 }
-
-void ProcessSingleton::ProcessCommandLine(const CommandLine& command_line,
-                                          const FilePath& current_directory) {
-  PrefService* prefs = g_browser_process->local_state();
-  DCHECK(prefs);
-
-  // Handle the --uninstall-extension startup action. This needs to done here
-  // in the process that is running with the target profile, otherwise the
-  // uninstall will fail to unload and remove all components.
-  if (command_line.HasSwitch(switches::kUninstallExtension)) {
-    // The uninstall extension switch can't be combined with the profile
-    // directory switch.
-    DCHECK(!command_line.HasSwitch(switches::kProfileDirectory));
-
-    Profile* profile = ProfileManager::GetLastUsedProfile();
-    if (!profile) {
-      // We should only be able to get here if the profile already exists and
-      // has been created.
-      NOTREACHED();
-      return;
-    }
-
-    ExtensionsStartupUtil ext_startup_util;
-    ext_startup_util.UninstallExtension(command_line, profile);
-    return;
-  }
-
-  // Run the browser startup sequence again, with the command line of the
-  // signalling process.
-  BrowserInit::ProcessCommandLineAlreadyRunning(command_line,
-                                                current_directory);
-}