components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/nacl/loader/nacl_listener.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/loader/nacl_listener.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <string.h>
 
 #if defined(OS_POSIX)
 #include <unistd.h>
 #endif
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
+#include "base/single_thread_task_runner.h"
 #include "components/nacl/common/nacl_messages.h"
 #include "components/nacl/common/nacl_renderer_messages.h"
 #include "components/nacl/common/nacl_switches.h"
 #include "components/nacl/loader/nacl_ipc_adapter.h"
 #include "components/nacl/loader/nacl_validation_db.h"
 #include "components/nacl/loader/nacl_validation_query.h"
 #include "ipc/ipc_channel_handle.h"
 #include "ipc/ipc_switches.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/ipc_sync_message_filter.h"
@@ skipping 105 matching lines @@
 
 #endif
 
 // Creates the PPAPI IPC channel between the NaCl IRT and the host
 // (browser/renderer) process, and starts to listen it on the thread where
 // the given message_loop_proxy runs.
 // Also, creates and sets the corresponding NaClDesc to the given nap with
 // the FD #.
 void SetUpIPCAdapter(
     IPC::ChannelHandle* handle,
-    scoped_refptr<base::MessageLoopProxy> message_loop_proxy,
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     struct NaClApp* nap,
     int nacl_fd,
     NaClIPCAdapter::ResolveFileTokenCallback resolve_file_token_cb,
     NaClIPCAdapter::OpenResourceCallback open_resource_cb) {
-  scoped_refptr<NaClIPCAdapter> ipc_adapter(
-      new NaClIPCAdapter(*handle,
-                         message_loop_proxy.get(),
-                         resolve_file_token_cb,
-                         open_resource_cb));
+  scoped_refptr<NaClIPCAdapter> ipc_adapter(new NaClIPCAdapter(
+      *handle, task_runner.get(), resolve_file_token_cb, open_resource_cb));
   ipc_adapter->ConnectChannel();
 #if defined(OS_POSIX)
   handle->socket =
       base::FileDescriptor(ipc_adapter->TakeClientFileDescriptor());
 #endif
 
   // Pass a NaClDesc to the untrusted side. This will hold a ref to the
   // NaClIPCAdapter.
   NaClAppSetDesc(nap, nacl_fd, ipc_adapter->MakeNaClDesc());
 }
@@ skipping 90 matching lines @@
     g_listener->OnFileTokenResolved(token_lo, token_hi, ipc_fd, file_path);
   }
  private:
   ~FileTokenMessageFilter() override {}
 };
 
 void NaClListener::Listen() {
   std::string channel_name =
       base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
           switches::kProcessChannelID);
-  channel_ = IPC::SyncChannel::Create(
-      this, io_thread_.message_loop_proxy().get(), &shutdown_event_);
+  channel_ = IPC::SyncChannel::Create(this, io_thread_.task_runner().get(),
+                                      &shutdown_event_);
   filter_ = new IPC::SyncMessageFilter(&shutdown_event_);
   channel_->AddFilter(filter_.get());
   channel_->AddFilter(new FileTokenMessageFilter());
   channel_->Init(channel_name, IPC::Channel::MODE_CLIENT, true);
   main_loop_ = base::MessageLoop::current();
   main_loop_->Run();
 }
 
 bool NaClListener::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
@@ skipping 78 matching lines @@
   IPC::ChannelHandle manifest_service_handle;
 
   if (params.enable_ipc_proxy) {
     browser_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     ppapi_renderer_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
     manifest_service_handle = IPC::Channel::GenerateVerifiedChannelID("nacl");
 
     // Create the PPAPI IPC channels between the NaCl IRT and the host
     // (browser/renderer) processes. The IRT uses these channels to
     // communicate with the host and to initialize the IPC dispatchers.
-    SetUpIPCAdapter(&browser_handle, io_thread_.message_loop_proxy(),
-                    nap, NACL_CHROME_DESC_BASE,
+    SetUpIPCAdapter(&browser_handle, io_thread_.task_runner(), nap,
+                    NACL_CHROME_DESC_BASE,
                     NaClIPCAdapter::ResolveFileTokenCallback(),
                     NaClIPCAdapter::OpenResourceCallback());
-    SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.message_loop_proxy(),
-                    nap, NACL_CHROME_DESC_BASE + 1,
+    SetUpIPCAdapter(&ppapi_renderer_handle, io_thread_.task_runner(), nap,
+                    NACL_CHROME_DESC_BASE + 1,
                     NaClIPCAdapter::ResolveFileTokenCallback(),
                     NaClIPCAdapter::OpenResourceCallback());
-    SetUpIPCAdapter(&manifest_service_handle,
-                    io_thread_.message_loop_proxy(),
-                    nap,
-                    NACL_CHROME_DESC_BASE + 2,
-                    base::Bind(&NaClListener::ResolveFileToken,
-                               base::Unretained(this)),
-                    base::Bind(&NaClListener::OnOpenResource,
-                               base::Unretained(this)));
+    SetUpIPCAdapter(
+        &manifest_service_handle, io_thread_.task_runner(), nap,
+        NACL_CHROME_DESC_BASE + 2,
+        base::Bind(&NaClListener::ResolveFileToken, base::Unretained(this)),
+        base::Bind(&NaClListener::OnOpenResource, base::Unretained(this)));
   }
 
-  trusted_listener_ = new NaClTrustedListener(
-      IPC::Channel::GenerateVerifiedChannelID("nacl"),
-      io_thread_.message_loop_proxy().get(),
-      &shutdown_event_);
+  trusted_listener_ =
+      new NaClTrustedListener(IPC::Channel::GenerateVerifiedChannelID("nacl"),
+                              io_thread_.task_runner().get(), &shutdown_event_);
   if (!Send(new NaClProcessHostMsg_PpapiChannelsCreated(
           browser_handle,
           ppapi_renderer_handle,
           trusted_listener_->TakeClientChannelHandle(),
           manifest_service_handle)))
     LOG(ERROR) << "Failed to send IPC channel handle to NaClProcessHost.";
 
   struct NaClChromeMainArgs* args = NaClChromeMainArgsCreate();
   if (args == NULL) {
     LOG(ERROR) << "NaClChromeMainArgsCreate() failed";
@@ skipping 109 matching lines @@
 }
 
 void NaClListener::OnFileTokenResolved(
     uint64_t token_lo,
     uint64_t token_hi,
     IPC::PlatformFileForTransit ipc_fd,
     base::FilePath file_path) {
   resolved_cb_.Run(ipc_fd, file_path);
   resolved_cb_.Reset();
 }