Resubmit r56600 - Start/stop service process when browser starts and stop

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 92 matching lines @@
   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()) {
-    task->Run();
-    delete task;
+    if (task) {
+      task->Run();
+      delete 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.";
   }
 
   CommandLine* cmd_line = new CommandLine(exe_path);
   cmd_line->AppendSwitchASCII(switches::kProcessType,
                               switches::kServiceProcess);
 
   const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
   FilePath user_data_dir =
       browser_command_line.GetSwitchValuePath(switches::kUserDataDir);
   if (!user_data_dir.empty())
     cmd_line->AppendSwitchPath(switches::kUserDataDir, user_data_dir);
 
   std::string logging_level = browser_command_line.GetSwitchValueASCII(
       switches::kLoggingLevel);
   if (!logging_level.empty())
     cmd_line->AppendSwitchASCII(switches::kLoggingLevel, logging_level);
 
+  if (browser_command_line.HasSwitch(switches::kWaitForDebuggerChildren)) {
+    cmd_line->AppendSwitch(switches::kWaitForDebugger);
+  }
+
   // 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();
-  } else {
+  } 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;
 }
 
 void ServiceProcessControl::OnMessageReceived(const IPC::Message& message) {
   if (!message_handler_)
     return;
 
   if (message.type() == ServiceHostMsg_GoodDay::ID)
     message_handler_->OnGoodDay();
 }
 
 void ServiceProcessControl::OnChannelConnected(int32 peer_pid) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (!connect_done_task_.get())
+    return;
   connect_done_task_->Run();
   connect_done_task_.reset();
 }
 
 void ServiceProcessControl::OnChannelError() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   channel_.reset();
+  if (!connect_done_task_.get())
+    return;
   connect_done_task_->Run();
   connect_done_task_.reset();
 }
 
 bool ServiceProcessControl::Send(IPC::Message* message) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (!channel_.get())
+    return false;
   return channel_->Send(message);
 }
 
 bool ServiceProcessControl::SendHello() {
   return Send(new ServiceMsg_Hello());
 }
 
 bool ServiceProcessControl::Shutdown() {
   bool ret = Send(new ServiceMsg_Shutdown());
   channel_.reset();
   return ret;
 }
 
 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);