ppapi/proxy/ppapi_proxy_test.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <map>
   6 #include <string>
   7
   8 #include "base/message_loop.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/synchronization/waitable_event.h"
  11 #include "base/threading/thread.h"
  12 #include "ppapi/c/pp_instance.h"
  13 #include "ppapi/proxy/host_dispatcher.h"
  14 #include "ppapi/proxy/plugin_dispatcher.h"
  15 #include "ppapi/proxy/plugin_globals.h"
  16 #include "ppapi/proxy/plugin_proxy_delegate.h"
  17 #include "ppapi/proxy/plugin_resource_tracker.h"
  18 #include "ppapi/proxy/plugin_var_tracker.h"
  19 #include "ppapi/proxy/resource_message_test_sink.h"
  20 #include "ppapi/shared_impl/test_globals.h"
  21 #include "testing/gtest/include/gtest/gtest.h"
  22
  23 namespace ppapi {
  24 namespace proxy {
  25
  26 // Base class for plugin and host test harnesses. Tests will not use this
  27 // directly. Instead, use the PluginProxyTest, HostProxyTest, or TwoWayTest.
  28 class ProxyTestHarnessBase {
  29  public:
  30   ProxyTestHarnessBase();
  31   virtual ~ProxyTestHarnessBase();
  32
  33   PP_Module pp_module() const { return pp_module_; }
  34   PP_Instance pp_instance() const { return pp_instance_; }
  35   ResourceMessageTestSink& sink() { return sink_; }
  36
  37   virtual PpapiGlobals* GetGlobals() = 0;
  38   // Returns either the plugin or host dispatcher, depending on the test.
  39   virtual Dispatcher* GetDispatcher() = 0;
  40
  41   // Set up the harness using an IPC::TestSink to capture messages.
  42   virtual void SetUpHarness() = 0;
  43
  44   // Set up the harness using a real IPC channel.
  45   virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
  46                                        base::MessageLoopProxy* ipc_message_loop,
  47                                        base::WaitableEvent* shutdown_event,
  48                                        bool is_client) = 0;
  49
  50   virtual void TearDownHarness() = 0;
  51
  52   // Implementation of GetInterface for the dispatcher. This will
  53   // return NULL for all interfaces unless one is registered by calling
  54   // RegisterTestInterface();
  55   const void* GetInterface(const char* name);
  56
  57   // Allows the test to specify an interface implementation for a given
  58   // interface name. This will be returned when any of the proxy logic
  59   // requests a local interface.
  60   void RegisterTestInterface(const char* name, const void* test_interface);
  61
  62   // Sends a "supports interface" message to the current dispatcher and returns
  63   // true if it's supported. This is just for the convenience of tests.
  64   bool SupportsInterface(const char* name);
  65
  66  private:
  67   // Destination for IPC messages sent by the test.
  68   ResourceMessageTestSink sink_;
  69
  70   // The module and instance ID associated with the plugin dispatcher.
  71   PP_Module pp_module_;
  72   PP_Instance pp_instance_;
  73
  74   // Stores the data for GetInterface/RegisterTestInterface.
  75   std::map<std::string, const void*> registered_interfaces_;
  76 };
  77
  78 // Test harness for the plugin side of the proxy.
  79 class PluginProxyTestHarness : public ProxyTestHarnessBase {
  80  public:
  81   PluginProxyTestHarness();
  82   virtual ~PluginProxyTestHarness();
  83
  84   PluginDispatcher* plugin_dispatcher() { return plugin_dispatcher_.get(); }
  85   PluginResourceTracker& resource_tracker() {
  86     return *plugin_globals_->plugin_resource_tracker();
  87   }
  88   PluginVarTracker& var_tracker() {
  89     return *plugin_globals_->plugin_var_tracker();
  90   }
  91
  92   // ProxyTestHarnessBase implementation.
  93   virtual PpapiGlobals* GetGlobals();
  94   virtual Dispatcher* GetDispatcher();
  95   virtual void SetUpHarness();
  96   virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
  97                                        base::MessageLoopProxy* ipc_message_loop,
  98                                        base::WaitableEvent* shutdown_event,
  99                                        bool is_client);
 100   virtual void TearDownHarness();
 101
 102   class PluginDelegateMock : public PluginDispatcher::PluginDelegate,
 103                              public PluginProxyDelegate {
 104    public:
 105     PluginDelegateMock() : ipc_message_loop_(NULL), shutdown_event_() {}
 106     virtual ~PluginDelegateMock() {}
 107
 108     void Init(base::MessageLoopProxy* ipc_message_loop,
 109               base::WaitableEvent* shutdown_event) {
 110       ipc_message_loop_ = ipc_message_loop;
 111       shutdown_event_ = shutdown_event;
 112     }
 113
 114     void set_browser_sender(IPC::Sender* browser_sender) {
 115       browser_sender_ = browser_sender;
 116     }
 117
 118     // ProxyChannel::Delegate implementation.
 119     virtual base::MessageLoopProxy* GetIPCMessageLoop() OVERRIDE;
 120     virtual base::WaitableEvent* GetShutdownEvent() OVERRIDE;
 121     virtual IPC::PlatformFileForTransit ShareHandleWithRemote(
 122         base::PlatformFile handle,
 123         const IPC::SyncChannel& /* channel */,
 124         bool should_close_source) OVERRIDE;
 125
 126     // PluginDispatcher::PluginDelegate implementation.
 127     virtual std::set<PP_Instance>* GetGloballySeenInstanceIDSet() OVERRIDE;
 128     virtual uint32 Register(PluginDispatcher* plugin_dispatcher) OVERRIDE;
 129     virtual void Unregister(uint32 plugin_dispatcher_id) OVERRIDE;
 130
 131     // PluginProxyDelegate implementation.
 132     virtual IPC::Sender* GetBrowserSender() OVERRIDE;
 133     virtual std::string GetUILanguage() OVERRIDE;
 134     virtual void PreCacheFont(const void* logfontw) OVERRIDE;
 135     virtual void SetActiveURL(const std::string& url) OVERRIDE;
 136
 137    private:
 138     base::MessageLoopProxy* ipc_message_loop_;  // Weak
 139     base::WaitableEvent* shutdown_event_;  // Weak
 140     std::set<PP_Instance> instance_id_set_;
 141     IPC::Sender* browser_sender_;
 142
 143     DISALLOW_COPY_AND_ASSIGN(PluginDelegateMock);
 144   };
 145
 146  private:
 147   scoped_ptr<PluginGlobals> plugin_globals_;
 148
 149   scoped_ptr<PluginDispatcher> plugin_dispatcher_;
 150   PluginDelegateMock plugin_delegate_mock_;
 151 };
 152
 153 class PluginProxyTest : public PluginProxyTestHarness, public testing::Test {
 154  public:
 155   PluginProxyTest();
 156   virtual ~PluginProxyTest();
 157
 158   // testing::Test implementation.
 159   virtual void SetUp();
 160   virtual void TearDown();
 161  private:
 162   MessageLoop message_loop_;
 163 };
 164
 165 class HostProxyTestHarness : public ProxyTestHarnessBase {
 166  public:
 167   HostProxyTestHarness();
 168   virtual ~HostProxyTestHarness();
 169
 170   HostDispatcher* host_dispatcher() { return host_dispatcher_.get(); }
 171   ResourceTracker& resource_tracker() {
 172     return *host_globals_->GetResourceTracker();
 173   }
 174   VarTracker& var_tracker() {
 175     return *host_globals_->GetVarTracker();
 176   }
 177
 178   // ProxyTestBase implementation.
 179   virtual PpapiGlobals* GetGlobals();
 180   virtual Dispatcher* GetDispatcher();
 181   virtual void SetUpHarness();
 182   virtual void SetUpHarnessWithChannel(const IPC::ChannelHandle& channel_handle,
 183                                        base::MessageLoopProxy* ipc_message_loop,
 184                                        base::WaitableEvent* shutdown_event,
 185                                        bool is_client);
 186   virtual void TearDownHarness();
 187
 188   class DelegateMock : public ProxyChannel::Delegate {
 189    public:
 190     DelegateMock() : ipc_message_loop_(NULL), shutdown_event_(NULL) {
 191     }
 192     virtual ~DelegateMock() {}
 193
 194     void Init(base::MessageLoopProxy* ipc_message_loop,
 195               base::WaitableEvent* shutdown_event) {
 196       ipc_message_loop_ = ipc_message_loop;
 197       shutdown_event_ = shutdown_event;
 198     }
 199
 200     // ProxyChannel::Delegate implementation.
 201     virtual base::MessageLoopProxy* GetIPCMessageLoop();
 202     virtual base::WaitableEvent* GetShutdownEvent();
 203     virtual IPC::PlatformFileForTransit ShareHandleWithRemote(
 204         base::PlatformFile handle,
 205         const IPC::SyncChannel& /* channel */,
 206         bool should_close_source) OVERRIDE;
 207
 208    private:
 209     base::MessageLoopProxy* ipc_message_loop_;  // Weak
 210     base::WaitableEvent* shutdown_event_;  // Weak
 211
 212     DISALLOW_COPY_AND_ASSIGN(DelegateMock);
 213   };
 214
 215  private:
 216   class MockSyncMessageStatusReceiver;
 217
 218   scoped_ptr<ppapi::TestGlobals> host_globals_;
 219   scoped_ptr<HostDispatcher> host_dispatcher_;
 220   DelegateMock delegate_mock_;
 221
 222   scoped_ptr<MockSyncMessageStatusReceiver> status_receiver_;
 223 };
 224
 225 class HostProxyTest : public HostProxyTestHarness, public testing::Test {
 226  public:
 227   HostProxyTest();
 228   virtual ~HostProxyTest();
 229
 230   // testing::Test implementation.
 231   virtual void SetUp();
 232   virtual void TearDown();
 233  private:
 234   MessageLoop message_loop_;
 235 };
 236
 237 // Use this base class to test both sides of a proxy.
 238 class TwoWayTest : public testing::Test {
 239  public:
 240   enum TwoWayTestMode {
 241     TEST_PPP_INTERFACE,
 242     TEST_PPB_INTERFACE
 243   };
 244   TwoWayTest(TwoWayTestMode test_mode);
 245   virtual ~TwoWayTest();
 246
 247   HostProxyTestHarness& host() { return host_; }
 248   PluginProxyTestHarness& plugin() { return plugin_; }
 249   PP_Module pp_module() const { return host_.pp_module(); }
 250   PP_Instance pp_instance() const { return host_.pp_instance(); }
 251   TwoWayTestMode test_mode() { return test_mode_; }
 252
 253   // testing::Test implementation.
 254   virtual void SetUp();
 255   virtual void TearDown();
 256
 257  protected:
 258   // Post a task to the thread where the remote harness lives. This
 259   // is typically used to test the state of the var tracker on the plugin
 260   // thread. This runs the task synchronously for convenience.
 261   void PostTaskOnRemoteHarness(const base::Closure& task);
 262
 263  private:
 264   TwoWayTestMode test_mode_;
 265   HostProxyTestHarness host_;
 266   PluginProxyTestHarness plugin_;
 267   // In order to use sync IPC, we need to have an IO thread.
 268   base::Thread io_thread_;
 269   // The plugin side of the proxy runs on its own thread.
 270   base::Thread plugin_thread_;
 271   // The message loop for the main (host) thread.
 272   MessageLoop message_loop_;
 273
 274   // Aliases for the host and plugin harnesses; if we're testing a PPP
 275   // interface, remote_harness will point to plugin_, and local_harness
 276   // will point to host_.  This makes it convenient when we're starting and
 277   // stopping the harnesses.
 278   ProxyTestHarnessBase* remote_harness_;
 279   ProxyTestHarnessBase* local_harness_;
 280
 281   base::WaitableEvent channel_created_;
 282   base::WaitableEvent shutdown_event_;
 283 };
 284
 285 // Used during Gtests when you have a PP_Var that you want to EXPECT is equal
 286 // to a certain constant string value:
 287 //
 288 //   EXPECT_VAR_IS_STRING("foo", my_var);
 289 #define EXPECT_VAR_IS_STRING(str, var) { \
 290   StringVar* sv = StringVar::FromPPVar(var); \
 291   EXPECT_TRUE(sv); \
 292   if (sv) \
 293     EXPECT_EQ(str, sv->value()); \
 294 }
 295
 296 }  // namespace proxy
 297 }  // namespace ppapi