Home | History | Annotate | Download | only in proxy 
      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 "ppapi/proxy/ppapi_proxy_test.h"
      6 
      7 #include <sstream>
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/message_loop/message_loop_proxy.h"
     12 #include "base/observer_list.h"
     13 #include "base/run_loop.h"
     14 #include "ipc/ipc_sync_channel.h"
     15 #include "ipc/message_filter.h"
     16 #include "ppapi/c/pp_errors.h"
     17 #include "ppapi/c/private/ppb_proxy_private.h"
     18 #include "ppapi/proxy/ppapi_messages.h"
     19 #include "ppapi/proxy/ppb_message_loop_proxy.h"
     20 #include "ppapi/shared_impl/proxy_lock.h"
     21 
     22 namespace ppapi {
     23 namespace proxy {
     24 
     25 namespace {
     26 // HostDispatcher requires a PPB_Proxy_Private, so we always provide a fallback
     27 // do-nothing implementation.
     28 void PluginCrashed(PP_Module module) {
     29   NOTREACHED();
     30 };
     31 
     32 PP_Instance GetInstanceForResource(PP_Resource resource) {
     33   // If a test relies on this, we need to implement it.
     34   NOTREACHED();
     35   return 0;
     36 }
     37 
     38 void SetReserveInstanceIDCallback(PP_Module module,
     39                                   PP_Bool (*is_seen)(PP_Module, PP_Instance)) {
     40   // This function gets called in HostDispatcher's constructor.  We simply don't
     41   // worry about Instance uniqueness in tests, so we can ignore the call.
     42 }
     43 
     44 void AddRefModule(PP_Module module) {}
     45 void ReleaseModule(PP_Module module) {}
     46 PP_Bool IsInModuleDestructor(PP_Module module) { return PP_FALSE; }
     47 
     48 PPB_Proxy_Private ppb_proxy_private = {
     49   &PluginCrashed,
     50   &GetInstanceForResource,
     51   &SetReserveInstanceIDCallback,
     52   &AddRefModule,
     53   &ReleaseModule,
     54   &IsInModuleDestructor
     55 };
     56 
     57 // We allow multiple harnesses at a time to respond to 'GetInterface' calls.
     58 // We assume that only 1 harness's GetInterface function will ever support a
     59 // given interface name. In practice, there will either be only 1 GetInterface
     60 // handler (for PluginProxyTest or HostProxyTest), or there will be only 2
     61 // GetInterface handlers (for TwoWayTest).  In the latter case, one handler is
     62 // for the PluginProxyTestHarness and should only respond for PPP interfaces,
     63 // and the other handler is for the HostProxyTestHarness which should only
     64 // ever respond for PPB interfaces.
     65 ObserverList<ProxyTestHarnessBase> get_interface_handlers_;
     66 
     67 const void* MockGetInterface(const char* name) {
     68   ObserverList<ProxyTestHarnessBase>::Iterator it =
     69       get_interface_handlers_;
     70   while (ProxyTestHarnessBase* observer = it.GetNext()) {
     71     const void* interface = observer->GetInterface(name);
     72     if (interface)
     73       return interface;
     74   }
     75   if (strcmp(name, PPB_PROXY_PRIVATE_INTERFACE) == 0)
     76     return &ppb_proxy_private;
     77   return NULL;
     78 }
     79 
     80 void SetUpRemoteHarness(ProxyTestHarnessBase* harness,
     81                         const IPC::ChannelHandle& handle,
     82                         base::MessageLoopProxy* ipc_message_loop_proxy,
     83                         base::WaitableEvent* shutdown_event,
     84                         base::WaitableEvent* harness_set_up) {
     85   harness->SetUpHarnessWithChannel(handle, ipc_message_loop_proxy,
     86                                    shutdown_event, false);
     87   harness_set_up->Signal();
     88 }
     89 
     90 void TearDownRemoteHarness(ProxyTestHarnessBase* harness,
     91                            base::WaitableEvent* harness_torn_down) {
     92   harness->TearDownHarness();
     93   harness_torn_down->Signal();
     94 }
     95 
     96 void RunTaskOnRemoteHarness(const base::Closure& task,
     97                             base::WaitableEvent* task_complete) {
     98  task.Run();
     99  task_complete->Signal();
    100 }
    101 
    102 }  // namespace
    103 
    104 // ProxyTestHarnessBase --------------------------------------------------------
    105 
    106 ProxyTestHarnessBase::ProxyTestHarnessBase() : pp_module_(0x98765),
    107                                                pp_instance_(0x12345) {
    108   get_interface_handlers_.AddObserver(this);
    109 }
    110 
    111 ProxyTestHarnessBase::~ProxyTestHarnessBase() {
    112   get_interface_handlers_.RemoveObserver(this);
    113 }
    114 
    115 const void* ProxyTestHarnessBase::GetInterface(const char* name) {
    116   return registered_interfaces_[name];
    117 }
    118 
    119 void ProxyTestHarnessBase::RegisterTestInterface(const char* name,
    120                                                  const void* test_interface) {
    121   registered_interfaces_[name] = test_interface;
    122 }
    123 
    124 bool ProxyTestHarnessBase::SupportsInterface(const char* name) {
    125   sink().ClearMessages();
    126 
    127   // IPC doesn't actually write to this when we send a message manually
    128   // not actually using IPC.
    129   bool unused_result = false;
    130   PpapiMsg_SupportsInterface msg(name, &unused_result);
    131   GetDispatcher()->OnMessageReceived(msg);
    132 
    133   const IPC::Message* reply_msg =
    134       sink().GetUniqueMessageMatching(IPC_REPLY_ID);
    135   EXPECT_TRUE(reply_msg);
    136   if (!reply_msg)
    137     return false;
    138 
    139   TupleTypes<PpapiMsg_SupportsInterface::ReplyParam>::ValueTuple reply_data;
    140   EXPECT_TRUE(PpapiMsg_SupportsInterface::ReadReplyParam(
    141       reply_msg, &reply_data));
    142 
    143   sink().ClearMessages();
    144   return reply_data.a;
    145 }
    146 
    147 // PluginProxyTestHarness ------------------------------------------------------
    148 
    149 PluginProxyTestHarness::PluginProxyTestHarness(
    150     GlobalsConfiguration globals_config)
    151     : globals_config_(globals_config) {
    152 }
    153 
    154 PluginProxyTestHarness::~PluginProxyTestHarness() {
    155 }
    156 
    157 PpapiGlobals* PluginProxyTestHarness::GetGlobals() {
    158   return plugin_globals_.get();
    159 }
    160 
    161 Dispatcher* PluginProxyTestHarness::GetDispatcher() {
    162   return plugin_dispatcher_.get();
    163 }
    164 
    165 void PluginProxyTestHarness::SetUpHarness() {
    166   // These must be first since the dispatcher set-up uses them.
    167   CreatePluginGlobals();
    168   // Some of the methods called during set-up check that the lock is held.
    169   ProxyAutoLock lock;
    170 
    171   resource_tracker().DidCreateInstance(pp_instance());
    172 
    173   plugin_dispatcher_.reset(new PluginDispatcher(
    174       &MockGetInterface,
    175       PpapiPermissions(),
    176       false));
    177   plugin_dispatcher_->InitWithTestSink(&sink());
    178   // The plugin proxy delegate is needed for
    179   // |PluginProxyDelegate::GetBrowserSender| which is used
    180   // in |ResourceCreationProxy::GetConnection| to get the channel to the
    181   // browser. In this case we just use the |plugin_dispatcher_| as the channel
    182   // for test purposes.
    183   plugin_delegate_mock_.set_browser_sender(plugin_dispatcher_.get());
    184   PluginGlobals::Get()->SetPluginProxyDelegate(&plugin_delegate_mock_);
    185   plugin_dispatcher_->DidCreateInstance(pp_instance());
    186 }
    187 
    188 void PluginProxyTestHarness::SetUpHarnessWithChannel(
    189     const IPC::ChannelHandle& channel_handle,
    190     base::MessageLoopProxy* ipc_message_loop,
    191     base::WaitableEvent* shutdown_event,
    192     bool is_client) {
    193   // These must be first since the dispatcher set-up uses them.
    194   CreatePluginGlobals();
    195   // Some of the methods called during set-up check that the lock is held.
    196   ProxyAutoLock lock;
    197 
    198   resource_tracker().DidCreateInstance(pp_instance());
    199   plugin_delegate_mock_.Init(ipc_message_loop, shutdown_event);
    200 
    201   plugin_dispatcher_.reset(new PluginDispatcher(
    202       &MockGetInterface,
    203       PpapiPermissions(),
    204       false));
    205   plugin_dispatcher_->InitPluginWithChannel(&plugin_delegate_mock_,
    206                                             base::kNullProcessId,
    207                                             channel_handle,
    208                                             is_client);
    209   plugin_delegate_mock_.set_browser_sender(plugin_dispatcher_.get());
    210   PluginGlobals::Get()->SetPluginProxyDelegate(&plugin_delegate_mock_);
    211   plugin_dispatcher_->DidCreateInstance(pp_instance());
    212 }
    213 
    214 void PluginProxyTestHarness::TearDownHarness() {
    215   {
    216     // Some of the methods called during tear-down check that the lock is held.
    217     ProxyAutoLock lock;
    218 
    219     plugin_dispatcher_->DidDestroyInstance(pp_instance());
    220     plugin_dispatcher_.reset();
    221 
    222     resource_tracker().DidDeleteInstance(pp_instance());
    223   }
    224   plugin_globals_.reset();
    225 }
    226 
    227 void PluginProxyTestHarness::CreatePluginGlobals() {
    228   if (globals_config_ == PER_THREAD_GLOBALS) {
    229     plugin_globals_.reset(new PluginGlobals(PpapiGlobals::PerThreadForTest()));
    230     PpapiGlobals::SetPpapiGlobalsOnThreadForTest(GetGlobals());
    231     // Enable locking in case some other unit test ran before us and disabled
    232     // locking.
    233     ProxyLock::EnableLockingOnThreadForTest();
    234   } else {
    235     plugin_globals_.reset(new PluginGlobals());
    236     ProxyLock::EnableLockingOnThreadForTest();
    237   }
    238 }
    239 
    240 base::MessageLoopProxy*
    241 PluginProxyTestHarness::PluginDelegateMock::GetIPCMessageLoop() {
    242   return ipc_message_loop_;
    243 }
    244 
    245 base::WaitableEvent*
    246 PluginProxyTestHarness::PluginDelegateMock::GetShutdownEvent() {
    247   return shutdown_event_;
    248 }
    249 
    250 IPC::PlatformFileForTransit
    251 PluginProxyTestHarness::PluginDelegateMock::ShareHandleWithRemote(
    252     base::PlatformFile handle,
    253     base::ProcessId /* remote_pid */,
    254     bool should_close_source) {
    255   return IPC::GetFileHandleForProcess(handle,
    256                                       base::Process::Current().handle(),
    257                                       should_close_source);
    258 }
    259 
    260 std::set<PP_Instance>*
    261 PluginProxyTestHarness::PluginDelegateMock::GetGloballySeenInstanceIDSet() {
    262   return &instance_id_set_;
    263 }
    264 
    265 uint32 PluginProxyTestHarness::PluginDelegateMock::Register(
    266     PluginDispatcher* plugin_dispatcher) {
    267   return 0;
    268 }
    269 
    270 void PluginProxyTestHarness::PluginDelegateMock::Unregister(
    271     uint32 plugin_dispatcher_id) {
    272 }
    273 
    274 IPC::Sender* PluginProxyTestHarness::PluginDelegateMock::GetBrowserSender() {
    275   return browser_sender_;
    276 }
    277 
    278 std::string PluginProxyTestHarness::PluginDelegateMock::GetUILanguage() {
    279   return std::string("en-US");
    280 }
    281 
    282 void PluginProxyTestHarness::PluginDelegateMock::PreCacheFont(
    283     const void* logfontw) {
    284 }
    285 
    286 void PluginProxyTestHarness::PluginDelegateMock::SetActiveURL(
    287     const std::string& url) {
    288 }
    289 
    290 PP_Resource PluginProxyTestHarness::PluginDelegateMock::CreateBrowserFont(
    291     Connection connection,
    292     PP_Instance instance,
    293     const PP_BrowserFont_Trusted_Description& desc,
    294     const Preferences& prefs) {
    295   return 0;
    296 }
    297 
    298 // PluginProxyTest -------------------------------------------------------------
    299 
    300 PluginProxyTest::PluginProxyTest() : PluginProxyTestHarness(SINGLETON_GLOBALS) {
    301 }
    302 
    303 PluginProxyTest::~PluginProxyTest() {
    304 }
    305 
    306 void PluginProxyTest::SetUp() {
    307   SetUpHarness();
    308 }
    309 
    310 void PluginProxyTest::TearDown() {
    311   TearDownHarness();
    312 }
    313 
    314 // PluginProxyMultiThreadTest --------------------------------------------------
    315 
    316 PluginProxyMultiThreadTest::PluginProxyMultiThreadTest() {
    317 }
    318 
    319 PluginProxyMultiThreadTest::~PluginProxyMultiThreadTest() {
    320 }
    321 
    322 void PluginProxyMultiThreadTest::RunTest() {
    323   main_thread_message_loop_proxy_ =
    324       PpapiGlobals::Get()->GetMainThreadMessageLoop();
    325   ASSERT_EQ(main_thread_message_loop_proxy_.get(),
    326             base::MessageLoopProxy::current().get());
    327   nested_main_thread_message_loop_.reset(new base::RunLoop());
    328 
    329   secondary_thread_.reset(new base::DelegateSimpleThread(
    330       this, "PluginProxyMultiThreadTest"));
    331 
    332   {
    333     ProxyAutoLock auto_lock;
    334 
    335     // MessageLoopResource assumes that the proxy lock has been acquired.
    336     secondary_thread_message_loop_ = new MessageLoopResource(pp_instance());
    337 
    338     ASSERT_EQ(PP_OK,
    339         secondary_thread_message_loop_->PostWork(
    340             PP_MakeCompletionCallback(
    341                 &PluginProxyMultiThreadTest::InternalSetUpTestOnSecondaryThread,
    342                 this),
    343             0));
    344   }
    345 
    346   SetUpTestOnMainThread();
    347 
    348   secondary_thread_->Start();
    349   nested_main_thread_message_loop_->Run();
    350   secondary_thread_->Join();
    351 
    352   {
    353     ProxyAutoLock auto_lock;
    354 
    355     // The destruction requires a valid PpapiGlobals instance, so we should
    356     // explicitly release it.
    357     secondary_thread_message_loop_ = NULL;
    358   }
    359 
    360   secondary_thread_.reset(NULL);
    361   nested_main_thread_message_loop_.reset(NULL);
    362   main_thread_message_loop_proxy_ = NULL;
    363 }
    364 
    365 void PluginProxyMultiThreadTest::CheckOnThread(ThreadType thread_type) {
    366   ProxyAutoLock auto_lock;
    367   if (thread_type == MAIN_THREAD) {
    368     ASSERT_TRUE(MessageLoopResource::GetCurrent()->is_main_thread_loop());
    369   } else {
    370     ASSERT_EQ(secondary_thread_message_loop_.get(),
    371               MessageLoopResource::GetCurrent());
    372   }
    373 }
    374 
    375 void PluginProxyMultiThreadTest::PostQuitForMainThread() {
    376   main_thread_message_loop_proxy_->PostTask(
    377       FROM_HERE,
    378       base::Bind(&PluginProxyMultiThreadTest::QuitNestedLoop,
    379                  base::Unretained(this)));
    380 }
    381 
    382 void PluginProxyMultiThreadTest::PostQuitForSecondaryThread() {
    383   ProxyAutoLock auto_lock;
    384   secondary_thread_message_loop_->PostQuit(PP_TRUE);
    385 }
    386 
    387 void PluginProxyMultiThreadTest::Run() {
    388   ProxyAutoLock auto_lock;
    389   ASSERT_EQ(PP_OK, secondary_thread_message_loop_->AttachToCurrentThread());
    390   ASSERT_EQ(PP_OK, secondary_thread_message_loop_->Run());
    391   secondary_thread_message_loop_->DetachFromThread();
    392 }
    393 
    394 void PluginProxyMultiThreadTest::QuitNestedLoop() {
    395   nested_main_thread_message_loop_->Quit();
    396 }
    397 
    398 // static
    399 void PluginProxyMultiThreadTest::InternalSetUpTestOnSecondaryThread(
    400     void* user_data,
    401     int32_t result) {
    402   EXPECT_EQ(PP_OK, result);
    403   PluginProxyMultiThreadTest* thiz =
    404       static_cast<PluginProxyMultiThreadTest*>(user_data);
    405   thiz->CheckOnThread(SECONDARY_THREAD);
    406   thiz->SetUpTestOnSecondaryThread();
    407 }
    408 
    409 // HostProxyTestHarness --------------------------------------------------------
    410 
    411 HostProxyTestHarness::HostProxyTestHarness(GlobalsConfiguration globals_config)
    412     : globals_config_(globals_config) {
    413 }
    414 
    415 HostProxyTestHarness::~HostProxyTestHarness() {
    416 }
    417 
    418 PpapiGlobals* HostProxyTestHarness::GetGlobals() {
    419   return host_globals_.get();
    420 }
    421 
    422 Dispatcher* HostProxyTestHarness::GetDispatcher() {
    423   return host_dispatcher_.get();
    424 }
    425 
    426 void HostProxyTestHarness::SetUpHarness() {
    427   // These must be first since the dispatcher set-up uses them.
    428   CreateHostGlobals();
    429 
    430   host_dispatcher_.reset(new HostDispatcher(
    431       pp_module(),
    432       &MockGetInterface,
    433       PpapiPermissions::AllPermissions()));
    434   host_dispatcher_->InitWithTestSink(&sink());
    435   HostDispatcher::SetForInstance(pp_instance(), host_dispatcher_.get());
    436 }
    437 
    438 void HostProxyTestHarness::SetUpHarnessWithChannel(
    439     const IPC::ChannelHandle& channel_handle,
    440     base::MessageLoopProxy* ipc_message_loop,
    441     base::WaitableEvent* shutdown_event,
    442     bool is_client) {
    443   // These must be first since the dispatcher set-up uses them.
    444   CreateHostGlobals();
    445 
    446   delegate_mock_.Init(ipc_message_loop, shutdown_event);
    447 
    448   host_dispatcher_.reset(new HostDispatcher(
    449       pp_module(),
    450       &MockGetInterface,
    451       PpapiPermissions::AllPermissions()));
    452   ppapi::Preferences preferences;
    453   host_dispatcher_->InitHostWithChannel(&delegate_mock_,
    454                                         base::kNullProcessId, channel_handle,
    455                                         is_client, preferences);
    456   HostDispatcher::SetForInstance(pp_instance(), host_dispatcher_.get());
    457 }
    458 
    459 void HostProxyTestHarness::TearDownHarness() {
    460   HostDispatcher::RemoveForInstance(pp_instance());
    461   host_dispatcher_.reset();
    462   host_globals_.reset();
    463 }
    464 
    465 void HostProxyTestHarness::CreateHostGlobals() {
    466   if (globals_config_ == PER_THREAD_GLOBALS) {
    467     host_globals_.reset(new TestGlobals(PpapiGlobals::PerThreadForTest()));
    468     PpapiGlobals::SetPpapiGlobalsOnThreadForTest(GetGlobals());
    469     // The host side of the proxy does not lock.
    470     ProxyLock::DisableLockingOnThreadForTest();
    471   } else {
    472     ProxyLock::DisableLockingOnThreadForTest();
    473     host_globals_.reset(new TestGlobals());
    474   }
    475 }
    476 
    477 base::MessageLoopProxy*
    478 HostProxyTestHarness::DelegateMock::GetIPCMessageLoop() {
    479   return ipc_message_loop_;
    480 }
    481 
    482 base::WaitableEvent* HostProxyTestHarness::DelegateMock::GetShutdownEvent() {
    483   return shutdown_event_;
    484 }
    485 
    486 IPC::PlatformFileForTransit
    487 HostProxyTestHarness::DelegateMock::ShareHandleWithRemote(
    488     base::PlatformFile handle,
    489     base::ProcessId /* remote_pid */,
    490     bool should_close_source) {
    491   return IPC::GetFileHandleForProcess(handle,
    492                                       base::Process::Current().handle(),
    493                                       should_close_source);
    494 }
    495 
    496 
    497 // HostProxyTest ---------------------------------------------------------------
    498 
    499 HostProxyTest::HostProxyTest() : HostProxyTestHarness(SINGLETON_GLOBALS) {
    500 }
    501 
    502 HostProxyTest::~HostProxyTest() {
    503 }
    504 
    505 void HostProxyTest::SetUp() {
    506   SetUpHarness();
    507 }
    508 
    509 void HostProxyTest::TearDown() {
    510   TearDownHarness();
    511 }
    512 
    513 // TwoWayTest ---------------------------------------------------------------
    514 
    515 TwoWayTest::TwoWayTest(TwoWayTest::TwoWayTestMode test_mode)
    516     : test_mode_(test_mode),
    517       host_(ProxyTestHarnessBase::PER_THREAD_GLOBALS),
    518       plugin_(ProxyTestHarnessBase::PER_THREAD_GLOBALS),
    519       io_thread_("TwoWayTest_IOThread"),
    520       plugin_thread_("TwoWayTest_PluginThread"),
    521       remote_harness_(NULL),
    522       local_harness_(NULL),
    523       channel_created_(true, false),
    524       shutdown_event_(true, false) {
    525   if (test_mode == TEST_PPP_INTERFACE) {
    526     remote_harness_ = &plugin_;
    527     local_harness_ = &host_;
    528   } else {
    529     remote_harness_ = &host_;
    530     local_harness_ = &plugin_;
    531   }
    532 }
    533 
    534 TwoWayTest::~TwoWayTest() {
    535   shutdown_event_.Signal();
    536 }
    537 
    538 void TwoWayTest::SetUp() {
    539   base::Thread::Options options;
    540   options.message_loop_type = base::MessageLoop::TYPE_IO;
    541   io_thread_.StartWithOptions(options);
    542   plugin_thread_.Start();
    543 
    544   // Construct the IPC handle name using the process ID so we can safely run
    545   // multiple |TwoWayTest|s concurrently.
    546   std::ostringstream handle_name;
    547   handle_name << "TwoWayTestChannel" << base::GetCurrentProcId();
    548   IPC::ChannelHandle handle(handle_name.str());
    549   base::WaitableEvent remote_harness_set_up(true, false);
    550   plugin_thread_.message_loop_proxy()->PostTask(
    551       FROM_HERE,
    552       base::Bind(&SetUpRemoteHarness,
    553                  remote_harness_,
    554                  handle,
    555                  io_thread_.message_loop_proxy(),
    556                  &shutdown_event_,
    557                  &remote_harness_set_up));
    558   remote_harness_set_up.Wait();
    559   local_harness_->SetUpHarnessWithChannel(handle,
    560                                           io_thread_.message_loop_proxy().get(),
    561                                           &shutdown_event_,
    562                                           true);  // is_client
    563 }
    564 
    565 void TwoWayTest::TearDown() {
    566   base::WaitableEvent remote_harness_torn_down(true, false);
    567   plugin_thread_.message_loop_proxy()->PostTask(
    568       FROM_HERE,
    569       base::Bind(&TearDownRemoteHarness,
    570                  remote_harness_,
    571                  &remote_harness_torn_down));
    572   remote_harness_torn_down.Wait();
    573 
    574   local_harness_->TearDownHarness();
    575 
    576   io_thread_.Stop();
    577 }
    578 
    579 void TwoWayTest::PostTaskOnRemoteHarness(const base::Closure& task) {
    580   base::WaitableEvent task_complete(true, false);
    581   plugin_thread_.message_loop_proxy()->PostTask(FROM_HERE,
    582       base::Bind(&RunTaskOnRemoteHarness,
    583                  task,
    584                  &task_complete));
    585   task_complete.Wait();
    586 }
    587 
    588 
    589 }  // namespace proxy
    590 }  // namespace ppapi
    591