chrome/browser/service_process/service_process_control.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/service_process/service_process_control.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/command_line.h"
  10 #include "base/files/file_path.h"
  11 #include "base/metrics/histogram_base.h"
  12 #include "base/metrics/histogram_delta_serialization.h"
  13 #include "base/process/kill.h"
  14 #include "base/process/launch.h"
  15 #include "base/stl_util.h"
  16 #include "base/threading/thread.h"
  17 #include "base/threading/thread_restrictions.h"
  18 #include "chrome/browser/browser_process.h"
  19 #include "chrome/browser/chrome_notification_types.h"
  20 #include "chrome/browser/upgrade_detector.h"
  21 #include "chrome/common/chrome_switches.h"
  22 #include "chrome/common/service_messages.h"
  23 #include "chrome/common/service_process_util.h"
  24 #include "content/public/browser/browser_thread.h"
  25 #include "content/public/browser/notification_service.h"
  26 #include "content/public/common/child_process_host.h"
  27 #include "google_apis/gaia/gaia_switches.h"
  28 #include "ui/base/ui_base_switches.h"
  29
  30 using content::BrowserThread;
  31 using content::ChildProcessHost;
  32
  33 // ServiceProcessControl implementation.
  34 ServiceProcessControl::ServiceProcessControl() {
  35 }
  36
  37 ServiceProcessControl::~ServiceProcessControl() {
  38 }
  39
  40 void ServiceProcessControl::ConnectInternal() {
  41   // If the channel has already been established then we run the task
  42   // and return.
  43   if (channel_.get()) {
  44     RunConnectDoneTasks();
  45     return;
  46   }
  47
  48   // Actually going to connect.
  49   VLOG(1) << "Connecting to Service Process IPC Server";
  50
  51   // TODO(hclam): Handle error connecting to channel.
  52   const IPC::ChannelHandle channel_id = GetServiceProcessChannel();
  53   SetChannel(new IPC::ChannelProxy(
  54       channel_id,
  55       IPC::Channel::MODE_NAMED_CLIENT,
  56       this,
  57       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO).get()));
  58 }
  59
  60 void ServiceProcessControl::SetChannel(IPC::ChannelProxy* channel) {
  61   channel_.reset(channel);
  62 }
  63
  64 void ServiceProcessControl::RunConnectDoneTasks() {
  65   // The tasks executed here may add more tasks to the vector. So copy
  66   // them to the stack before executing them. This way recursion is
  67   // avoided.
  68   TaskList tasks;
  69
  70   if (IsConnected()) {
  71     tasks.swap(connect_success_tasks_);
  72     RunAllTasksHelper(&tasks);
  73     DCHECK(tasks.empty());
  74     connect_failure_tasks_.clear();
  75   } else {
  76     tasks.swap(connect_failure_tasks_);
  77     RunAllTasksHelper(&tasks);
  78     DCHECK(tasks.empty());
  79     connect_success_tasks_.clear();
  80   }
  81 }
  82
  83 // static
  84 void ServiceProcessControl::RunAllTasksHelper(TaskList* task_list) {
  85   TaskList::iterator index = task_list->begin();
  86   while (index != task_list->end()) {
  87     (*index).Run();
  88     index = task_list->erase(index);
  89   }
  90 }
  91
  92 bool ServiceProcessControl::IsConnected() const {
  93   return channel_ != NULL;
  94 }
  95
  96 void ServiceProcessControl::Launch(const base::Closure& success_task,
  97                                    const base::Closure& failure_task) {
  98   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
  99
 100   base::Closure failure = failure_task;
 101   if (!success_task.is_null())
 102     connect_success_tasks_.push_back(success_task);
 103
 104   if (!failure.is_null())
 105     connect_failure_tasks_.push_back(failure);
 106
 107   // If we already in the process of launching, then we are done.
 108   if (launcher_.get())
 109     return;
 110
 111   // If the service process is already running then connects to it.
 112   if (CheckServiceProcessReady()) {
 113     ConnectInternal();
 114     return;
 115   }
 116
 117   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents", SERVICE_EVENT_LAUNCH,
 118                             SERVICE_EVENT_MAX);
 119
 120   // A service process should have a different mechanism for starting, but now
 121   // we start it as if it is a child process.
 122
 123 #if defined(OS_LINUX)
 124   int flags = ChildProcessHost::CHILD_ALLOW_SELF;
 125 #else
 126   int flags = ChildProcessHost::CHILD_NORMAL;
 127 #endif
 128
 129   base::FilePath exe_path = ChildProcessHost::GetChildPath(flags);
 130   if (exe_path.empty())
 131     NOTREACHED() << "Unable to get service process binary name.";
 132
 133   CommandLine* cmd_line = new CommandLine(exe_path);
 134   cmd_line->AppendSwitchASCII(switches::kProcessType,
 135                               switches::kServiceProcess);
 136
 137   static const char* const kSwitchesToCopy[] = {
 138     switches::kCloudPrintServiceURL,
 139     switches::kCloudPrintSetupProxy,
 140     switches::kEnableLogging,
 141     switches::kIgnoreUrlFetcherCertRequests,
 142     switches::kLang,
 143     switches::kLoggingLevel,
 144     switches::kLsoUrl,
 145     switches::kNoServiceAutorun,
 146     switches::kUserDataDir,
 147     switches::kV,
 148     switches::kVModule,
 149     switches::kWaitForDebugger,
 150   };
 151   cmd_line->CopySwitchesFrom(*CommandLine::ForCurrentProcess(),
 152                              kSwitchesToCopy,
 153                              arraysize(kSwitchesToCopy));
 154
 155   // And then start the process asynchronously.
 156   launcher_ = new Launcher(this, cmd_line);
 157   launcher_->Run(base::Bind(&ServiceProcessControl::OnProcessLaunched,
 158                             base::Unretained(this)));
 159 }
 160
 161 void ServiceProcessControl::Disconnect() {
 162   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 163   channel_.reset();
 164 }
 165
 166 void ServiceProcessControl::OnProcessLaunched() {
 167   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 168   if (launcher_->launched()) {
 169     UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 170                               SERVICE_EVENT_LAUNCHED, SERVICE_EVENT_MAX);
 171     // After we have successfully created the service process we try to connect
 172     // to it. The launch task is transfered to a connect task.
 173     ConnectInternal();
 174   } else {
 175     UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 176                               SERVICE_EVENT_LAUNCH_FAILED, SERVICE_EVENT_MAX);
 177     // If we don't have process handle that means launching the service process
 178     // has failed.
 179     RunConnectDoneTasks();
 180   }
 181
 182   // We don't need the launcher anymore.
 183   launcher_ = NULL;
 184 }
 185
 186 bool ServiceProcessControl::OnMessageReceived(const IPC::Message& message) {
 187   bool handled = true;
 188   IPC_BEGIN_MESSAGE_MAP(ServiceProcessControl, message)
 189     IPC_MESSAGE_HANDLER(ServiceHostMsg_CloudPrintProxy_Info,
 190                         OnCloudPrintProxyInfo)
 191     IPC_MESSAGE_HANDLER(ServiceHostMsg_Histograms, OnHistograms)
 192     IPC_MESSAGE_UNHANDLED(handled = false)
 193   IPC_END_MESSAGE_MAP()
 194   return handled;
 195 }
 196
 197 void ServiceProcessControl::OnChannelConnected(int32 peer_pid) {
 198   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 199
 200   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 201                             SERVICE_EVENT_CHANNEL_CONNECTED, SERVICE_EVENT_MAX);
 202
 203   // We just established a channel with the service process. Notify it if an
 204   // upgrade is available.
 205   if (UpgradeDetector::GetInstance()->notify_upgrade()) {
 206     Send(new ServiceMsg_UpdateAvailable);
 207   } else {
 208     if (registrar_.IsEmpty())
 209       registrar_.Add(this, chrome::NOTIFICATION_UPGRADE_RECOMMENDED,
 210                      content::NotificationService::AllSources());
 211   }
 212   RunConnectDoneTasks();
 213 }
 214
 215 void ServiceProcessControl::OnChannelError() {
 216   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 217
 218   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 219                             SERVICE_EVENT_CHANNEL_ERROR, SERVICE_EVENT_MAX);
 220
 221   channel_.reset();
 222   RunConnectDoneTasks();
 223 }
 224
 225 bool ServiceProcessControl::Send(IPC::Message* message) {
 226   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 227   if (!channel_.get())
 228     return false;
 229   return channel_->Send(message);
 230 }
 231
 232 // content::NotificationObserver implementation.
 233 void ServiceProcessControl::Observe(
 234     int type,
 235     const content::NotificationSource& source,
 236     const content::NotificationDetails& details) {
 237   if (type == chrome::NOTIFICATION_UPGRADE_RECOMMENDED) {
 238     Send(new ServiceMsg_UpdateAvailable);
 239   }
 240 }
 241
 242 void ServiceProcessControl::OnCloudPrintProxyInfo(
 243     const cloud_print::CloudPrintProxyInfo& proxy_info) {
 244   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 245   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 246                             SERVICE_EVENT_INFO_REPLY, SERVICE_EVENT_MAX);
 247   if (!cloud_print_info_callback_.is_null()) {
 248     cloud_print_info_callback_.Run(proxy_info);
 249     cloud_print_info_callback_.Reset();
 250   }
 251 }
 252
 253 void ServiceProcessControl::OnHistograms(
 254     const std::vector<std::string>& pickled_histograms) {
 255   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 256                             SERVICE_EVENT_HISTOGRAMS_REPLY, SERVICE_EVENT_MAX);
 257   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 258   base::HistogramDeltaSerialization::DeserializeAndAddSamples(
 259       pickled_histograms);
 260   RunHistogramsCallback();
 261 }
 262
 263 void ServiceProcessControl::RunHistogramsCallback() {
 264   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 265   if (!histograms_callback_.is_null()) {
 266     histograms_callback_.Run();
 267     histograms_callback_.Reset();
 268   }
 269   histograms_timeout_callback_.Cancel();
 270 }
 271
 272 bool ServiceProcessControl::GetCloudPrintProxyInfo(
 273     const CloudPrintProxyInfoHandler& cloud_print_info_callback) {
 274   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 275   DCHECK(!cloud_print_info_callback.is_null());
 276   cloud_print_info_callback_.Reset();
 277   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 278                             SERVICE_EVENT_INFO_REQUEST, SERVICE_EVENT_MAX);
 279   if (!Send(new ServiceMsg_GetCloudPrintProxyInfo()))
 280     return false;
 281   cloud_print_info_callback_ = cloud_print_info_callback;
 282   return true;
 283 }
 284
 285 bool ServiceProcessControl::GetHistograms(
 286     const base::Closure& histograms_callback,
 287     const base::TimeDelta& timeout) {
 288   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 289   DCHECK(!histograms_callback.is_null());
 290   histograms_callback_.Reset();
 291
 292   // If the service process is already running then connect to it.
 293   if (!CheckServiceProcessReady())
 294     return false;
 295   ConnectInternal();
 296
 297   UMA_HISTOGRAM_ENUMERATION("CloudPrint.ServiceEvents",
 298                             SERVICE_EVENT_HISTOGRAMS_REQUEST,
 299                             SERVICE_EVENT_MAX);
 300
 301   if (!Send(new ServiceMsg_GetHistograms()))
 302     return false;
 303
 304   // Run timeout task to make sure |histograms_callback| is called.
 305   histograms_timeout_callback_.Reset(
 306       base::Bind(&ServiceProcessControl::RunHistogramsCallback,
 307                  base::Unretained(this)));
 308   BrowserThread::PostDelayedTask(BrowserThread::UI, FROM_HERE,
 309                                  histograms_timeout_callback_.callback(),
 310                                  timeout);
 311
 312   histograms_callback_ = histograms_callback;
 313   return true;
 314 }
 315
 316 bool ServiceProcessControl::Shutdown() {
 317   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 318   bool ret = Send(new ServiceMsg_Shutdown());
 319   channel_.reset();
 320   return ret;
 321 }
 322
 323 // static
 324 ServiceProcessControl* ServiceProcessControl::GetInstance() {
 325   return Singleton<ServiceProcessControl>::get();
 326 }
 327
 328 ServiceProcessControl::Launcher::Launcher(ServiceProcessControl* process,
 329                                           CommandLine* cmd_line)
 330     : process_(process),
 331       cmd_line_(cmd_line),
 332       launched_(false),
 333       retry_count_(0),
 334       process_handle_(base::kNullProcessHandle) {
 335 }
 336
 337 // Execute the command line to start the process asynchronously.
 338 // After the command is executed, |task| is called with the process handle on
 339 // the UI thread.
 340 void ServiceProcessControl::Launcher::Run(const base::Closure& task) {
 341   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 342   notify_task_ = task;
 343   BrowserThread::PostTask(BrowserThread::PROCESS_LAUNCHER, FROM_HERE,
 344                           base::Bind(&Launcher::DoRun, this));
 345 }
 346
 347 ServiceProcessControl::Launcher::~Launcher() {
 348   CloseProcessHandle();
 349 }
 350
 351
 352 void ServiceProcessControl::Launcher::Notify() {
 353   DCHECK(!notify_task_.is_null());
 354   notify_task_.Run();
 355   notify_task_.Reset();
 356 }
 357
 358 void ServiceProcessControl::Launcher::CloseProcessHandle() {
 359   if (process_handle_ != base::kNullProcessHandle) {
 360     base::CloseProcessHandle(process_handle_);
 361     process_handle_ = base::kNullProcessHandle;
 362   }
 363 }
 364
 365 #if !defined(OS_MACOSX)
 366 void ServiceProcessControl::Launcher::DoDetectLaunched() {
 367   DCHECK(!notify_task_.is_null());
 368
 369   const uint32 kMaxLaunchDetectRetries = 10;
 370   launched_ = CheckServiceProcessReady();
 371
 372   int exit_code = 0;
 373   if (launched_ || (retry_count_ >= kMaxLaunchDetectRetries) ||
 374       base::WaitForExitCodeWithTimeout(process_handle_, &exit_code,
 375                                        base::TimeDelta())) {
 376     CloseProcessHandle();
 377     BrowserThread::PostTask(
 378         BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
 379     return;
 380   }
 381   retry_count_++;
 382
 383   // If the service process is not launched yet then check again in 2 seconds.
 384   const base::TimeDelta kDetectLaunchRetry = base::TimeDelta::FromSeconds(2);
 385   base::MessageLoop::current()->PostDelayedTask(
 386       FROM_HERE, base::Bind(&Launcher::DoDetectLaunched, this),
 387       kDetectLaunchRetry);
 388 }
 389
 390 void ServiceProcessControl::Launcher::DoRun() {
 391   DCHECK(!notify_task_.is_null());
 392
 393   base::LaunchOptions options;
 394 #if defined(OS_WIN)
 395   options.start_hidden = true;
 396 #endif
 397   if (base::LaunchProcess(*cmd_line_, options, &process_handle_)) {
 398     BrowserThread::PostTask(
 399         BrowserThread::IO, FROM_HERE,
 400         base::Bind(&Launcher::DoDetectLaunched, this));
 401   } else {
 402     BrowserThread::PostTask(
 403         BrowserThread::UI, FROM_HERE, base::Bind(&Launcher::Notify, this));
 404   }
 405 }
 406 #endif  // !OS_MACOSX