ppapi/proxy/ppp_instance_proxy_unittest.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 "base/synchronization/waitable_event.h"
   6 #include "ipc/ipc_message_utils.h"
   7 #include "ppapi/c/pp_var.h"
   8 #include "ppapi/c/ppb_core.h"
   9 #include "ppapi/c/ppb_fullscreen.h"
  10 #include "ppapi/c/ppb_url_loader.h"
  11 #include "ppapi/c/ppp_instance.h"
  12 #include "ppapi/c/private/ppb_flash_fullscreen.h"
  13 #include "ppapi/proxy/locking_resource_releaser.h"
  14 #include "ppapi/proxy/ppapi_messages.h"
  15 #include "ppapi/proxy/ppapi_proxy_test.h"
  16 #include "ppapi/shared_impl/ppb_view_shared.h"
  17
  18 namespace ppapi {
  19 namespace proxy {
  20
  21 namespace {
  22 // This is a poor man's mock of PPP_Instance using global variables.  Eventually
  23 // we should generalize making PPAPI interface mocks by using IDL or macro/
  24 // template magic.
  25 PP_Instance received_instance;
  26 uint32_t received_argc;
  27 std::vector<std::string> received_argn;
  28 std::vector<std::string> received_argv;
  29 PP_Bool bool_to_return;
  30 PP_Bool DidCreate(PP_Instance instance, uint32_t argc, const char* argn[],
  31                   const char* argv[]) {
  32   received_instance = instance;
  33   received_argc = argc;
  34   received_argn.clear();
  35   received_argn.insert(received_argn.begin(), argn, argn + argc);
  36   received_argv.clear();
  37   received_argv.insert(received_argv.begin(), argv, argv + argc);
  38   return bool_to_return;
  39 }
  40
  41 void DidDestroy(PP_Instance instance) {
  42   received_instance = instance;
  43 }
  44
  45 PP_Rect received_position;
  46 PP_Rect received_clip;
  47 // DidChangeView is asynchronous. We wait until the call has completed before
  48 // proceeding on to the next test.
  49 base::WaitableEvent did_change_view_called(false, false);
  50 void DidChangeView(PP_Instance instance, const PP_Rect* position,
  51                    const PP_Rect* clip) {
  52   received_instance = instance;
  53   received_position = *position;
  54   received_clip = *clip;
  55   did_change_view_called.Signal();
  56 }
  57
  58 PP_Bool received_has_focus;
  59 base::WaitableEvent did_change_focus_called(false, false);
  60 void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
  61   received_instance = instance;
  62   received_has_focus = has_focus;
  63   did_change_focus_called.Signal();
  64 }
  65
  66 PP_Bool HandleDocumentLoad(PP_Instance instance, PP_Resource url_loader) {
  67   // This one requires use of the PPB_URLLoader proxy and PPB_Core, plus a
  68   // resource tracker for the url_loader resource.
  69   // TODO(dmichael): Mock those out and test this function.
  70   NOTREACHED();
  71   return PP_FALSE;
  72 }
  73
  74 // Clear all the 'received' values for our mock.  Call this before you expect
  75 // one of the functions to be invoked.  TODO(dmichael): It would be better to
  76 // have a flag also for each function, so we know the right one got called.
  77 void ResetReceived() {
  78   received_instance = 0;
  79   received_argc = 0;
  80   received_argn.clear();
  81   received_argv.clear();
  82   memset(&received_position, 0, sizeof(received_position));
  83   memset(&received_clip, 0, sizeof(received_clip));
  84   received_has_focus = PP_FALSE;
  85 }
  86
  87 PPP_Instance_1_0 ppp_instance_1_0 = {
  88   &DidCreate,
  89   &DidDestroy,
  90   &DidChangeView,
  91   &DidChangeFocus,
  92   &HandleDocumentLoad
  93 };
  94
  95 // PPP_Instance_Proxy::DidChangeView relies on PPB_(Flash)Fullscreen being
  96 // available with a valid implementation of IsFullScreen, so we mock it.
  97 PP_Bool IsFullscreen(PP_Instance instance) {
  98   return PP_FALSE;
  99 }
 100 PPB_Fullscreen ppb_fullscreen = { &IsFullscreen };
 101 PPB_FlashFullscreen ppb_flash_fullscreen = { &IsFullscreen };
 102
 103 }  // namespace
 104
 105 class PPP_Instance_ProxyTest : public TwoWayTest {
 106  public:
 107    PPP_Instance_ProxyTest()
 108        : TwoWayTest(TwoWayTest::TEST_PPP_INTERFACE) {
 109    }
 110 };
 111
 112 TEST_F(PPP_Instance_ProxyTest, PPPInstance1_0) {
 113   plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_1_0, &ppp_instance_1_0);
 114   host().RegisterTestInterface(PPB_FLASHFULLSCREEN_INTERFACE,
 115                                &ppb_flash_fullscreen);
 116   host().RegisterTestInterface(PPB_FULLSCREEN_INTERFACE,
 117                                &ppb_fullscreen);
 118
 119   // Grab the host-side proxy for the interface. The browser only speaks 1.1,
 120   // while the proxy ensures support for the 1.0 version on the plugin side.
 121   const PPP_Instance_1_1* ppp_instance = static_cast<const PPP_Instance_1_1*>(
 122       host().host_dispatcher()->GetProxiedInterface(
 123           PPP_INSTANCE_INTERFACE_1_1));
 124
 125   // Call each function in turn, make sure we get the expected values and
 126   // returns.
 127   //
 128   // We don't test DidDestroy, because it has the side-effect of removing the
 129   // PP_Instance from the PluginDispatcher, which will cause a failure later
 130   // when the test is torn down.
 131   PP_Instance expected_instance = pp_instance();
 132   std::vector<std::string> expected_argn, expected_argv;
 133   expected_argn.push_back("Hello");
 134   expected_argn.push_back("world.");
 135   expected_argv.push_back("elloHay");
 136   expected_argv.push_back("orldway.");
 137   std::vector<const char*> argn_to_pass, argv_to_pass;
 138   CHECK(expected_argn.size() == expected_argv.size());
 139   for (size_t i = 0; i < expected_argn.size(); ++i) {
 140     argn_to_pass.push_back(expected_argn[i].c_str());
 141     argv_to_pass.push_back(expected_argv[i].c_str());
 142   }
 143   uint32_t expected_argc = static_cast<uint32_t>(expected_argn.size());
 144   bool_to_return = PP_TRUE;
 145   ResetReceived();
 146   // Tell the host resource tracker about the instance.
 147   host().resource_tracker().DidCreateInstance(expected_instance);
 148   EXPECT_EQ(bool_to_return, ppp_instance->DidCreate(expected_instance,
 149                                                     expected_argc,
 150                                                     &argn_to_pass[0],
 151                                                     &argv_to_pass[0]));
 152   EXPECT_EQ(received_instance, expected_instance);
 153   EXPECT_EQ(received_argc, expected_argc);
 154   EXPECT_EQ(received_argn, expected_argn);
 155   EXPECT_EQ(received_argv, expected_argv);
 156
 157   PP_Rect expected_position = { {1, 2}, {3, 4} };
 158   PP_Rect expected_clip = { {5, 6}, {7, 8} };
 159   ViewData data;
 160   data.rect = expected_position;
 161   data.is_fullscreen = false;
 162   data.is_page_visible = true;
 163   data.clip_rect = expected_clip;
 164   data.device_scale = 1.0f;
 165   ResetReceived();
 166   LockingResourceReleaser view_resource(
 167       (new PPB_View_Shared(OBJECT_IS_IMPL,
 168                            expected_instance, data))->GetReference());
 169   ppp_instance->DidChangeView(expected_instance, view_resource.get());
 170   did_change_view_called.Wait();
 171   EXPECT_EQ(received_instance, expected_instance);
 172   EXPECT_EQ(received_position.point.x, expected_position.point.x);
 173   EXPECT_EQ(received_position.point.y, expected_position.point.y);
 174   EXPECT_EQ(received_position.size.width, expected_position.size.width);
 175   EXPECT_EQ(received_position.size.height, expected_position.size.height);
 176   EXPECT_EQ(received_clip.point.x, expected_clip.point.x);
 177   EXPECT_EQ(received_clip.point.y, expected_clip.point.y);
 178   EXPECT_EQ(received_clip.size.width, expected_clip.size.width);
 179   EXPECT_EQ(received_clip.size.height, expected_clip.size.height);
 180
 181   PP_Bool expected_has_focus = PP_TRUE;
 182   ResetReceived();
 183   ppp_instance->DidChangeFocus(expected_instance, expected_has_focus);
 184   did_change_focus_called.Wait();
 185   EXPECT_EQ(received_instance, expected_instance);
 186   EXPECT_EQ(received_has_focus, expected_has_focus);
 187
 188   //  TODO(dmichael): Need to mock out a resource Tracker to be able to test
 189   //                  HandleResourceLoad. It also requires
 190   //                  PPB_Core.AddRefResource and for PPB_URLLoader to be
 191   //                  registered.
 192
 193   host().resource_tracker().DidDeleteInstance(expected_instance);
 194 }
 195
 196 }  // namespace proxy
 197 }  // namespace ppapi