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

chrome/browser/process_singleton_linux.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.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 62 matching lines @@
 #include "base/safe_strerror_posix.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/browser_process.h"
 #if defined(TOOLKIT_GTK)
 #include "chrome/browser/ui/gtk/process_singleton_dialog.h"
 #endif
-#include "chrome/browser/io_thread.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/profiles/profile_manager.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 "content/public/browser/browser_thread.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::BrowserThread;
 
 const int ProcessSingleton::kTimeoutInSeconds;
@@ skipping 520 matching lines @@
   // we are probably in a first run critical phase.
   if (parent_->locked()) {
     DLOG(WARNING) << "Browser is locked";
     parent_->saved_startup_messages_.push_back(
         std::make_pair(argv, FilePath(current_dir)));
     // Send back "ACK" message to prevent the client process from starting up.
     reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1);
     return;
   }
 
-  // Ignore the request if the browser process is already in shutdown path.
-  if (!g_browser_process || g_browser_process->IsShuttingDown()) {
+  if (parent_->notification_callback_.Run(CommandLine(argv),
+                                          FilePath(current_dir))) {
+    // Send back "ACK" message to prevent the client process from starting up.
+    reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1);
+  } else {
     LOG(WARNING) << "Not handling interprocess notification as browser"
                     " is shutting down";
     // Send back "SHUTDOWN" message, so that the client process can start up
     // without killing this process.
     reader->FinishWithACK(kShutdownToken, arraysize(kShutdownToken) - 1);
     return;
   }
-
-  CommandLine parsed_command_line(argv);
-  parent_->ProcessCommandLine(parsed_command_line, FilePath(current_dir));
-
-  // Send back "ACK" message to prevent the client process from starting up.
-  reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1);
 }
 
 void ProcessSingleton::LinuxWatcher::RemoveSocketReader(SocketReader* reader) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(reader);
   readers_.erase(reader);
   delete reader;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ skipping 221 matching lines @@
     gdk_notify_startup_complete();
 #endif
     // Assume the other process is handling the request.
     return PROCESS_NOTIFIED;
   }
 
   NOTREACHED() << "The other process returned unknown message: " << buf;
   return PROCESS_NOTIFIED;
 }
 
-ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate() {
+ProcessSingleton::NotifyResult ProcessSingleton::NotifyOtherProcessOrCreate(
+    const NotificationCallback& notification_callback) {
   return NotifyOtherProcessWithTimeoutOrCreate(
       *CommandLine::ForCurrentProcess(),
+      notification_callback,
       kTimeoutInSeconds);
 }
 
 ProcessSingleton::NotifyResult
 ProcessSingleton::NotifyOtherProcessWithTimeoutOrCreate(
     const CommandLine& command_line,
+    const NotificationCallback& notification_callback,
     int timeout_seconds) {
   NotifyResult result = NotifyOtherProcessWithTimeout(command_line,
                                                       timeout_seconds, true);
   if (result != PROCESS_NONE)
     return result;
-  if (Create())
+  if (Create(notification_callback))
     return PROCESS_NONE;
   // If the Create() failed, try again to notify. (It could be that another
   // instance was starting at the same time and managed to grab the lock before
   // we did.)
   // This time, we don't want to kill anything if we aren't successful, since we
   // aren't going to try to take over the lock ourselves.
   result = NotifyOtherProcessWithTimeout(command_line, timeout_seconds, false);
   if (result != PROCESS_NONE)
     return result;
 
   return LOCK_ERROR;
 }
 
-bool ProcessSingleton::Create() {
+bool ProcessSingleton::Create(
+    const NotificationCallback& notification_callback) {
   int sock;
   sockaddr_un addr;
 
   // The symlink lock is pointed to the hostname and process id, so other
   // processes can find it out.
   FilePath symlink_content(base::StringPrintf(
       "%s%c%u",
       net::GetHostName().c_str(),
       kLockDelimiter,
       base::GetCurrentProcId()));
@@ skipping 36 matching lines @@
 
   if (bind(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr)) < 0) {
     PLOG(ERROR) << "Failed to bind() " << socket_target_path.value();
     CloseSocket(sock);
     return false;
   }
 
   if (listen(sock, 5) < 0)
     NOTREACHED() << "listen failed: " << safe_strerror(errno);
 
+  notification_callback_ = notification_callback;
+
   DCHECK(BrowserThread::IsMessageLoopValid(BrowserThread::IO));
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&ProcessSingleton::LinuxWatcher::StartListening,
                  watcher_.get(),
                  sock));
 
   return true;
 }
 
 void ProcessSingleton::Cleanup() {
   UnlinkPath(socket_path_);
   UnlinkPath(cookie_path_);
   UnlinkPath(lock_path_);
 }
-
-void ProcessSingleton::ProcessCommandLine(const CommandLine& command_line,
-                                          const FilePath& current_directory) {
-  PrefService* prefs = g_browser_process->local_state();
-  DCHECK(prefs);
-
-  // Ignore the request if the process was passed the --product-version flag.
-  // Normally we wouldn't get here if that flag had been passed, but it can
-  // happen if it is passed to an older version of chrome. Since newer versions
-  // of chrome do this in the background, we want to avoid spawning extra
-  // windows.
-  if (command_line.HasSwitch(switches::kProductVersion)) {
-    DLOG(WARNING) << "Remote process was passed product version flag, "
-                  << "but ignored it. Doing nothing.";
-  } else {
-    // Run the browser startup sequence again, with the command line of the
-    // signalling process.
-    BrowserInit::ProcessCommandLineAlreadyRunning(command_line,
-                                                  current_directory);
-  }
-}