base::Bind: Convert chrome/service.

chrome/service/cloud_print/printer_job_handler.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/printer_job_handler.h"
 
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/md5.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/common/net/http_return.h"
 #include "chrome/service/cloud_print/cloud_print_consts.h"
 #include "chrome/service/cloud_print/cloud_print_helpers.h"
 #include "chrome/service/cloud_print/job_status_updater.h"
@@ skipping 104 matching lines @@
   }
 }
 
 void PrinterJobHandler::Stop() {
   VLOG(1) << "CP_CONNECTOR: Stop printer job handler, id: "
           << printer_info_cloud_.printer_id;
   task_in_progress_ = false;
   Reset();
   if (HavePendingTasks()) {
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
+        FROM_HERE, base::Bind(&PrinterJobHandler::Start, this));
   }
 }
 
 void PrinterJobHandler::CheckForJobs(const std::string& reason) {
   VLOG(1) << "CP_CONNECTOR: CheckForJobs, id: "
           << printer_info_cloud_.printer_id
           << ", reason: " << reason
           << ", task in progress: " << task_in_progress_;
   job_fetch_reason_ = reason;
   job_check_pending_ = true;
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
+        FROM_HERE, base::Bind(&PrinterJobHandler::Start, this));
   }
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
   if (!printer_watcher_) {
     LOG(ERROR) << "CP_CONNECTOR: Printer watcher is missing."
                << "Check printer server url for printer id: "
                << printer_info_cloud_.printer_id;
     return false;
   }
