base::Bind: Convert chrome/service.

chrome/service/cloud_print/cloud_print_proxy_backend.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/cloud_print/cloud_print_proxy_backend.h"
 
 #include <map>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/rand_util.h"
 #include "base/values.h"
 #include "chrome/common/net/gaia/gaia_oauth_client.h"
 #include "chrome/common/net/gaia/gaia_urls.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_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/cloud_print_token_store.h"
@@ skipping 147 matching lines @@
 }
 
 bool CloudPrintProxyBackend::InitializeWithLsid(
     const std::string& lsid,
     const std::string& proxy_id,
     const std::string& last_robot_refresh_token,
     const std::string& last_robot_email,
     const std::string& last_user_email) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(
-        core_.get(),
-        &CloudPrintProxyBackend::Core::DoInitializeWithLsid,
-        lsid,
-        proxy_id,
-        last_robot_refresh_token,
-        last_robot_email,
-        last_user_email));
+  core_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithLsid,
+                 core_.get(), lsid, proxy_id, last_robot_refresh_token,
+                 last_robot_email, last_user_email));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithToken(
     const std::string& cloud_print_token,
     const std::string& proxy_id) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(
-        core_.get(), &CloudPrintProxyBackend::Core::DoInitializeWithToken,
-        cloud_print_token, proxy_id));
+  core_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithToken,
+                 core_.get(), cloud_print_token, proxy_id));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithRobotToken(
     const std::string& robot_oauth_refresh_token,
     const std::string& robot_email,
     const std::string& proxy_id) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(
-        core_.get(),
-        &CloudPrintProxyBackend::Core::DoInitializeWithRobotToken,
-        robot_oauth_refresh_token,
-        robot_email,
-        proxy_id));
+  core_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotToken,
+                 core_.get(), robot_oauth_refresh_token, robot_email,
+                 proxy_id));
   return true;
 }
 
 bool CloudPrintProxyBackend::InitializeWithRobotAuthCode(
     const std::string& robot_oauth_auth_code,
     const std::string& robot_email,
     const std::string& proxy_id) {
   if (!core_thread_.Start())
     return false;
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(
-        core_.get(),
-        &CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode,
-        robot_oauth_auth_code,
-        robot_email,
-        proxy_id));
+  core_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CloudPrintProxyBackend::Core::DoInitializeWithRobotAuthCode,
+                 core_.get(), robot_oauth_auth_code, robot_email, proxy_id));
   return true;
 }
 
 void CloudPrintProxyBackend::Shutdown() {
-  core_thread_.message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(core_.get(),
-                        &CloudPrintProxyBackend::Core::DoShutdown));
+  core_thread_.message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&CloudPrintProxyBackend::Core::DoShutdown, core_.get()));
   core_thread_.Stop();
   core_ = NULL;  // Releases reference to core_.
 }
 
 CloudPrintProxyBackend::Core::Core(
     CloudPrintProxyBackend* backend,
     const std::string& proxy_id,
     const GURL& cloud_print_server_url,
     const DictionaryValue* print_system_settings,
     const gaia::OAuthClientInfo& oauth_client_info,
@@ skipping 54 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);
   // Let the frontend know that we have authenticated.
   backend_->frontend_loop_->PostTask(
-      FROM_HERE, NewRunnableMethod(this,
-                                   &Core::NotifyAuthenticated,
-                                   robot_oauth_refresh_token,
-                                   robot_email,
-                                   user_email));
+      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(talk_mediator_.get());
     talk_mediator_->SetAuthToken(robot_email,
                                  access_token,
                                  kSyncGaiaServiceId);
   }
   // 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(
-          FROM_HERE,
-          NewRunnableMethod(this,
-                            &Core::NotifyPrintSystemUnavailable));
+          FROM_HERE, base::Bind(&Core::NotifyPrintSystemUnavailable, this));
     }
   }
 }
 
 void CloudPrintProxyBackend::Core::OnInvalidCredentials() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_CONNECTOR: Auth Error";
-  backend_->frontend_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-      &Core::NotifyAuthenticationFailed));
+  backend_->frontend_loop_->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.
@@ skipping 56 matching lines @@
   if (!notifications_enabled_ && enable_job_poll_)
     ScheduleJobPoll();
 }
 
 void CloudPrintProxyBackend::Core::ScheduleJobPoll() {
   if (!job_poll_scheduled_) {
     int interval_in_seconds = base::RandInt(kMinJobPollIntervalSecs,
                                             kMaxJobPollIntervalSecs);
     MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
-        NewRunnableMethod(this, &CloudPrintProxyBackend::Core::PollForJobs),
+        base::Bind(&CloudPrintProxyBackend::Core::PollForJobs, this),
         interval_in_seconds * 1000);
     job_poll_scheduled_ = true;
   }
 }
 
 CloudPrintTokenStore* CloudPrintProxyBackend::Core::GetTokenStore() {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   if (!token_store_.get())
     token_store_.reset(new CloudPrintTokenStore);
   return token_store_.get();
@@ skipping 47 matching lines @@
 void CloudPrintProxyBackend::Core::OnIncomingNotification(
     const notifier::Notification& notification) {
   DCHECK(MessageLoop::current() == backend_->core_thread_.message_loop());
   VLOG(1) << "CP_CONNECTOR: Incoming notification.";
   if (0 == base::strcasecmp(kCloudPrintPushNotificationsSource,
                             notification.channel.c_str()))
     HandlePrinterNotification(notification.data);
 }
 
 void CloudPrintProxyBackend::Core::OnOutgoingNotification() {}