ppapi: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

ppapi/proxy/ppapi_proxy_test.h

 // 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 <map>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner.h"
 #include "base/threading/simple_thread.h"
 #include "base/threading/thread.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/plugin_dispatcher.h"
 #include "ppapi/proxy/plugin_globals.h"
 #include "ppapi/proxy/plugin_proxy_delegate.h"
 #include "ppapi/proxy/plugin_resource_tracker.h"
 #include "ppapi/proxy/plugin_var_tracker.h"
 #include "ppapi/proxy/resource_message_test_sink.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 #include "ppapi/shared_impl/test_globals.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
-class MessageLoopProxy;
+class SingleThreadTaskRunner;

[bbudge, 2015/06/10 20:57:46]

Alphabetical ordering

[Sami, 2015/06/11 18:03:46]

Thanks, fixed.

 class RunLoop;
 }
 
 namespace ppapi {
 namespace proxy {
 
 class MessageLoopResource;
 
 // Base class for plugin and host test harnesses. Tests will not use this
 // directly. Instead, use the PluginProxyTest, HostProxyTest, or TwoWayTest.
@@ skipping 12 matching lines @@
   ResourceMessageTestSink& sink() { return sink_; }
 
   virtual PpapiGlobals* GetGlobals() = 0;
   // Returns either the plugin or host dispatcher, depending on the test.
   virtual Dispatcher* GetDispatcher() = 0;
 
   // Set up the harness using an IPC::TestSink to capture messages.
   virtual void SetUpHarness() = 0;
 
   // Set up the harness using a real IPC channel.
-  virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
-                                       base::MessageLoopProxy* ipc_message_loop,
-                                       base::WaitableEvent* shutdown_event,
-                                       bool is_client) = 0;
+  virtual void SetUpHarnessWithChannel(
+      const IPC::ChannelHandle& channel_handle,
+      base::SingleThreadTaskRunner* ipc_task_runner,
+      base::WaitableEvent* shutdown_event,
+      bool is_client) = 0;
 
   virtual void TearDownHarness() = 0;
 
   // Implementation of GetInterface for the dispatcher. This will
   // return NULL for all interfaces unless one is registered by calling
   // RegisterTestInterface();
   const void* GetInterface(const char* name);
 
   // Allows the test to specify an interface implementation for a given
   // interface name. This will be returned when any of the proxy logic
@@ skipping 27 matching lines @@
     return *plugin_globals_->plugin_resource_tracker();
   }
   PluginVarTracker& var_tracker() {
     return *plugin_globals_->plugin_var_tracker();
   }
 
   // ProxyTestHarnessBase implementation.
   virtual PpapiGlobals* GetGlobals();
   virtual Dispatcher* GetDispatcher();
   virtual void SetUpHarness();
-  virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
-                                       base::MessageLoopProxy* ipc_message_loop,
-                                       base::WaitableEvent* shutdown_event,
-                                       bool is_client);
+  virtual void SetUpHarnessWithChannel(
+      const IPC::ChannelHandle& channel_handle,
+      base::SingleThreadTaskRunner* ipc_task_runner,
+      base::WaitableEvent* shutdown_event,
+      bool is_client);
   virtual void TearDownHarness();
 
   class PluginDelegateMock : public PluginDispatcher::PluginDelegate,
                              public PluginProxyDelegate {
    public:
-    PluginDelegateMock() : ipc_message_loop_(NULL), shutdown_event_() {}
+    PluginDelegateMock() : ipc_task_runner_(NULL), shutdown_event_() {}
     ~PluginDelegateMock() override {}
 
-    void Init(base::MessageLoopProxy* ipc_message_loop,
+    void Init(base::SingleThreadTaskRunner* ipc_task_runner,
               base::WaitableEvent* shutdown_event) {
-      ipc_message_loop_ = ipc_message_loop;
+      ipc_task_runner_ = ipc_task_runner;
       shutdown_event_ = shutdown_event;
     }
 
     void set_browser_sender(IPC::Sender* browser_sender) {
       browser_sender_ = browser_sender;
     }
 
     // ProxyChannel::Delegate implementation.
     base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
     base::WaitableEvent* GetShutdownEvent() override;
@@ skipping 15 matching lines @@
     std::string GetUILanguage() override;
     void PreCacheFont(const void* logfontw) override;
     void SetActiveURL(const std::string& url) override;
     PP_Resource CreateBrowserFont(
         Connection connection,
         PP_Instance instance,
         const PP_BrowserFont_Trusted_Description& desc,
         const Preferences& prefs) override;
 
    private:
-    base::MessageLoopProxy* ipc_message_loop_;  // Weak
+    base::SingleThreadTaskRunner* ipc_task_runner_;  // Weak
     base::WaitableEvent* shutdown_event_;  // Weak
     std::set<PP_Instance> instance_id_set_;
     IPC::Sender* browser_sender_;
 
     DISALLOW_COPY_AND_ASSIGN(PluginDelegateMock);
   };
 
  private:
   void CreatePluginGlobals(
       const scoped_refptr<base::TaskRunner>& ipc_task_runner);
@@ skipping 44 matching lines @@
     SECONDARY_THREAD
   };
   void CheckOnThread(ThreadType thread_type);
 
   // These can be called on any thread.
   void PostQuitForMainThread();
   void PostQuitForSecondaryThread();
 
  protected:
   scoped_refptr<MessageLoopResource> secondary_thread_message_loop_;
