chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/service/service_process.cc

 // Copyright (c) 2012 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/callback.h"
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/i18n/rtl.h"
+#include "base/location.h"
 #include "base/memory/singleton.h"
 #include "base/path_service.h"
 #include "base/prefs/json_pref_store.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/env_vars.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/service_process_util.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/service/cloud_print/cloud_print_proxy.h"
@@ skipping 157 matching lines @@
   }
 
   VLOG(1) << "Starting Service Process IPC Server";
   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 (!service_process_state_->SignalReady(
-          io_thread_->message_loop_proxy().get(),
+          io_thread_->task_runner().get(),
           base::Bind(&ServiceProcess::Terminate, base::Unretained(this)))) {
     return false;
   }
 
   // See if we need to stay running.
   ScheduleShutdownCheck();
 
   return true;
 }
 
@@ skipping 39 matching lines @@
   // terminate.
   if (!ForceServiceProcessShutdown("", 0)) {
     Terminate();
   }
 #else
   Terminate();
 #endif
 }
 
 void ServiceProcess::Terminate() {
-  main_message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
+  main_message_loop_->task_runner()->PostTask(FROM_HERE,
+                                              base::MessageLoop::QuitClosure());
 }
 
 bool ServiceProcess::HandleClientDisconnect() {
   // If there are no enabled services or if there is an update available
   // we want to shutdown right away. Else we want to keep listening for
   // new connections.
   if (!enabled_services_ || update_available()) {
     Shutdown();
     return false;
   }
@@ skipping 51 matching lines @@
     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() {
-  base::MessageLoop::current()->PostDelayedTask(
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ServiceProcess::ShutdownIfNeeded, base::Unretained(this)),
       base::TimeDelta::FromSeconds(kShutdownDelaySeconds));
 }
 
 void ServiceProcess::ShutdownIfNeeded() {
   if (0 == enabled_services_) {
     if (ipc_server_->is_client_connected()) {
       // If there is a client connected, we need to try again later.
       // Note that there is still a timing window here because a client may
       // decide to connect at this point.
       // TODO(sanjeevr): Fix this timing window.
       ScheduleShutdownCheck();
     } else {
       Shutdown();
     }
   }
 }
 
 ServiceProcess::~ServiceProcess() {
   Teardown();
   g_service_process = NULL;
 }