ppapi/proxy/ppapi_proxy_test.cc

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