ppapi: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ppapi/proxy/ppapi_proxy_test.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 "ppapi/proxy/ppapi_proxy_test.h"
 
 #include <sstream>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/message_loop/message_loop_proxy.h"
+#include "base/location.h"
 #include "base/observer_list.h"
 #include "base/process/process_handle.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
 #include "ipc/ipc_sync_channel.h"
 #include "ipc/message_filter.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_proxy_private.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_message_loop_proxy.h"
 
 namespace ppapi {
 namespace proxy {
 
@@ skipping 47 matching lines @@
     if (interface)
       return interface;
   }
   if (strcmp(name, PPB_PROXY_PRIVATE_INTERFACE) == 0)
     return &ppb_proxy_private;
   return NULL;
 }
 
 void SetUpRemoteHarness(ProxyTestHarnessBase* harness,
                         const IPC::ChannelHandle& handle,
-                        base::MessageLoopProxy* ipc_message_loop_proxy,
+                        base::SingleThreadTaskRunner* ipc_task_runner,
                         base::WaitableEvent* shutdown_event,
                         base::WaitableEvent* harness_set_up) {
-  harness->SetUpHarnessWithChannel(handle, ipc_message_loop_proxy,
-                                   shutdown_event, false);
+  harness->SetUpHarnessWithChannel(handle, ipc_task_runner, shutdown_event,
+                                   false);
   harness_set_up->Signal();
 }
 
 void TearDownRemoteHarness(ProxyTestHarnessBase* harness,
                            base::WaitableEvent* harness_torn_down) {
   harness->TearDownHarness();
   harness_torn_down->Signal();
 }
 
 void RunTaskOnRemoteHarness(const base::Closure& task,
@@ skipping 84 matching lines @@
   // in |ResourceCreationProxy::GetConnection| to get the channel to the
   // browser. In this case we just use the |plugin_dispatcher_| as the channel
   // for test purposes.
   plugin_delegate_mock_.set_browser_sender(plugin_dispatcher_.get());
   PluginGlobals::Get()->SetPluginProxyDelegate(&plugin_delegate_mock_);
   plugin_dispatcher_->DidCreateInstance(pp_instance());
 }
 
 void PluginProxyTestHarness::SetUpHarnessWithChannel(
     const IPC::ChannelHandle& channel_handle,
-    base::MessageLoopProxy* ipc_message_loop,
+    base::SingleThreadTaskRunner* ipc_task_runner,
     base::WaitableEvent* shutdown_event,
     bool is_client) {
   // These must be first since the dispatcher set-up uses them.
-  scoped_refptr<base::TaskRunner> ipc_task_runner(ipc_message_loop);
-  CreatePluginGlobals(ipc_message_loop);
+  CreatePluginGlobals(ipc_task_runner);
   // Some of the methods called during set-up check that the lock is held.
   ProxyAutoLock lock;
 
   resource_tracker().DidCreateInstance(pp_instance());
-  plugin_delegate_mock_.Init(ipc_message_loop, shutdown_event);
+  plugin_delegate_mock_.Init(ipc_task_runner, shutdown_event);
 
   plugin_dispatcher_.reset(new PluginDispatcher(
       &MockGetInterface,
       PpapiPermissions(),
       false));
   plugin_dispatcher_->InitPluginWithChannel(&plugin_delegate_mock_,
                                             base::kNullProcessId,
                                             channel_handle,
                                             is_client);
   plugin_delegate_mock_.set_browser_sender(plugin_dispatcher_.get());
@@ skipping 20 matching lines @@
     plugin_globals_.reset(new PluginGlobals(PpapiGlobals::PerThreadForTest(),
                                             ipc_task_runner));
     PpapiGlobals::SetPpapiGlobalsOnThreadForTest(GetGlobals());
   } else {
     plugin_globals_.reset(new PluginGlobals(ipc_task_runner));
   }
 }
 
 base::SingleThreadTaskRunner*
 PluginProxyTestHarness::PluginDelegateMock::GetIPCTaskRunner() {
-  return ipc_message_loop_;
+  return ipc_task_runner_;
 }
 
 base::WaitableEvent*
 PluginProxyTestHarness::PluginDelegateMock::GetShutdownEvent() {
   return shutdown_event_;
 }
 
 IPC::PlatformFileForTransit
 PluginProxyTestHarness::PluginDelegateMock::ShareHandleWithRemote(
     base::PlatformFile handle,
@@ skipping 67 matching lines @@
 
 // PluginProxyMultiThreadTest --------------------------------------------------
 
 PluginProxyMultiThreadTest::PluginProxyMultiThreadTest() {
 }
 
 PluginProxyMultiThreadTest::~PluginProxyMultiThreadTest() {
 }
 
 void PluginProxyMultiThreadTest::RunTest() {
-  main_thread_message_loop_proxy_ =
-      PpapiGlobals::Get()->GetMainThreadMessageLoop();
-  ASSERT_EQ(main_thread_message_loop_proxy_.get(),
-            base::MessageLoopProxy::current().get());
+  main_thread_task_runner_ = PpapiGlobals::Get()->GetMainThreadMessageLoop();
+  ASSERT_EQ(main_thread_task_runner_.get(),
+            base::ThreadTaskRunnerHandle::Get().get());
   nested_main_thread_message_loop_.reset(new base::RunLoop());
 
   secondary_thread_.reset(new base::DelegateSimpleThread(
       this, "PluginProxyMultiThreadTest"));
 
   {
     ProxyAutoLock auto_lock;
 
     // MessageLoopResource assumes that the proxy lock has been acquired.
     secondary_thread_message_loop_ = new MessageLoopResource(pp_instance());
@@ skipping 15 matching lines @@
   {
     ProxyAutoLock auto_lock;
 
     // The destruction requires a valid PpapiGlobals instance, so we should
     // explicitly release it.
     secondary_thread_message_loop_ = NULL;
   }
 
   secondary_thread_.reset(NULL);
   nested_main_thread_message_loop_.reset(NULL);
-  main_thread_message_loop_proxy_ = NULL;
+  main_thread_task_runner_ = NULL;
 }
 
 void PluginProxyMultiThreadTest::CheckOnThread(ThreadType thread_type) {
   ProxyAutoLock auto_lock;
   if (thread_type == MAIN_THREAD) {
     ASSERT_TRUE(MessageLoopResource::GetCurrent()->is_main_thread_loop());
   } else {
     ASSERT_EQ(secondary_thread_message_loop_.get(),
               MessageLoopResource::GetCurrent());
   }
 }
 
 void PluginProxyMultiThreadTest::PostQuitForMainThread() {
-  main_thread_message_loop_proxy_->PostTask(
-      FROM_HERE,
-      base::Bind(&PluginProxyMultiThreadTest::QuitNestedLoop,
-                 base::Unretained(this)));
+  main_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&PluginProxyMultiThreadTest::QuitNestedLoop,
+                            base::Unretained(this)));
 }
 
 void PluginProxyMultiThreadTest::PostQuitForSecondaryThread() {
   ProxyAutoLock auto_lock;
   secondary_thread_message_loop_->PostQuit(PP_TRUE);
 }
 
 void PluginProxyMultiThreadTest::Run() {
   ProxyAutoLock auto_lock;
   ASSERT_EQ(PP_OK, secondary_thread_message_loop_->AttachToCurrentThread());
@@ skipping 40 matching lines @@
   host_dispatcher_.reset(new HostDispatcher(
       pp_module(),
       &MockGetInterface,
       PpapiPermissions::AllPermissions()));
   host_dispatcher_->InitWithTestSink(&sink());
   HostDispatcher::SetForInstance(pp_instance(), host_dispatcher_.get());
 }
 
 void HostProxyTestHarness::SetUpHarnessWithChannel(
     const IPC::ChannelHandle& channel_handle,
-    base::MessageLoopProxy* ipc_message_loop,
+    base::SingleThreadTaskRunner* ipc_task_runner,
     base::WaitableEvent* shutdown_event,
     bool is_client) {
   // These must be first since the dispatcher set-up uses them.
   CreateHostGlobals();
 
-  delegate_mock_.Init(ipc_message_loop, shutdown_event);
+  delegate_mock_.Init(ipc_task_runner, shutdown_event);
 
   host_dispatcher_.reset(new HostDispatcher(
       pp_module(),
       &MockGetInterface,
       PpapiPermissions::AllPermissions()));
   ppapi::Preferences preferences;
   host_dispatcher_->InitHostWithChannel(&delegate_mock_,
                                         base::kNullProcessId, channel_handle,
                                         is_client, preferences);
   HostDispatcher::SetForInstance(pp_instance(), host_dispatcher_.get());
 }
 
 void HostProxyTestHarness::TearDownHarness() {
   HostDispatcher::RemoveForInstance(pp_instance());
   host_dispatcher_.reset();
   host_globals_.reset();
 }
 
 void HostProxyTestHarness::CreateHostGlobals() {
   disable_locking_.reset(new ProxyLock::LockingDisablerForTest);
   if (globals_config_ == PER_THREAD_GLOBALS) {
     host_globals_.reset(new TestGlobals(PpapiGlobals::PerThreadForTest()));
     PpapiGlobals::SetPpapiGlobalsOnThreadForTest(GetGlobals());
   } else {
     host_globals_.reset(new TestGlobals());
   }
 }
 
