Don't launch service process if it's already running

chrome/browser/service/service_process_control.cc

 // Copyright (c) 2010 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/service/service_process_control.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/process_util.h"
 #include "base/thread.h"
@@ skipping 73 matching lines @@
 ServiceProcessControl::ServiceProcessControl(Profile* profile,
                                              ServiceProcessType type)
     : profile_(profile),
       type_(type),
       message_handler_(NULL) {
 }
 
 ServiceProcessControl::~ServiceProcessControl() {
 }
 
-void ServiceProcessControl::Connect(Task* task) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+void ServiceProcessControl::ConnectInternal(Task* task) {
+  // If the channel has already been established then we run the task
+  // and return.
   if (channel_.get()) {
-    task->Run();
-    delete task;
+    if (task) {
+      task->Run();
+      delete task;
+    }
     return;
   }
 
-  // Saves the task.
+  // Actually going to connect.
+  LOG(INFO) << "Connecting to Service Process IPC Server";
   connect_done_task_.reset(task);
-  ConnectInternal();
-}
 
-void ServiceProcessControl::ConnectInternal() {
-  LOG(INFO) << "Connecting to Service Process IPC Server";
   // Run the IPC channel on the shared IO thread.
   base::Thread* io_thread = g_browser_process->io_thread();
 
   // TODO(hclam): Determine the the channel id from profile and type.
   // TODO(hclam): Handle error connecting to channel.
   const std::string channel_id = GetServiceProcessChannelName(type_);
   channel_.reset(
       new IPC::SyncChannel(channel_id, IPC::Channel::MODE_CLIENT, this, NULL,
                            io_thread->message_loop(), true,
                            g_browser_process->shutdown_event()));
   channel_->set_sync_messages_with_no_timeout_allowed(false);
 }
 
 void ServiceProcessControl::Launch(Task* task) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
-  if (channel_.get()) {
-    if (task) {
-      task->Run();
-      delete task;
-    }
+
+  // If the service process is already running then connects to it.
+  if (CheckServiceProcessRunning(kServiceProcessCloudPrint)) {
+    ConnectInternal(task);
     return;
   }
 
   // A service process should have a different mechanism for starting, but now
   // we start it as if it is a child process.
   FilePath exe_path = ChildProcessHost::GetChildPath(true);
   if (exe_path.empty()) {
     NOTREACHED() << "Unable to get service process binary name.";
   }
 
@@ skipping 18 matching lines @@
 
   // And then start the process asynchronously.
   launcher_ = new Launcher(this, cmd_line);
   launcher_->Run(
       NewRunnableMethod(this, &ServiceProcessControl::OnProcessLaunched, task));
 }
 
 void ServiceProcessControl::OnProcessLaunched(Task* task) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   if (launcher_->launched()) {
-    // Now use the launch task as the connect task.
-    connect_done_task_.reset(task);
-
     // After we have successfully created the service process we try to connect
     // to it. The launch task is transfered to a connect task.
-    ConnectInternal();
+    ConnectInternal(task);
   } else if (task) {
     // If we don't have process handle that means launching the service process
     // has failed.
     task->Run();
     delete task;
   }
 
   // We don't need the launcher anymore.
   launcher_ = NULL;
 }
@@ skipping 43 matching lines @@
 bool ServiceProcessControl::EnableRemotingWithTokens(
     const std::string& user,
     const std::string& remoting_token,
     const std::string& talk_token) {
   return Send(
       new ServiceMsg_EnableRemotingWithTokens(user, remoting_token,
                                               talk_token));
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ServiceProcessControl);