Patch for bug 74983 (among others) to be applied to M11 696 branch.

chrome/service/service_process.cc

 // Copyright (c) 2011 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/basictypes.h"
 #include "base/command_line.h"
@@ skipping 108 matching lines @@
 ServiceProcess::ServiceProcess()
   : shutdown_event_(true, false),
     main_message_loop_(NULL),
     enabled_services_(0),
     update_available_(false) {
   DCHECK(!g_service_process);
   g_service_process = this;
 }
 
 bool ServiceProcess::Initialize(MessageLoopForUI* message_loop,
-                                const CommandLine& command_line) {
+                                const CommandLine& command_line,
+                                ServiceProcessState* state) {
 #if defined(TOOLKIT_USES_GTK)
   // TODO(jamiewalch): Calling GtkInitFromCommandLine here causes the process
   // to abort if run headless. The correct fix for this is to refactor the
   // service process to be more modular, a task that is currently underway.
   // However, since this problem is blocking cloud print, the following quick
   // hack will have to do. Note that the situation with this hack in place is
   // no worse than it was when we weren't initializing GTK at all.
   int argc = 1;
   scoped_array<char*> argv(new char*[2]);
   argv[0] = strdup(command_line.argv()[0].c_str());
   argv[1] = NULL;
   char **argv_pointer = argv.get();
   gtk_init_check(&argc, &argv_pointer);
   free(argv[0]);
 #endif
   main_message_loop_ = message_loop;
+  service_process_state_.reset(state);
   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
   base::Thread::Options options;
   options.message_loop_type = MessageLoop::TYPE_IO;
   io_thread_.reset(new ServiceIOThread("ServiceProcess_IO"));
   file_thread_.reset(new base::Thread("ServiceProcess_File"));
   if (!io_thread_->StartWithOptions(options) ||
       !file_thread_->StartWithOptions(options)) {
     NOTREACHED();
     Teardown();
     return false;
@@ skipping 58 matching lines @@
     // Then check if the cloud print proxy was previously enabled.
     service_prefs_->GetBoolean(prefs::kCloudPrintProxyEnabled,
                                &cloud_print_proxy_enabled);
   }
 
   if (cloud_print_proxy_enabled) {
     GetCloudPrintProxy()->EnableForUser(lsid);
   }
 
   VLOG(1) << "Starting Service Process IPC Server";
-  ServiceProcessState* state = ServiceProcessState::GetInstance();
-  ipc_server_.reset(new ServiceIPCServer(state->GetServiceProcessChannel()));
+  ipc_server_.reset(new ServiceIPCServer(
+      service_process_state_->GetServiceProcessChannel()));
   ipc_server_->Init();
 
   // After the IPC server has started we signal that the service process is
   // ready.
   if (!state->SignalReady(io_thread_->message_loop_proxy(),
                           NewRunnableMethod(this, &ServiceProcess::Shutdown))) {
     return false;
   }
 
   // See if we need to stay running.
   ScheduleShutdownCheck();
   return true;
 }
 
 bool ServiceProcess::Teardown() {
   service_prefs_.reset();
   cloud_print_proxy_.reset();
 
   ipc_server_.reset();
   // Signal this event before shutting down the service process. That way all
   // background threads can cleanup.
   shutdown_event_.Signal();
   io_thread_.reset();
   file_thread_.reset();
   // The NetworkChangeNotifier must be destroyed after all other threads that
   // might use it have been shut down.
   network_change_notifier_.reset();
 
-  ServiceProcessState::GetInstance()->SignalStopped();
+  service_process_state_->SignalStopped();
   return true;
 }
 
 #if defined(ENABLE_REMOTING)
 static void QuitMessageLoop(MessageLoop* message_loop) {
   message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
 }
 #endif
 
 // This method is called when a shutdown command is received from IPC channel
@@ skipping 61 matching lines @@
 ServiceProcess::GetServiceURLRequestContextGetter() {
   DCHECK(request_context_getter_.get());
   return request_context_getter_.get();
 }
 
 void ServiceProcess::OnServiceEnabled() {
   enabled_services_++;
   if ((1 == enabled_services_) &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kNoServiceAutorun)) {
-    ServiceProcessState::GetInstance()->AddToAutoRun();
+    if (!service_process_state_->AddToAutoRun()) {
+      // TODO(scottbyer/sanjeevr/dmaclach): Handle error condition
+      LOG(ERROR) << "Unable to AddToAutoRun";
+    }
   }
 }
 
 void ServiceProcess::OnServiceDisabled() {
   DCHECK_NE(enabled_services_, 0);
   enabled_services_--;
   if (0 == enabled_services_) {
-    ServiceProcessState::GetInstance()->RemoveFromAutoRun();
+    if (!service_process_state_->RemoveFromAutoRun()) {
+      // TODO(scottbyer/sanjeevr/dmaclach): Handle error condition
+      LOG(ERROR) << "Unable to RemoveFromAutoRun";
+    }
     // We will wait for some time to respond to IPCs before shutting down.
     ScheduleShutdownCheck();
   }
 }
 
 void ServiceProcess::ScheduleShutdownCheck() {
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       NewRunnableMethod(this, &ServiceProcess::ShutdownIfNeeded),
       kShutdownDelay);
@@ skipping 14 matching lines @@
 }
 
 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);