-base::MessageLoopProxy* HostProxyTestHarness::DelegateMock::GetIPCTaskRunner() {
-  return ipc_message_loop_;
+base::SingleThreadTaskRunner*
+HostProxyTestHarness::DelegateMock::GetIPCTaskRunner() {
+  return ipc_task_runner_;
 }
 
 base::WaitableEvent* HostProxyTestHarness::DelegateMock::GetShutdownEvent() {
   return shutdown_event_;
 }
 
 IPC::PlatformFileForTransit
 HostProxyTestHarness::DelegateMock::ShareHandleWithRemote(
     base::PlatformFile handle,
     base::ProcessId /* remote_pid */,
@@ skipping 56 matching lines @@
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
   plugin_thread_.Start();
 
   // Construct the IPC handle name using the process ID so we can safely run
   // multiple |TwoWayTest|s concurrently.
   std::ostringstream handle_name;
   handle_name << "TwoWayTestChannel" << base::GetCurrentProcId();
   IPC::ChannelHandle handle(handle_name.str());
   base::WaitableEvent remote_harness_set_up(true, false);
-  plugin_thread_.message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&SetUpRemoteHarness,
-                 remote_harness_,
-                 handle,
-                 io_thread_.message_loop_proxy(),
-                 &shutdown_event_,
-                 &remote_harness_set_up));
+  plugin_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&SetUpRemoteHarness, remote_harness_, handle,
+                            io_thread_.task_runner(), &shutdown_event_,
+                            &remote_harness_set_up));
   remote_harness_set_up.Wait();
