chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/service/cloud_print/printer_job_handler.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/printer_job_handler.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
+#include "base/location.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "chrome/common/cloud_print/cloud_print_helpers.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/service/cloud_print/cloud_print_service_helpers.h"
 #include "chrome/service/cloud_print/job_status_updater.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "printing/printing_utils.h"
@@ skipping 40 matching lines @@
     Delegate* delegate)
     : print_system_(print_system),
       printer_info_(printer_info),
       printer_info_cloud_(printer_info_cloud),
       cloud_print_server_url_(cloud_print_server_url),
       delegate_(delegate),
       local_job_id_(-1),
       next_json_data_handler_(NULL),
       next_data_handler_(NULL),
       print_thread_("Chrome_CloudPrintJobPrintThread"),
-      job_handler_message_loop_proxy_(
-          base::MessageLoopProxy::current()),
+      job_handler_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       shutting_down_(false),
       job_check_pending_(false),
       printer_update_pending_(true),
       task_in_progress_(false),
       weak_ptr_factory_(this) {
 }
 
 bool PrinterJobHandler::Initialize() {
   if (!print_system_->IsValidPrinter(printer_info_.printer_name))
     return false;
@@ skipping 12 matching lines @@
 void PrinterJobHandler::CheckForJobs(const std::string& reason) {
   VLOG(1) << "CP_CONNECTOR: Checking for jobs"
           << ", printer id: " << printer_info_cloud_.printer_id
           << ", reason: " << reason
           << ", task in progress: " << task_in_progress_;
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                             JOB_HANDLER_CHECK_FOR_JOBS, JOB_HANDLER_MAX);
   job_fetch_reason_ = reason;
   job_check_pending_ = true;
   if (!task_in_progress_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&PrinterJobHandler::Start, this));
   }
 }
 
 void PrinterJobHandler::Shutdown() {
   VLOG(1) << "CP_CONNECTOR: Shutting down printer job handler"
           << ", printer id: " << printer_info_cloud_.printer_id;
   Reset();
   shutting_down_ = true;
   while (!job_status_updater_list_.empty()) {
     // Calling Stop() will cause the OnJobCompleted to be called which will
     // remove the updater object from the list.
     job_status_updater_list_.front()->Stop();
   }
 }
 
 // CloudPrintURLFetcher::Delegate implementation.
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleRawResponse(
     const net::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 == net::HTTP_UNSUPPORTED_MEDIA_TYPE) {
     VLOG(1) << "CP_CONNECTOR: Job failed (unsupported media type)";
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&PrinterJobHandler::JobFailed, this, JOB_DOWNLOAD_FAILED));
     return CloudPrintURLFetcher::STOP_PROCESSING;
   }
   return CloudPrintURLFetcher::CONTINUE_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::HandleRawData(
     const net::URLFetcher* source,
     const GURL& url,
@@ skipping 10 matching lines @@
     bool succeeded) {
   DCHECK(next_json_data_handler_);
   return (this->*next_json_data_handler_)(source, url, json_data, succeeded);
 }
 
 // Mark the job fetch as failed and check if other jobs can be printed
 void PrinterJobHandler::OnRequestGiveUp() {
   if (job_queue_handler_.JobFetchFailed(job_details_.job_id_)) {
     VLOG(1) << "CP_CONNECTOR: Job failed to load (scheduling retry)";
     CheckForJobs(kJobFetchReasonFailure);
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   } else {
     VLOG(1) << "CP_CONNECTOR: Job failed (giving up after " <<
         kNumRetriesBeforeAbandonJob << " retries)";
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&PrinterJobHandler::JobFailed, this, JOB_DOWNLOAD_FAILED));
   }
 }
 
 CloudPrintURLFetcher::ResponseAction PrinterJobHandler::OnRequestAuthError() {
   // We got an Auth error and have no idea how long it will take to refresh
   // auth information (may take forever). We'll drop current request and
   // propagate this error to the upper level. After auth issues will be
   // resolved, GCP connector will restart.
@@ skipping 20 matching lines @@
     if (index->get() == updater) {
       job_status_updater_list_.erase(index);
       ret = true;
       break;
     }
   }
   return ret;
 }
 
 void PrinterJobHandler::OnAuthError() {
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   if (delegate_)
     delegate_->OnAuthError();
 }
 
 void PrinterJobHandler::OnPrinterDeleted() {
   if (delegate_)
     delegate_->OnPrinterDeleted(printer_info_cloud_.printer_id);
 }
 
 void PrinterJobHandler::OnPrinterChanged() {
   printer_update_pending_ = true;
   if (!task_in_progress_) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         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++) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&JobStatusUpdater::UpdateStatus, index->get()));
   }
 }
 
 void PrinterJobHandler::OnJobSpoolSucceeded(const PlatformJobId& job_id) {
   DCHECK(base::MessageLoop::current() == print_thread_.message_loop());
   job_spooler_->AddRef();
   print_thread_.message_loop()->ReleaseSoon(FROM_HERE, job_spooler_.get());
   job_spooler_ = NULL;
-  job_handler_message_loop_proxy_->PostTask(
+  job_handler_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::JobSpooled, this, job_id));
 }
 
 void PrinterJobHandler::OnJobSpoolFailed() {
   DCHECK(base::MessageLoop::current() == print_thread_.message_loop());
   job_spooler_->AddRef();
   print_thread_.message_loop()->ReleaseSoon(FROM_HERE, job_spooler_.get());
   job_spooler_ = NULL;
   VLOG(1) << "CP_CONNECTOR: Job failed (spool failed)";
-  job_handler_message_loop_proxy_->PostTask(
+  job_handler_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::JobFailed, this, JOB_FAILED));
 }
 
 // static
 void PrinterJobHandler::ReportsStats() {
   base::subtle::Atomic32 started =
       base::subtle::NoBarrier_AtomicExchange(&g_total_jobs_started, 0);
   base::subtle::Atomic32 done =
       base::subtle::NoBarrier_AtomicExchange(&g_total_jobs_done, 0);
   UMA_HISTOGRAM_COUNTS_100("CloudPrint.JobsStartedPerInterval", started);
@@ skipping 10 matching lines @@
 PrinterJobHandler::HandlePrinterUpdateResponse(
     const net::URLFetcher* source,
     const GURL& url,
     base::DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handling printer update response"
           << ", printer id: " << printer_info_cloud_.printer_id;
   // We are done here. Go to the Stop state
   VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
           << ", printer id: " << printer_info_cloud_.printer_id;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleJobMetadataResponse(
     const net::URLFetcher* source,
     const GURL& url,
     base::DictionaryValue* json_data,
     bool succeeded) {
@@ skipping 20 matching lines @@
                               job_fetch_reason_),
               this, kJobDataMaxRetryCount, std::string());
         } else {
           request_->StartGetRequest(
               CloudPrintURLFetcher::REQUEST_TICKET,
               GURL(job_details_.print_ticket_url_), this, kJobDataMaxRetryCount,
               std::string());
         }
       } else {
         job_available = false;
-        base::MessageLoop::current()->PostDelayedTask(
+        base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&PrinterJobHandler::RunScheduledJobCheck, this),
             jobs[0].time_remaining_);
       }
     }
   }
 
   if (!job_available) {
     // If no jobs are available, go to the Stop state.
     VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
             << ", printer id: " << printer_info_cloud_.printer_id;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   }
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandlePrintTicketResponse(const net::URLFetcher* source,
                                              const GURL& url,
                                              const std::string& data) {
   VLOG(1) << "CP_CONNECTOR: Handling print ticket response"
@@ skipping 41 matching lines @@
       return CloudPrintURLFetcher::STOP_PROCESSING;
     }
   }
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                             JOB_HANDLER_INVALID_DATA, JOB_HANDLER_MAX);
 
   // If we are here, then there was an error in saving the print data, bail out
   // here.
   VLOG(1) << "CP_CONNECTOR: Error saving print data"
           << ", printer id: " << printer_info_cloud_.printer_id;
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE, base::Bind(&PrinterJobHandler::JobFailed, this,
-                            JOB_DOWNLOAD_FAILED));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&PrinterJobHandler::JobFailed, this, JOB_DOWNLOAD_FAILED));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleInProgressStatusUpdateResponse(
     const net::URLFetcher* source,
     const GURL& url,
     base::DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handling success status update response"
           << ", printer id: " << printer_info_cloud_.printer_id;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::StartPrinting, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 CloudPrintURLFetcher::ResponseAction
 PrinterJobHandler::HandleFailureStatusUpdateResponse(
     const net::URLFetcher* source,
     const GURL& url,
     base::DictionaryValue* json_data,
     bool succeeded) {
   VLOG(1) << "CP_CONNECTOR: Handling failure status update response"
           << ", printer id: " << printer_info_cloud_.printer_id;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   return CloudPrintURLFetcher::STOP_PROCESSING;
 }
 
 void PrinterJobHandler::Start() {
   VLOG(1) << "CP_CONNECTOR: Starting printer job handler"
           << ", printer id: " << printer_info_cloud_.printer_id
           << ", task in progress: " << task_in_progress_;
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                             JOB_HANDLER_START, JOB_HANDLER_MAX);
@@ skipping 48 matching lines @@
 
 void PrinterJobHandler::Stop() {
   VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
           << ", printer id: " << printer_info_cloud_.printer_id;
   task_in_progress_ = false;
   VLOG(1) << "CP_CONNECTOR: Changed task in progress"
           << ", printer id: " << printer_info_cloud_.printer_id
           << ", task in progress: " << task_in_progress_;
   Reset();
   if (HavePendingTasks()) {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&PrinterJobHandler::Start, this));
   }
 }
 
 void PrinterJobHandler::StartPrinting() {
   VLOG(1) << "CP_CONNECTOR: Starting printing"
           << ", printer id: " << printer_info_cloud_.printer_id;
   UMA_HISTOGRAM_ENUMERATION("CloudPrint.JobHandlerEvent",
                             JOB_HANDLER_SET_START_PRINTING, JOB_HANDLER_MAX);
   // We are done with the request object for now.
   request_ = NULL;
   if (!shutting_down_) {
 #if defined(OS_WIN)
     print_thread_.init_com_with_mta(true);
 #endif
     if (!print_thread_.Start()) {
       VLOG(1) << "CP_CONNECTOR: Failed to start print thread"
               << ", printer id: " << printer_info_cloud_.printer_id;
       JobFailed(JOB_FAILED);
     } else {
-      print_thread_.message_loop()->PostTask(
+      print_thread_.task_runner()->PostTask(
           FROM_HERE, base::Bind(&PrinterJobHandler::DoPrint, this, job_details_,
                                 printer_info_.printer_name));
     }
   }
 }
 
 void PrinterJobHandler::Reset() {
   job_details_.Clear();
   request_ = NULL;
   print_thread_.Stop();
@@ skipping 78 matching lines @@
   local_job_id_ = local_job_id;
   print_thread_.Stop();
 
   // 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);
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&JobStatusUpdater::UpdateStatus, job_status_updater.get()));
 
   CheckForJobs(kJobFetchReasonQueryMore);
 
   VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
           << ", printer id: " << printer_info_cloud_.printer_id;
