components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/nacl/renderer/ppb_nacl_private_impl.cc

 // Copyright 2013 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 "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include <numeric>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/cpu.h"
 #include "base/files/file.h"
 #include "base/json/json_reader.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "base/rand_util.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "components/nacl/common/nacl_host_messages.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_nonsfi_util.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/nacl/common/nacl_types.h"
 #include "components/nacl/renderer/file_downloader.h"
 #include "components/nacl/renderer/histogram.h"
 #include "components/nacl/renderer/json_manifest.h"
 #include "components/nacl/renderer/manifest_downloader.h"
 #include "components/nacl/renderer/manifest_service_channel.h"
@@ skipping 215 matching lines @@
       const ManifestServiceChannel::OpenResourceCallback& callback) override {
     DCHECK(ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->
                BelongsToCurrentThread());
 
     // For security hardening, disable open_resource() when it is isn't
     // needed.  PNaCl pexes can't use open_resource(), but general nexes
     // and the PNaCl translator nexes may use it.
     if (process_type_ != kNativeNaClProcessType &&
         process_type_ != kPNaClTranslatorProcessType) {
       // Return an error.
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(callback, base::Passed(base::File()), 0, 0));
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(callback, base::Passed(base::File()), 0, 0));
       return;
     }
 
     std::string url;
     // TODO(teravest): Clean up pnacl_options logic in JsonManifest so we don't
     // have to initialize it like this here.
     PP_PNaClOptions pnacl_options;
     pnacl_options.translate = PP_FALSE;
     pnacl_options.is_debug = PP_FALSE;
     pnacl_options.use_subzero = PP_FALSE;
     pnacl_options.opt_level = 2;
     bool is_helper_process = process_type_ == kPNaClTranslatorProcessType;
     if (!ManifestResolveKey(pp_instance_, is_helper_process, key, &url,
                             &pnacl_options)) {
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(callback, base::Passed(base::File()), 0, 0));
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(callback, base::Passed(base::File()), 0, 0));
       return;
     }
 
     // We have to call DidDownloadFile, even if this object is destroyed, so
     // that the handle inside PP_NaClFileInfo isn't leaked. This means that the
     // callback passed to this function shouldn't have a weak pointer to an
     // object either.
     //
     // TODO(teravest): Make a type like PP_NaClFileInfo to use for DownloadFile
     // that would close the file handle on destruction.
@@ skipping 1105 matching lines @@
 
 void DownloadFile(PP_Instance instance,
                   const std::string& url,
                   const DownloadFileCallback& callback) {
   DCHECK(ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->
              BelongsToCurrentThread());
 
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   static_cast<int32_t>(PP_ERROR_FAILED),
-                   kInvalidNaClFileInfo));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, static_cast<int32_t>(PP_ERROR_FAILED),
+                              kInvalidNaClFileInfo));
     return;
   }
 
   // Handle special PNaCl support files which are installed on the user's
   // machine.
   if (url.find(kPNaClTranslatorBaseUrl, 0) == 0) {
     PP_NaClFileInfo file_info = kInvalidNaClFileInfo;
     PP_FileHandle handle = GetReadonlyPnaclFd(url.c_str(),
                                               false /* is_executable */,
                                               &file_info.token_lo,
                                               &file_info.token_hi);
     if (handle == PP_kInvalidFileHandle) {
-      base::MessageLoop::current()->PostTask(
-          FROM_HERE,
-          base::Bind(callback,
-                     static_cast<int32_t>(PP_ERROR_FAILED),
-                     kInvalidNaClFileInfo));
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
+          FROM_HERE, base::Bind(callback, static_cast<int32_t>(PP_ERROR_FAILED),
+                                kInvalidNaClFileInfo));
       return;
     }
     file_info.handle = handle;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, static_cast<int32_t>(PP_OK), file_info));
     return;
   }
 
   // We have to ensure that this url resolves relative to the plugin base url
   // before downloading it.
   const GURL& test_gurl = load_manager->plugin_base_url().Resolve(url);
   if (!test_gurl.is_valid()) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   static_cast<int32_t>(PP_ERROR_FAILED),
-                   kInvalidNaClFileInfo));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, static_cast<int32_t>(PP_ERROR_FAILED),
+                              kInvalidNaClFileInfo));
     return;
   }
 
   // Try the fast path for retrieving the file first.
   uint64_t file_token_lo = 0;
   uint64_t file_token_hi = 0;
   PP_FileHandle file_handle = OpenNaClExecutable(instance,
                                                  url.c_str(),
                                                  &file_token_lo,
                                                  &file_token_hi);
   if (file_handle != PP_kInvalidFileHandle) {
     PP_NaClFileInfo file_info;
     file_info.handle = file_handle;
     file_info.token_lo = file_token_lo;
     file_info.token_hi = file_token_hi;
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, static_cast<int32_t>(PP_OK), file_info));
     return;
   }
 
   // The fast path didn't work, we'll fetch the file using URLLoader and write
   // it to local storage.
   base::File target_file(CreateTemporaryFile(instance));
   GURL gurl(url);
 
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(callback,
-                   static_cast<int32_t>(PP_ERROR_FAILED),
-                   kInvalidNaClFileInfo));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(callback, static_cast<int32_t>(PP_ERROR_FAILED),
+                              kInvalidNaClFileInfo));
   }
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
 
   ProgressEventRateLimiter* tracker = new ProgressEventRateLimiter(instance);
 
   // FileDownloader deletes itself after invoking DownloadNexeCompletion.
@@ skipping 167 matching lines @@
 
 void StreamPexe(PP_Instance instance,
                 const char* pexe_url,
                 int32_t opt_level,
                 PP_Bool use_subzero,
                 const PPP_PexeStreamHandler* handler,
                 void* handler_user_data) {
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(handler->DidFinishStream,
-                   handler_user_data,
-                   static_cast<int32_t>(PP_ERROR_FAILED)));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(handler->DidFinishStream, handler_user_data,
+                              static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   GURL gurl(pexe_url);
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
   PexeDownloader* downloader =
       new PexeDownloader(instance, url_loader.Pass(), pexe_url, opt_level,
@@ skipping 37 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl