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

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/path_service.h"
 #include "base/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.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"
 #include "remoting/base/encoder_zlib.h"
 #include "remoting/host/chromoting_host.h"
@@ skipping 34 matching lines @@
     Teardown();
     return false;
   }
   FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   FilePath pref_path = user_data_dir.Append(chrome::kServiceStateFileName);
   service_prefs_.reset(new JsonPrefStore(pref_path,
                                          file_thread_->message_loop_proxy()));
   service_prefs_->ReadPrefs();
 
+  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.
   LOG(INFO) << "Starting Service Process IPC Server";
   ipc_server_.reset(new ServiceIPCServer(
       GetServiceProcessChannelName(kServiceProcessCloudPrint)));
   ipc_server_->Init();
 
   // After the IPC server has started we can create the lock file to indicate
   // that we have started.
   bool ret = CreateServiceProcessLockFile(kServiceProcessCloudPrint);
   DCHECK(ret) << "Failed to create service process lock file.";
   return ret;
 }
 
 bool ServiceProcess::Teardown() {
-  // TODO(hclam): Remove this as this looks like dead code.
   if (service_prefs_.get()) {
     service_prefs_->WritePrefs();
     service_prefs_.reset();
   }
   cloud_print_proxy_.reset();
 
 #if defined(ENABLE_REMOTING)
   ShutdownChromotingHost();
 #endif
 
@@ skipping 30 matching lines @@
 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;
 
   // Use the remoting directory to register the host.
+  if (remoting_directory_.get())
+    remoting_directory_->CancelRequest();
   remoting_directory_.reset(new RemotingDirectoryService(this));
   remoting_directory_->AddHost(remoting_token);
   return true;
 }
 
 bool ServiceProcess::StartChromotingHost() {
   // We have already started.
   if (chromoting_context_.get())
     return true;
 
@@ skipping 55 matching lines @@
   SaveChromotingConfig(remoting_login_,
                        talk_token_,
                        remoting_directory_->host_id(),
                        remoting_directory_->host_name(),
                        remoting_directory_->host_key_pair());
   remoting_directory_.reset();
   remoting_login_ = "";
   remoting_token_ = "";
   talk_token_ = "";
 
+  // Save the preference that we have enabled the remoting host.
+  service_prefs_->prefs()->SetBoolean(prefs::kRemotingHostEnabled, true);
+
+  // Force writing prefs to the disk.
+  service_prefs_->WritePrefs();
+
   // TODO(hclam): If we have a problem we need to send an IPC message back
   // to the client that started this.
   bool ret = StartChromotingHost();
   DCHECK(ret);
 }
 
 void ServiceProcess::OnRemotingDirectoryError() {
   remoting_directory_.reset();
   remoting_login_ = "";
   remoting_token_ = "";
@@ skipping 56 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);