-  local_harness_->SetUpHarnessWithChannel(handle,
-                                          io_thread_.message_loop_proxy().get(),
-                                          &shutdown_event_,
-                                          true);  // is_client
+  local_harness_->SetUpHarnessWithChannel(
+      handle, io_thread_.task_runner().get(), &shutdown_event_,
+      true);  // is_client
 }
 
 void TwoWayTest::TearDown() {
   base::WaitableEvent remote_harness_torn_down(true, false);
-  plugin_thread_.message_loop_proxy()->PostTask(
-      FROM_HERE,
-      base::Bind(&TearDownRemoteHarness,
-                 remote_harness_,
-                 &remote_harness_torn_down));
+  plugin_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&TearDownRemoteHarness, remote_harness_,
+                            &remote_harness_torn_down));
   remote_harness_torn_down.Wait();
 
   local_harness_->TearDownHarness();
 
   io_thread_.Stop();
 }
 
 void TwoWayTest::PostTaskOnRemoteHarness(const base::Closure& task) {
   base::WaitableEvent task_complete(true, false);
-  plugin_thread_.message_loop_proxy()->PostTask(FROM_HERE,
-      base::Bind(&RunTaskOnRemoteHarness,
-                 task,
-                 &task_complete));
+  plugin_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&RunTaskOnRemoteHarness, task, &task_complete));
   task_complete.Wait();
 }
 
 
 }  // namespace proxy
 }  // namespace ppapi