-  base::MessageLoop::current()->PostTask(
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
 }
 
 bool PrinterJobHandler::UpdatePrinterInfo() {
   if (!printer_watcher_.get()) {
     LOG(ERROR) << "CP_CONNECTOR: Printer watcher is missing."
                << " Check printer server url for printer id: "
                << printer_info_cloud_.printer_id;
     return false;
   }
@@ skipping 126 matching lines @@
             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
     VLOG(1) << "CP_CONNECTOR: Stopping printer job handler"
             << ", printer name: " << printer_name;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&PrinterJobHandler::Stop, this));
   }
 }
 
 // The following methods are called on |print_thread_|. It is not safe to
-// access any members other than |job_handler_message_loop_proxy_|,
+// access any members other than |job_handler_task_runner_|,
 // |job_spooler_| and |print_system_|.
 void PrinterJobHandler::DoPrint(const JobDetails& job_details,
                                 const std::string& printer_name) {
   job_spooler_ = print_system_->CreateJobSpooler();
   UMA_HISTOGRAM_LONG_TIMES("CloudPrint.PrepareTime",
                            base::Time::Now() - job_start_time_);
   DCHECK(job_spooler_.get());
   if (!job_spooler_.get())
     return;
   base::string16 document_name = printing::SimplifyDocumentTitle(
@@ skipping 11 matching lines @@
                            job_details.print_data_mime_type_,
                            printer_name,
                            base::UTF16ToUTF8(document_name),
                            job_details.tags_,
                            this)) {
     OnJobSpoolFailed();
   }
 }
 
 }  // namespace cloud_print