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