chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/service/cloud_print/cloud_print_proxy_backend.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/cloud_print/cloud_print_proxy_backend.h"
 
 #include <map>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/service/cloud_print/cloud_print_auth.h"
 #include "chrome/service/cloud_print/cloud_print_connector.h"
 #include "chrome/service/cloud_print/cloud_print_service_helpers.h"
 #include "chrome/service/cloud_print/cloud_print_token_store.h"
 #include "chrome/service/cloud_print/connector_settings.h"
 #include "chrome/service/net/service_url_request_context_getter.h"
 #include "chrome/service/service_process.h"
 #include "components/cloud_devices/common/cloud_devices_switches.h"
@@ skipping 139 matching lines @@
   DCHECK(frontend_);
   core_ = new Core(this, settings, oauth_client_info, enable_job_poll);
 }
 
 CloudPrintProxyBackend::~CloudPrintProxyBackend() { DCHECK(!core_.get()); }
 
 bool CloudPrintProxyBackend::InitializeWithToken(
     const std::string& cloud_print_token) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(
+  core_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithToken,
                  core_.get(), cloud_print_token));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithRobotToken(
     const std::string& robot_oauth_refresh_token,
     const std::string& robot_email) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(
+  core_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotToken,
                  core_.get(), robot_oauth_refresh_token, robot_email));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithRobotAuthCode(
     const std::string& robot_oauth_auth_code,
     const std::string& robot_email) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(
+  core_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode,
                  core_.get(), robot_oauth_auth_code, robot_email));
   return true;
 }
 
 void CloudPrintProxyBackend::Shutdown() {
-  core_thread_.message_loop()->PostTask(
+  core_thread_.task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&CloudPrintProxyBackend::Core::DoShutdown, core_.get()));
   core_thread_.Stop();
   core_ = NULL;  // Releases reference to core_.
 }
 
 void CloudPrintProxyBackend::UnregisterPrinters() {
-  core_thread_.message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(&CloudPrintProxyBackend::Core::DoUnregisterPrinters,
-                 core_.get()));
+  core_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&CloudPrintProxyBackend::Core::DoUnregisterPrinters,
+                            core_.get()));
 }
 
 CloudPrintProxyBackend::Core::Core(
     CloudPrintProxyBackend* backend,
     const ConnectorSettings& settings,
     const gaia::OAuthClientInfo& oauth_client_info,
     bool enable_job_poll)
       : backend_(backend),
         oauth_client_info_(oauth_client_info),
         notifications_enabled_(false),
