chrome: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

chrome/service/service_utility_process_host.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_utility_process_host.h"
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
-#include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/process/launch.h"
 #include "base/task_runner_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_utility_printing_messages.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/result_codes.h"
 #include "content/public/common/sandbox_init.h"
 #include "content/public/common/sandboxed_process_launcher_delegate.h"
 #include "ipc/ipc_switches.h"
 #include "printing/emf_win.h"
 #include "sandbox/win/src/sandbox_policy_base.h"
 #include "ui/base/ui_base_switches.h"
@@ skipping 113 matching lines @@
   base::ScopedTempDir temp_dir_;
   ServiceUtilityProcessHost* host_;
   std::queue<base::File> emf_files_;
   int page_count_;
   int current_page_;
   int pages_in_progress_;
 };
 
 ServiceUtilityProcessHost::ServiceUtilityProcessHost(
     Client* client,
-    base::MessageLoopProxy* client_message_loop_proxy)
+    base::SingleThreadTaskRunner* client_task_runner)
     : client_(client),
-      client_message_loop_proxy_(client_message_loop_proxy),
+      client_task_runner_(client_task_runner),
       waiting_for_reply_(false),
       weak_ptr_factory_(this) {
   child_process_host_.reset(ChildProcessHost::Create(this));
 }
 
 ServiceUtilityProcessHost::~ServiceUtilityProcessHost() {
   // We need to kill the child process when the host dies.
   process_.Terminate(content::RESULT_CODE_NORMAL_EXIT, false);
 }
 
@@ skipping 85 matching lines @@
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
   return ChildProcessHost::GetChildPath(flags);
 }
 
 void ServiceUtilityProcessHost::OnChildDisconnected() {
   if (waiting_for_reply_) {
     // If we are yet to receive a reply then notify the client that the
     // child died.
-    client_message_loop_proxy_->PostTask(
+    client_task_runner_->PostTask(
         FROM_HERE, base::Bind(&Client::OnChildDied, client_.get()));
     ReportUmaEvent(SERVICE_UTILITY_DISCONNECTED);
     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityDisconnectTime",
                         base::Time::Now() - start_time_);
   }
   delete this;
 }
 
 bool ServiceUtilityProcessHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
@@ skipping 40 matching lines @@
 }
 
 void ServiceUtilityProcessHost::OnRenderPDFPagesToMetafilesPageDone(
     bool success,
     float scale_factor) {
   DCHECK(waiting_for_reply_);
   if (!pdf_to_emf_state_ || !success)
     return OnPDFToEmfFinished(false);
   base::File emf_file = pdf_to_emf_state_->TakeNextFile();
   base::PostTaskAndReplyWithResult(
-      client_message_loop_proxy_.get(), FROM_HERE,
+      client_task_runner_.get(), FROM_HERE,
       base::Bind(&Client::MetafileAvailable, client_.get(), scale_factor,
                  base::Passed(&emf_file)),
       base::Bind(&ServiceUtilityProcessHost::OnMetafileSpooled,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ServiceUtilityProcessHost::OnPDFToEmfFinished(bool success) {
   if (!waiting_for_reply_)
     return;
   waiting_for_reply_ = false;
   if (success) {
     ReportUmaEvent(SERVICE_UTILITY_METAFILE_SUCCEEDED);
     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileTime",
                         base::Time::Now() - start_time_);
   } else {
     ReportUmaEvent(SERVICE_UTILITY_METAFILE_FAILED);
     UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityMetafileFailTime",
                         base::Time::Now() - start_time_);
   }
-  client_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(
-          &Client::OnRenderPDFPagesToMetafileDone, client_.get(), success));
+  client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::OnRenderPDFPagesToMetafileDone,
+                            client_.get(), success));
   pdf_to_emf_state_.reset();
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsSucceeded(
     const std::string& printer_name,
     const printing::PrinterCapsAndDefaults& caps_and_defaults) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_CAPS_SUCCEEDED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
-  client_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), true,
-                 printer_name, caps_and_defaults));
+  client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(),
+                            true, printer_name, caps_and_defaults));
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsSucceeded(
     const std::string& printer_name,
     const printing::PrinterSemanticCapsAndDefaults& caps_and_defaults) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_SUCCEEDED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
-  client_message_loop_proxy_->PostTask(
+  client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults, client_.get(),
                  true, printer_name, caps_and_defaults));
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterCapsAndDefaultsFailed(
     const std::string& printer_name) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_CAPS_FAILED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilityCapsFailTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
-  client_message_loop_proxy_->PostTask(
+  client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::OnGetPrinterCapsAndDefaults, client_.get(), false,
                  printer_name, printing::PrinterCapsAndDefaults()));
 }
 
 void ServiceUtilityProcessHost::OnGetPrinterSemanticCapsAndDefaultsFailed(
     const std::string& printer_name) {
   DCHECK(waiting_for_reply_);
   ReportUmaEvent(SERVICE_UTILITY_SEMANTIC_CAPS_FAILED);
   UMA_HISTOGRAM_TIMES("CloudPrint.ServiceUtilitySemanticCapsFailTime",
                       base::Time::Now() - start_time_);
   waiting_for_reply_ = false;
-  client_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
-                 client_.get(), false, printer_name,
-                 printing::PrinterSemanticCapsAndDefaults()));
+  client_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&Client::OnGetPrinterSemanticCapsAndDefaults,
+                            client_.get(), false, printer_name,
+                            printing::PrinterSemanticCapsAndDefaults()));
 }
 
 bool ServiceUtilityProcessHost::Client::MetafileAvailable(float scale_factor,
                                                           base::File file) {
   file.Seek(base::File::FROM_BEGIN, 0);
   int64 size = file.GetLength();
   if (size <= 0) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   std::vector<char> data(size);
   if (file.ReadAtCurrentPos(data.data(), data.size()) != size) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   printing::Emf emf;
   if (!emf.InitFromData(data.data(), data.size())) {
     OnRenderPDFPagesToMetafileDone(false);
     return false;
   }
   OnRenderPDFPagesToMetafilePageDone(scale_factor, emf);
   return true;
 }