-  scoped_refptr<base::MessageLoopProxy> main_thread_message_loop_proxy_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
 
  private:
   // base::DelegateSimpleThread::Delegate implementation.
   void Run() override;
 
   void QuitNestedLoop();
 
   static void InternalSetUpTestOnSecondaryThread(void* user_data,
                                                  int32_t result);
 
@@ skipping 11 matching lines @@
     return *host_globals_->GetResourceTracker();
   }
   VarTracker& var_tracker() {
     return *host_globals_->GetVarTracker();
   }
 
   // ProxyTestBase implementation.
   virtual PpapiGlobals* GetGlobals();
   virtual Dispatcher* GetDispatcher();
   virtual void SetUpHarness();
-  virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
-                                       base::MessageLoopProxy* ipc_message_loop,
-                                       base::WaitableEvent* shutdown_event,
-                                       bool is_client);
+  virtual void SetUpHarnessWithChannel(
+      const IPC::ChannelHandle& channel_handle,
+      base::SingleThreadTaskRunner* ipc_task_runner,
+      base::WaitableEvent* shutdown_event,
+      bool is_client);
   virtual void TearDownHarness();
 
   class DelegateMock : public ProxyChannel::Delegate {
    public:
-    DelegateMock() : ipc_message_loop_(NULL), shutdown_event_(NULL) {
-    }
+    DelegateMock() : ipc_task_runner_(NULL), shutdown_event_(NULL) {}
     ~DelegateMock() override {}
 
-    void Init(base::MessageLoopProxy* ipc_message_loop,
+    void Init(base::SingleThreadTaskRunner* ipc_task_runner,
               base::WaitableEvent* shutdown_event) {
-      ipc_message_loop_ = ipc_message_loop;
+      ipc_task_runner_ = ipc_task_runner;
       shutdown_event_ = shutdown_event;
     }
 
     // ProxyChannel::Delegate implementation.
-    base::MessageLoopProxy* GetIPCTaskRunner() override;
+    base::SingleThreadTaskRunner* GetIPCTaskRunner() override;
     base::WaitableEvent* GetShutdownEvent() override;
     IPC::PlatformFileForTransit ShareHandleWithRemote(
         base::PlatformFile handle,
         base::ProcessId remote_pid,
         bool should_close_source) override;
     base::SharedMemoryHandle ShareSharedMemoryHandleWithRemote(
         const base::SharedMemoryHandle& handle,
         base::ProcessId remote_pid) override;
 
    private:
-    base::MessageLoopProxy* ipc_message_loop_;  // Weak
+    base::SingleThreadTaskRunner* ipc_task_runner_;  // Weak
     base::WaitableEvent* shutdown_event_;  // Weak
 
     DISALLOW_COPY_AND_ASSIGN(DelegateMock);
   };
 
  private:
   void CreateHostGlobals();
 
   GlobalsConfiguration globals_config_;
   scoped_ptr<ppapi::TestGlobals> host_globals_;
@@ skipping 70 matching lines @@
 //   EXPECT_VAR_IS_STRING("foo", my_var);
 #define EXPECT_VAR_IS_STRING(str, var) { \
   StringVar* sv = StringVar::FromPPVar(var); \
   EXPECT_TRUE(sv); \
   if (sv) \
     EXPECT_EQ(str, sv->value()); \
 }
 
 }  // namespace proxy
 }  // namespace ppapi