@@ skipping 46 matching lines @@
 void CloudPrintProxyBackend::Core::OnAuthenticationComplete(
     const std::string& access_token,
     const std::string& robot_oauth_refresh_token,
     const std::string& robot_email,
     const std::string& user_email) {
   CloudPrintTokenStore* token_store  = GetTokenStore();
   bool first_time = token_store->token().empty();
   token_store->SetToken(access_token);
   robot_email_ = robot_email;
   // Let the frontend know that we have authenticated.
-  backend_->frontend_loop_->PostTask(
+  backend_->frontend_loop_->task_runner()->PostTask(
       FROM_HERE,
       base::Bind(&Core::NotifyAuthenticated, this, robot_oauth_refresh_token,
                  robot_email, user_email));
   if (first_time) {
     InitNotifications(robot_email, access_token);
   } else {
     // If we are refreshing a token, update the XMPP token too.
     DCHECK(push_client_.get());
     push_client_->UpdateCredentials(robot_email, access_token);
   }
   // Start cloud print connector if needed.
   if (!connector_->IsRunning()) {
     if (!connector_->Start()) {
       // Let the frontend know that we do not have a print system.
-      backend_->frontend_loop_->PostTask(
+      backend_->frontend_loop_->task_runner()->PostTask(
           FROM_HERE, base::Bind(&Core::NotifyPrintSystemUnavailable, this));
     }
   }
 }
 
 void CloudPrintProxyBackend::Core::OnInvalidCredentials() {
   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_CONNECTOR: Auth Error";
-  backend_->frontend_loop_->PostTask(
+  backend_->frontend_loop_->task_runner()->PostTask(
       FROM_HERE, base::Bind(&Core::NotifyAuthenticationFailed, this));
 }
 
 void CloudPrintProxyBackend::Core::OnAuthFailed() {
   VLOG(1) << "CP_CONNECTOR: Authentication failed in connector.";
   // Let's stop connecter and refresh token. We'll restart connecter once
   // new token available.
   if (connector_->IsRunning())
     connector_->Stop();
 
   // Refresh Auth token.
   auth_->RefreshAccessToken();
 }
 
 void CloudPrintProxyBackend::Core::OnXmppPingUpdated(int ping_timeout) {
   settings_.SetXmppPingTimeoutSec(ping_timeout);
-  backend_->frontend_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&Core::NotifyXmppPingUpdated, this, ping_timeout));
+  backend_->frontend_loop_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&Core::NotifyXmppPingUpdated, this, ping_timeout));
 }
 
 void CloudPrintProxyBackend::Core::InitNotifications(
     const std::string& robot_email,
     const std::string& access_token) {
   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
 
   pending_xmpp_pings_ = 0;
   notifier::NotifierOptions notifier_options;
   notifier_options.request_context_getter =
@@ skipping 33 matching lines @@
 }
 
 void CloudPrintProxyBackend::Core::DoUnregisterPrinters() {
   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
 
   std::string access_token = GetTokenStore()->token();
 
   std::list<std::string> printer_ids;
   connector_->GetPrinterIds(&printer_ids);
 
-  backend_->frontend_loop_->PostTask(
-      FROM_HERE,
-      base::Bind(&Core::NotifyUnregisterPrinters,
-                 this, access_token, printer_ids));
+  backend_->frontend_loop_->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&Core::NotifyUnregisterPrinters, this, access_token,
+                            printer_ids));
 }
 
 void CloudPrintProxyBackend::Core::HandlePrinterNotification(
     const std::string& notification) {
   DCHECK(base::MessageLoop::current() == backend_->core_thread_.message_loop());
 
   size_t pos = notification.rfind(kNotificationUpdateSettings);
   if (pos == std::string::npos) {
     VLOG(1) << "CP_CONNECTOR: Handle printer notification, id: "
             << notification;
@@ skipping 16 matching lines @@
   // If we don't have notifications and job polling is enabled, poll again
   // after a while.
   if (!notifications_enabled_ && enable_job_poll_)
     ScheduleJobPoll();
 }
 
 void CloudPrintProxyBackend::Core::ScheduleJobPoll() {
   if (!job_poll_scheduled_) {
     base::TimeDelta interval = base::TimeDelta::FromSeconds(
         base::RandInt(kMinJobPollIntervalSecs, kMaxJobPollIntervalSecs));
-    base::MessageLoop::current()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&CloudPrintProxyBackend::Core::PollForJobs, this),
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+        FROM_HERE, base::Bind(&CloudPrintProxyBackend::Core::PollForJobs, this),
         interval);
     job_poll_scheduled_ = true;
   }
 }
 
 void CloudPrintProxyBackend::Core::PingXmppServer() {
   xmpp_ping_scheduled_ = false;
 
   if (!push_client_.get())
     return;
 
   push_client_->SendPing();
 
   pending_xmpp_pings_++;
   if (pending_xmpp_pings_ >= kMaxFailedXmppPings) {
     // Check ping status when we close to the limit.
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CloudPrintProxyBackend::Core::CheckXmppPingStatus, this),
         base::TimeDelta::FromSeconds(kXmppPingCheckIntervalSecs));
   }
 
   // Schedule next ping if needed.
   if (notifications_enabled_)
     ScheduleXmppPing();
 }
 
 void CloudPrintProxyBackend::Core::ScheduleXmppPing() {
   // settings_.xmpp_ping_enabled() is obsolete, we are now control
   // XMPP pings from Cloud Print server.
   if (!xmpp_ping_scheduled_) {
     base::TimeDelta interval = base::TimeDelta::FromSeconds(
       base::RandInt(settings_.xmpp_ping_timeout_sec() * 0.9,
                     settings_.xmpp_ping_timeout_sec() * 1.1));
-    base::MessageLoop::current()->PostDelayedTask(
+    base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CloudPrintProxyBackend::Core::PingXmppServer, this),
         interval);
     xmpp_ping_scheduled_ = true;
   }
 }
 
 void CloudPrintProxyBackend::Core::CheckXmppPingStatus() {
   if (pending_xmpp_pings_ >= kMaxFailedXmppPings) {
     UMA_HISTOGRAM_COUNTS_100("CloudPrint.XmppPingTry", 99);  // Max on fail.
@@ skipping 86 matching lines @@
     HandlePrinterNotification(notification.data);
 }
 
 void CloudPrintProxyBackend::Core::OnPingResponse() {
   UMA_HISTOGRAM_COUNTS_100("CloudPrint.XmppPingTry", pending_xmpp_pings_);
   pending_xmpp_pings_ = 0;
   VLOG(1) << "CP_CONNECTOR: Ping response received.";
 }
 
 }  // namespace cloud_print