@@ skipping 97 matching lines @@
         CloudPrintHelpers::GetUrlForPrinterUpdate(
             cloud_print_server_url_, printer_info_cloud_.printer_id),
         this,
         kCloudPrintAPIMaxRetryCount,
         mime_type,
         post_data,
         std::string());
   } else {
     // We are done here. Go to the Stop state
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
+        FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   }
 }
 
 // CloudPrintURLFetcher::Delegate implementation.
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleRawResponse(
     const content::URLFetcher* source,
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const net::ResponseCookies& cookies,
     const std::string& data) {
   // 415 (Unsupported media type) error while fetching data from the server
   // means data conversion error. Stop fetching process and mark job as error.
   if (next_data_handler_ == (&PrinterJobHandler::HandlePrintDataResponse) &&
       response_code == RC_UNSUPPORTED_MEDIA_TYPE) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        NewRunnableMethod(this, &PrinterJobHandler::JobFailed,
-                          JOB_DOWNLOAD_FAILED));
+        base::Bind(&PrinterJobHandler::JobFailed, this, JOB_DOWNLOAD_FAILED));
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleRawData(
     const content::URLFetcher* source,
     const GURL& url,
     const std::string& data) {
   if (!next_data_handler_)
@@ skipping 10 matching lines @@
   return (this->*next_json_data_handler_)(source, url, json_data, succeeded);
 }
 
 void PrinterJobHandler::OnRequestGiveUp() {
   // The only time we call CloudPrintURLFetcher::StartGetRequest() with a
   // specified number of retries, is when we are trying to fetch print job
   // data. So, this function will be reached only if we failed to get job data.
   // In that case, we should make job as error and should not try it later.
   MessageLoop::current()->PostTask(
       FROM_HERE,
-      NewRunnableMethod(this, &PrinterJobHandler::JobFailed,
-                        JOB_DOWNLOAD_FAILED));
+      base::Bind(&PrinterJobHandler::JobFailed, this, JOB_DOWNLOAD_FAILED));
 }
 
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::OnRequestAuthError() {
   // TODO(gene): We might consider stop processing if we get auth error here.
   OnAuthError();
   // Continue processing as a network error.
   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 }
 
 std::string PrinterJobHandler::GetAuthHeader() {
@@ skipping 21 matching lines @@
 
 void PrinterJobHandler::OnPrinterDeleted() {
   if (delegate_)
     delegate_->OnPrinterDeleted(printer_info_cloud_.printer_id);
 }
 
 void PrinterJobHandler::OnPrinterChanged() {
   printer_update_pending_ = true;
   if (!task_in_progress_) {
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Start));
+        FROM_HERE, base::Bind(&PrinterJobHandler::Start, this));
   }
 }
 
 void PrinterJobHandler::OnJobChanged() {
   // Some job on the printer changed. Loop through all our JobStatusUpdaters
   // and have them check for updates.
   for (JobStatusUpdaterList::iterator index = job_status_updater_list_.begin();
        index != job_status_updater_list_.end(); index++) {
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(index->get(),
-                                     &JobStatusUpdater::UpdateStatus));
+        FROM_HERE, base::Bind(&JobStatusUpdater::UpdateStatus, index->get()));
   }
 }
 
 // Begin Response handlers
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrinterUpdateResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handle printer update response, id: "
           << printer_info_cloud_.printer_id;
   // We are done here. Go to the Stop state
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
+      FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleJobMetadataResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handle job metadata response, id: "
@@ skipping 28 matching lines @@
         request_->StartGetRequest(GURL(print_ticket_url.c_str()),
                                   this,
                                   kCloudPrintAPIMaxRetryCount,
                                   std::string());
       }
     }
   }
   // If no jobs are available, go to the Stop state.
   if (!job_available)
     MessageLoop::current()->PostTask(
-        FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
+        FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintTicketResponse(const content::URLFetcher* source,
                                              const GURL& url,
                                              const std::string& data) {
   VLOG(1) << "CP_CONNECTOR: Handle print ticket response, id: "
           << printer_info_cloud_.printer_id;
   if (print_system_->ValidatePrintTicket(printer_info_.printer_name, data)) {
@@ skipping 12 matching lines @@
   }
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintDataResponse(const content::URLFetcher* source,
                                            const GURL& url,
                                            const std::string& data) {
   VLOG(1) << "CP_CONNECTOR: Handle print data response, id: "
           << printer_info_cloud_.printer_id;
-  Task* next_task = NULL;
+  base::Closure next_task;
   if (file_util::CreateTemporaryFile(&job_details_.print_data_file_path_)) {
     int ret = file_util::WriteFile(job_details_.print_data_file_path_,
                                    data.c_str(),
                                    data.length());
     source->GetResponseHeaders()->GetMimeType(
         &job_details_.print_data_mime_type_);
     DCHECK(ret == static_cast<int>(data.length()));
     if (ret == static_cast<int>(data.length())) {
-      next_task = NewRunnableMethod(this, &PrinterJobHandler::StartPrinting);
+      next_task = base::Bind(&PrinterJobHandler::StartPrinting, this);
     }
   }
   // If there was no task allocated above, then there was an error in
   // saving the print data, bail out here.
-  if (!next_task) {
-    next_task = NewRunnableMethod(this, &PrinterJobHandler::JobFailed,
-                                  JOB_DOWNLOAD_FAILED);
+  if (next_task.is_null()) {
+    next_task = base::Bind(&PrinterJobHandler::JobFailed, this,
+                           JOB_DOWNLOAD_FAILED);
   }
   MessageLoop::current()->PostTask(FROM_HERE, next_task);
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleSuccessStatusUpdateResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handle success status update response, id: "
           << printer_info_cloud_.printer_id;
   // The print job has been spooled locally. We now need to create an object
   // that monitors the status of the job and updates the server.
   scoped_refptr<JobStatusUpdater> job_status_updater(
       new JobStatusUpdater(printer_info_.printer_name, job_details_.job_id_,
                            local_job_id_, cloud_print_server_url_,
                            print_system_.get(), this));
   job_status_updater_list_.push_back(job_status_updater);
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableMethod(job_status_updater.get(),
-                                   &JobStatusUpdater::UpdateStatus));
+      FROM_HERE, base::Bind(&JobStatusUpdater::UpdateStatus,
+                            job_status_updater.get()));
   if (succeeded) {
     // Since we just printed successfully, we want to look for more jobs.
     CheckForJobs(kJobFetchReasonQueryMore);
   }
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
+      FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleFailureStatusUpdateResponse(
     const content::URLFetcher* source,
     const GURL& url,
     DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handle failure status update response, id: "
           << printer_info_cloud_.printer_id;
   MessageLoop::current()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::Stop));
+      FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 // End Response handlers
 
 void PrinterJobHandler::StartPrinting() {
   VLOG(1) << "CP_CONNECTOR: Start printing, id: "
           << printer_info_cloud_.printer_id;
   // We are done with the request object for now.
   request_ = NULL;
   if (!shutting_down_) {
     if (!print_thread_.Start()) {
       JobFailed(PRINT_FAILED);
     } else {
       print_thread_.message_loop()->PostTask(
-          FROM_HERE, NewRunnableMethod(this, &PrinterJobHandler::DoPrint,
-                                       job_details_,
-                                       printer_info_.printer_name));
+          FROM_HERE, base::Bind(&PrinterJobHandler::DoPrint, this, job_details_,
+                                printer_info_.printer_name));
     }
   }
 }
 
 void PrinterJobHandler::JobFailed(PrintJobError error) {
   VLOG(1) << "CP_CONNECTOR: Job failed, id: " << printer_info_cloud_.printer_id;
   if (!shutting_down_) {
     UpdateJobStatus(cloud_print::PRINT_JOB_STATUS_ERROR, error);
   }
 }
@@ skipping 84 matching lines @@
                                             job_details.tags_,
                                             this)) {
     OnJobSpoolFailed();
   }
 }
 
 void PrinterJobHandler::OnJobSpoolSucceeded(
     const cloud_print::PlatformJobId& job_id) {
   DCHECK(MessageLoop::current() == print_thread_.message_loop());
   job_spooler_ = NULL;
-  job_handler_message_loop_proxy_->PostTask(FROM_HERE,
-                                            NewRunnableMethod(this,
-                                                &PrinterJobHandler::JobSpooled,
-                                                job_id));
+  job_handler_message_loop_proxy_->PostTask(
+      FROM_HERE, base::Bind(&PrinterJobHandler::JobSpooled, this, job_id));
 }
 
 void PrinterJobHandler::OnJobSpoolFailed() {
   DCHECK(MessageLoop::current() == print_thread_.message_loop());
   job_spooler_ = NULL;
-  job_handler_message_loop_proxy_->PostTask(FROM_HERE,
-                                            NewRunnableMethod(this,
-                                                &PrinterJobHandler::JobFailed,
-                                                PRINT_FAILED));
+  job_handler_message_loop_proxy_->PostTask(
+      FROM_HERE, base::Bind(&PrinterJobHandler::JobFailed, this, PRINT_FAILED));
 }