src/chrome/service/service_process.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/service/service_process.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/basictypes.h"
  10 #include "base/callback.h"
  11 #include "base/command_line.h"
  12 #include "base/environment.h"
  13 #include "base/i18n/rtl.h"
  14 #include "base/memory/singleton.h"
  15 #include "base/path_service.h"
  16 #include "base/prefs/json_pref_store.h"
  17 #include "base/strings/string16.h"
  18 #include "base/strings/utf_string_conversions.h"
  19 #include "base/values.h"
  20 #include "chrome/common/chrome_constants.h"
  21 #include "chrome/common/chrome_paths.h"
  22 #include "chrome/common/chrome_switches.h"
  23 #include "chrome/common/env_vars.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "chrome/common/service_process_util.h"
  26 #include "chrome/service/cloud_print/cloud_print_proxy.h"
  27 #include "chrome/service/net/service_url_request_context.h"
  28 #include "chrome/service/service_ipc_server.h"
  29 #include "chrome/service/service_process_prefs.h"
  30 #include "grit/chromium_strings.h"
  31 #include "grit/generated_resources.h"
  32 #include "net/base/network_change_notifier.h"
  33 #include "net/url_request/url_fetcher.h"
  34 #include "ui/base/l10n/l10n_util.h"
  35 #include "ui/base/resource/resource_bundle.h"
  36 #include "ui/base/ui_base_switches.h"
  37
  38 #if defined(OS_LINUX) || defined(OS_OPENBSD)
  39 #include <glib-object.h>
  40 #endif
  41
  42 #if defined(TOOLKIT_GTK)
  43 #include <gtk/gtk.h>
  44 #include "ui/gfx/gtk_util.h"
  45 #endif
  46
  47 ServiceProcess* g_service_process = NULL;
  48
  49 namespace {
  50
  51 // Delay in seconds after the last service is disabled before we attempt
  52 // a shutdown.
  53 const int kShutdownDelaySeconds = 60;
  54
  55 // Delay in hours between launching a browser process to check the
  56 // policy for us.
  57 const int64 kPolicyCheckDelayHours = 8;
  58
  59 const char kDefaultServiceProcessLocale[] = "en-US";
  60
  61 class ServiceIOThread : public base::Thread {
  62  public:
  63   explicit ServiceIOThread(const char* name);
  64   virtual ~ServiceIOThread();
  65
  66  protected:
  67   virtual void CleanUp() OVERRIDE;
  68
  69  private:
  70   DISALLOW_COPY_AND_ASSIGN(ServiceIOThread);
  71 };
  72
  73 ServiceIOThread::ServiceIOThread(const char* name) : base::Thread(name) {}
  74 ServiceIOThread::~ServiceIOThread() {
  75   Stop();
  76 }
  77
  78 void ServiceIOThread::CleanUp() {
  79   net::URLFetcher::CancelAll();
  80 }
  81
  82 // Prepares the localized strings that are going to be displayed to
  83 // the user if the service process dies. These strings are stored in the
  84 // environment block so they are accessible in the early stages of the
  85 // chrome executable's lifetime.
  86 void PrepareRestartOnCrashEnviroment(
  87     const CommandLine &parsed_command_line) {
  88   scoped_ptr<base::Environment> env(base::Environment::Create());
  89   // Clear this var so child processes don't show the dialog by default.
  90   env->UnSetVar(env_vars::kShowRestart);
  91
  92   // For non-interactive tests we don't restart on crash.
  93   if (env->HasVar(env_vars::kHeadless))
  94     return;
  95
  96   // If the known command-line test options are used we don't create the
  97   // environment block which means we don't get the restart dialog.
  98   if (parsed_command_line.HasSwitch(switches::kNoErrorDialogs))
  99     return;
 100
 101   // The encoding we use for the info is "title|context|direction" where
 102   // direction is either env_vars::kRtlLocale or env_vars::kLtrLocale depending
 103   // on the current locale.
 104   string16 dlg_strings(l10n_util::GetStringUTF16(IDS_CRASH_RECOVERY_TITLE));
 105   dlg_strings.push_back('|');
 106   string16 adjusted_string(
 107       l10n_util::GetStringFUTF16(IDS_SERVICE_CRASH_RECOVERY_CONTENT,
 108       l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT)));
 109   base::i18n::AdjustStringForLocaleDirection(&adjusted_string);
 110   dlg_strings.append(adjusted_string);
 111   dlg_strings.push_back('|');
 112   dlg_strings.append(ASCIIToUTF16(
 113       base::i18n::IsRTL() ? env_vars::kRtlLocale : env_vars::kLtrLocale));
 114
 115   env->SetVar(env_vars::kRestartInfo, UTF16ToUTF8(dlg_strings));
 116 }
 117
 118 }  // namespace
 119
 120 ServiceProcess::ServiceProcess()
 121   : shutdown_event_(true, false),
 122     main_message_loop_(NULL),
 123     enabled_services_(0),
 124     update_available_(false) {
 125   DCHECK(!g_service_process);
 126   g_service_process = this;
 127 }
 128
 129 bool ServiceProcess::Initialize(base::MessageLoopForUI* message_loop,
 130                                 const CommandLine& command_line,
 131                                 ServiceProcessState* state) {
 132 #if defined(TOOLKIT_GTK)
 133   // TODO(jamiewalch): Calling GtkInitFromCommandLine here causes the process
 134   // to abort if run headless. The correct fix for this is to refactor the
 135   // service process to be more modular, a task that is currently underway.
 136   // However, since this problem is blocking cloud print, the following quick
 137   // hack will have to do. Note that the situation with this hack in place is
 138   // no worse than it was when we weren't initializing GTK at all.
 139   int argc = 1;
 140   scoped_ptr<char*[]> argv(new char*[2]);
 141   argv[0] = strdup(command_line.argv()[0].c_str());
 142   argv[1] = NULL;
 143   char **argv_pointer = argv.get();
 144   gtk_init_check(&argc, &argv_pointer);
 145   free(argv[0]);
 146 #elif defined(OS_LINUX) || defined(OS_OPENBSD)
 147   // g_type_init has been deprecated since version 2.35.
 148 #if !GLIB_CHECK_VERSION(2, 35, 0)
 149   // GLib type system initialization is needed for gconf.
 150   g_type_init();
 151 #endif
 152 #endif // defined(OS_LINUX) || defined(OS_OPENBSD)
 153   main_message_loop_ = message_loop;
 154   service_process_state_.reset(state);
 155   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
 156   base::Thread::Options options;
 157   options.message_loop_type = base::MessageLoop::TYPE_IO;
 158   io_thread_.reset(new ServiceIOThread("ServiceProcess_IO"));
 159   file_thread_.reset(new base::Thread("ServiceProcess_File"));
 160   if (!io_thread_->StartWithOptions(options) ||
 161       !file_thread_->StartWithOptions(options)) {
 162     NOTREACHED();
 163     Teardown();
 164     return false;
 165   }
 166   blocking_pool_ = new base::SequencedWorkerPool(3, "ServiceBlocking");
 167
 168   request_context_getter_ = new ServiceURLRequestContextGetter();
 169
 170   base::FilePath user_data_dir;
 171   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 172   base::FilePath pref_path =
 173       user_data_dir.Append(chrome::kServiceStateFileName);
 174   service_prefs_.reset(new ServiceProcessPrefs(
 175       pref_path,
 176       JsonPrefStore::GetTaskRunnerForFile(pref_path, blocking_pool_.get())
 177           .get()));
 178   service_prefs_->ReadPrefs();
 179
 180   // This switch it required to run connector with test gaia.
 181   if (command_line.HasSwitch(switches::kIgnoreUrlFetcherCertRequests))
 182     net::URLFetcher::SetIgnoreCertificateRequests(true);
 183
 184   // Check if a locale override has been specified on the command-line.
 185   std::string locale = command_line.GetSwitchValueASCII(switches::kLang);
 186   if (!locale.empty()) {
 187     service_prefs_->SetString(prefs::kApplicationLocale, locale);
 188     service_prefs_->WritePrefs();
 189   } else {
 190     // If no command-line value was specified, read the last used locale from
 191     // the prefs.
 192     locale =
 193         service_prefs_->GetString(prefs::kApplicationLocale, std::string());
 194     // If no locale was specified anywhere, use the default one.
 195     if (locale.empty())
 196       locale = kDefaultServiceProcessLocale;
 197   }
 198   ResourceBundle::InitSharedInstanceWithLocale(locale, NULL);
 199
 200   PrepareRestartOnCrashEnviroment(command_line);
 201
 202   // Enable Cloud Print if needed. First check the command-line.
 203   // Then check if the cloud print proxy was previously enabled.
 204   if (command_line.HasSwitch(switches::kEnableCloudPrintProxy) ||
 205       service_prefs_->GetBoolean(prefs::kCloudPrintProxyEnabled, false)) {
 206     GetCloudPrintProxy()->EnableForUser();
 207   }
 208
 209   VLOG(1) << "Starting Service Process IPC Server";
 210   ipc_server_.reset(new ServiceIPCServer(
 211       service_process_state_->GetServiceProcessChannel()));
 212   ipc_server_->Init();
 213
 214   // After the IPC server has started we signal that the service process is
 215   // ready.
 216   if (!service_process_state_->SignalReady(
 217           io_thread_->message_loop_proxy().get(),
 218           base::Bind(&ServiceProcess::Terminate, base::Unretained(this)))) {
 219     return false;
 220   }
 221
 222   // See if we need to stay running.
 223   ScheduleShutdownCheck();
 224
 225   // Occasionally check to see if we need to launch the browser to get the
 226   // policy state information.
 227   CloudPrintPolicyCheckIfNeeded();
 228   return true;
 229 }
 230
 231 bool ServiceProcess::Teardown() {
 232   service_prefs_.reset();
 233   cloud_print_proxy_.reset();
 234
 235   ipc_server_.reset();
 236   // Signal this event before shutting down the service process. That way all
 237   // background threads can cleanup.
 238   shutdown_event_.Signal();
 239   io_thread_.reset();
 240   file_thread_.reset();
 241
 242   if (blocking_pool_.get()) {
 243     // The goal is to make it impossible for chrome to 'infinite loop' during
 244     // shutdown, but to reasonably expect that all BLOCKING_SHUTDOWN tasks
 245     // queued during shutdown get run. There's nothing particularly scientific
 246     // about the number chosen.
 247     const int kMaxNewShutdownBlockingTasks = 1000;
 248     blocking_pool_->Shutdown(kMaxNewShutdownBlockingTasks);
 249     blocking_pool_ = NULL;
 250   }
 251
 252   // The NetworkChangeNotifier must be destroyed after all other threads that
 253   // might use it have been shut down.
 254   network_change_notifier_.reset();
 255
 256   service_process_state_->SignalStopped();
 257   return true;
 258 }
 259
 260 // This method is called when a shutdown command is received from IPC channel
 261 // or there was an error in the IPC channel.
 262 void ServiceProcess::Shutdown() {
 263 #if defined(OS_MACOSX)
 264   // On MacOS X the service must be removed from the launchd job list.
 265   // http://www.chromium.org/developers/design-documents/service-processes
 266   // The best way to do that is to go through the ForceServiceProcessShutdown
 267   // path. If it succeeds Terminate() will be called from the handler registered
 268   // via service_process_state_->SignalReady().
 269   // On failure call Terminate() directly to force the process to actually
 270   // terminate.
 271   if (!ForceServiceProcessShutdown("", 0)) {
 272     Terminate();
 273   }
 274 #else
 275   Terminate();
 276 #endif
 277 }
 278
 279 void ServiceProcess::Terminate() {
 280   main_message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 281 }
 282
 283 bool ServiceProcess::HandleClientDisconnect() {
 284   // If there are no enabled services or if there is an update available
 285   // we want to shutdown right away. Else we want to keep listening for
 286   // new connections.
 287   if (!enabled_services_ || update_available()) {
 288     Shutdown();
 289     return false;
 290   }
 291   return true;
 292 }
 293
 294 cloud_print::CloudPrintProxy* ServiceProcess::GetCloudPrintProxy() {
 295   if (!cloud_print_proxy_.get()) {
 296     cloud_print_proxy_.reset(new cloud_print::CloudPrintProxy());
 297     cloud_print_proxy_->Initialize(service_prefs_.get(), this);
 298   }
 299   return cloud_print_proxy_.get();
 300 }
 301
 302 void ServiceProcess::OnCloudPrintProxyEnabled(bool persist_state) {
 303   if (persist_state) {
 304     // Save the preference that we have enabled the cloud print proxy.
 305     service_prefs_->SetBoolean(prefs::kCloudPrintProxyEnabled, true);
 306     service_prefs_->WritePrefs();
 307   }
 308   OnServiceEnabled();
 309 }
 310
 311 void ServiceProcess::OnCloudPrintProxyDisabled(bool persist_state) {
 312   if (persist_state) {
 313     // Save the preference that we have disabled the cloud print proxy.
 314     service_prefs_->SetBoolean(prefs::kCloudPrintProxyEnabled, false);
 315     service_prefs_->WritePrefs();
 316   }
 317   OnServiceDisabled();
 318 }
 319
 320 ServiceURLRequestContextGetter*
 321 ServiceProcess::GetServiceURLRequestContextGetter() {
 322   DCHECK(request_context_getter_.get());
 323   return request_context_getter_.get();
 324 }
 325
 326 void ServiceProcess::OnServiceEnabled() {
 327   enabled_services_++;
 328   if ((1 == enabled_services_) &&
 329       !CommandLine::ForCurrentProcess()->HasSwitch(
 330           switches::kNoServiceAutorun)) {
 331     if (!service_process_state_->AddToAutoRun()) {
 332       // TODO(scottbyer/sanjeevr/dmaclach): Handle error condition
 333       LOG(ERROR) << "Unable to AddToAutoRun";
 334     }
 335   }
 336 }
 337
 338 void ServiceProcess::OnServiceDisabled() {
 339   DCHECK_NE(enabled_services_, 0);
 340   enabled_services_--;
 341   if (0 == enabled_services_) {
 342     if (!service_process_state_->RemoveFromAutoRun()) {
 343       // TODO(scottbyer/sanjeevr/dmaclach): Handle error condition
 344       LOG(ERROR) << "Unable to RemoveFromAutoRun";
 345     }
 346     // We will wait for some time to respond to IPCs before shutting down.
 347     ScheduleShutdownCheck();
 348   }
 349 }
 350
 351 void ServiceProcess::ScheduleShutdownCheck() {
 352   base::MessageLoop::current()->PostDelayedTask(
 353       FROM_HERE,
 354       base::Bind(&ServiceProcess::ShutdownIfNeeded, base::Unretained(this)),
 355       base::TimeDelta::FromSeconds(kShutdownDelaySeconds));
 356 }
 357
 358 void ServiceProcess::ShutdownIfNeeded() {
 359   if (0 == enabled_services_) {
 360     if (ipc_server_->is_client_connected()) {
 361       // If there is a client connected, we need to try again later.
 362       // Note that there is still a timing window here because a client may
 363       // decide to connect at this point.
 364       // TODO(sanjeevr): Fix this timing window.
 365       ScheduleShutdownCheck();
 366     } else {
 367       Shutdown();
 368     }
 369   }
 370 }
 371
 372 void ServiceProcess::ScheduleCloudPrintPolicyCheck() {
 373   base::MessageLoop::current()->PostDelayedTask(
 374       FROM_HERE,
 375       base::Bind(&ServiceProcess::CloudPrintPolicyCheckIfNeeded,
 376                  base::Unretained(this)),
 377       base::TimeDelta::FromHours(kPolicyCheckDelayHours));
 378 }
 379
 380 void ServiceProcess::CloudPrintPolicyCheckIfNeeded() {
 381   if (enabled_services_ && !ipc_server_->is_client_connected()) {
 382     GetCloudPrintProxy()->CheckCloudPrintProxyPolicy();
 383   }
 384   ScheduleCloudPrintPolicyCheck();
 385 }
 386
 387 ServiceProcess::~ServiceProcess() {
 388   Teardown();
 389   g_service_process = NULL;
 390 }