Registered the service process to AutoRun (for Windows) if any service (Cloud...

chrome/service/service_process.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/service/service_process.h"
 
 #include <algorithm>
 
+#include "base/command_line.h"
 #include "base/path_service.h"
+#include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#if defined(OS_WIN)
+#include "base/win_util.h"
+#endif  // defined(OS_WIN)
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/json_pref_store.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_process_type.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/service/cloud_print/cloud_print_proxy.h"
 #include "chrome/service/service_ipc_server.h"
 #include "net/base/network_change_notifier.h"
 
 #if defined(ENABLE_REMOTING)
 #include "remoting/base/constants.h"
@@ skipping 11 matching lines @@
 #elif defined(OS_MACOSX)
 #include "remoting/host/capturer_mac.h"
 #include "remoting/host/event_executor_mac.h"
 #endif
 #endif  // defined(ENABLED_REMOTING)
 
 ServiceProcess* g_service_process = NULL;
 
 ServiceProcess::ServiceProcess()
   : shutdown_event_(true, false),
-    main_message_loop_(NULL) {
+    main_message_loop_(NULL),
+    enabled_services_(0) {
   DCHECK(!g_service_process);
   g_service_process = this;
 }
 
 bool ServiceProcess::Initialize(MessageLoop* message_loop) {
   main_message_loop_ = message_loop;
   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   io_thread_.reset(new base::Thread("ServiceProcess_IO"));
@@ skipping 14 matching lines @@
   DictionaryValue* values = service_prefs_->prefs();
   bool remoting_host_enabled = false;
 
   // Check if remoting host is already enabled.
   if (values->GetBoolean(prefs::kRemotingHostEnabled, &remoting_host_enabled) &&
       remoting_host_enabled) {
     // If true then we start the host.
     StartChromotingHost();
   }
 
-  // TODO(hclam): Each type of service process should has it own instance of
-  // process and thus channel, but now we have only one process for all types
-  // so the type parameter doesn't matter now.
+  bool cloud_print_proxy_enabled = false;
+
+  // Check if the cloud print proxy is already enabled.
+  if (values->GetBoolean(prefs::kCloudPrintProxyEnabled,
+                         &cloud_print_proxy_enabled) &&
+      cloud_print_proxy_enabled) {
+    GetCloudPrintProxy()->EnableForUser(std::string());
+  }
+
   LOG(INFO) << "Starting Service Process IPC Server";
-  ipc_server_.reset(new ServiceIPCServer(
-      GetServiceProcessChannelName(kServiceProcessCloudPrint)));
+  ipc_server_.reset(new ServiceIPCServer(GetServiceProcessChannelName()));
   ipc_server_->Init();
 
   // After the IPC server has started we signal that the service process is
   // running.
   SignalServiceProcessRunning(kServiceProcessCloudPrint);
   return true;
 }
 
 bool ServiceProcess::Teardown() {
   if (service_prefs_.get()) {
@@ skipping 22 matching lines @@
 }
 
 void ServiceProcess::Shutdown() {
   // Quit the main message loop.
   main_message_loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 
 CloudPrintProxy* ServiceProcess::GetCloudPrintProxy() {
   if (!cloud_print_proxy_.get()) {
     cloud_print_proxy_.reset(new CloudPrintProxy());
-    cloud_print_proxy_->Initialize(service_prefs_.get());
+    cloud_print_proxy_->Initialize(service_prefs_.get(), this);
   }
   return cloud_print_proxy_.get();
 }
 
+void ServiceProcess::OnCloudPrintProxyEnabled() {
+  // Save the preference that we have enabled the cloud print proxy.
+  service_prefs_->prefs()->SetBoolean(prefs::kCloudPrintProxyEnabled, true);
+  service_prefs_->WritePrefs();
+  OnServiceEnabled();
+}
+
+void ServiceProcess::OnCloudPrintProxyDisabled() {
+  // Save the preference that we have disabled the cloud print proxy.
+  service_prefs_->prefs()->SetBoolean(prefs::kCloudPrintProxyEnabled, false);
+  service_prefs_->WritePrefs();
+  OnServiceDisabled();
+}
+
+void ServiceProcess::OnServiceEnabled() {
+  enabled_services_++;
+  if (1 == enabled_services_) {
+    AddServiceProcessToAutoStart();
+  }
+}
+
+void ServiceProcess::OnServiceDisabled() {
+  DCHECK(0 != enabled_services_);
+  enabled_services_--;
+  if (0 == enabled_services_) {
+    RemoveServiceProcessFromAutoStart();
+    Shutdown();
+  }
+}
+
+bool ServiceProcess::AddServiceProcessToAutoStart() {
+// TODO(sanjeevr): This needs to move to some common place like base or
+// chrome/common and implementation for non-Windows platforms needs to be added.
+#if defined(OS_WIN)
+  FilePath chrome_path;
+  if (PathService::Get(base::FILE_EXE, &chrome_path)) {
+    CommandLine cmd_line(chrome_path);
+    cmd_line.AppendSwitchASCII(switches::kProcessType,
+                               switches::kServiceProcess);
+    // We need a unique name for the command per user-date-dir. Just use the
+    // channel name.
+    return win_util::AddCommandToAutoRun(
+        HKEY_CURRENT_USER, UTF8ToWide(GetServiceProcessChannelName()),
+        cmd_line.command_line_string());
+  }
+#endif  // defined(OS_WIN)
+  return false;
+}
+
+bool ServiceProcess::RemoveServiceProcessFromAutoStart() {
+// TODO(sanjeevr): This needs to move to some common place like base or
+// chrome/common and implementation for non-Windows platforms needs to be added.
+#if defined(OS_WIN)
+  return win_util::RemoveCommandFromAutoRun(
+      HKEY_CURRENT_USER, UTF8ToWide(GetServiceProcessChannelName()));
+#endif  // defined(OS_WIN)
+  return false;
+}
+
+
 #if defined(ENABLE_REMOTING)
 bool ServiceProcess::EnableChromotingHostWithTokens(
     const std::string& login,
     const std::string& remoting_token,
     const std::string& talk_token) {
   // Save the login info and tokens.
   remoting_login_ = login;
   remoting_token_ = remoting_token;
   talk_token_ = talk_token;
 
@@ skipping 40 matching lines @@
                                                   chromoting_config_,
                                                   capturer.release(),
                                                   encoder.release(),
                                                   executor.release());
 
   // Then start the chromoting host.
   // When ChromotingHost is shutdown because of failure or a request that
   // we made OnChromotingShutdown() is calls.
   chromoting_host_->Start(
       NewRunnableMethod(this, &ServiceProcess::OnChromotingHostShutdown));
+  OnServiceEnabled();
   return true;
 }
 
 bool ServiceProcess::ShutdownChromotingHost() {
   // Chromoting host doesn't exist so return true.
   if (!chromoting_host_)
     return true;
 
   // Shutdown the chromoting host asynchronously. This will signal the host to
   // shutdown, we'll actually wait for all threads to stop when we destroy
@@ skipping 90 matching lines @@
 #endif
 
 ServiceProcess::~ServiceProcess() {
   Teardown();
   g_service_process = NULL;
 }
 
 // Disable refcounting for runnable method because it is really not needed
 // when we post tasks on the main message loop.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(ServiceProcess);