ppapi/proxy/ppp_instance_proxy_test.cc

// Copyright (c) 2011 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 "base/synchronization/waitable_event.h"
#include "ipc/ipc_message_utils.h"
#include "ppapi/c/dev/ppb_fullscreen_dev.h"
#include "ppapi/c/ppb_core.h"
#include "ppapi/c/ppb_url_loader.h"
#include "ppapi/c/ppp_instance.h"
#include "ppapi/proxy/ppapi_messages.h"
#include "ppapi/proxy/ppapi_proxy_test.h"

namespace pp {
namespace proxy {

namespace {
// This is a poor man's mock of PPP_Instance using global variables.  Eventually
// we should generalize making PPAPI interface mocks by using IDL or macro/
// template magic.
PP_Instance received_instance;
uint32_t received_argc;
std::vector<std::string> received_argn;
std::vector<std::string> received_argv;
PP_Bool bool_to_return;
PP_Bool DidCreate(PP_Instance instance, uint32_t argc, const char* argn[],
                  const char* argv[]) {
  received_instance = instance;
  received_argc = argc;
  received_argn.clear();
  received_argn.insert(received_argn.begin(), argn, argn + argc);
  received_argv.clear();
  received_argv.insert(received_argv.begin(), argv, argv + argc);
  return bool_to_return;
}

void DidDestroy(PP_Instance instance) {
  received_instance = instance;
}

PP_Rect received_position;
PP_Rect received_clip;
// DidChangeView is asynchronous. We wait until the call has completed before
// proceeding on to the next test.
base::WaitableEvent did_change_view_called(false, false);
void DidChangeView(PP_Instance instance, const PP_Rect* position,
                   const PP_Rect* clip) {
  received_instance = instance;
  received_position = *position;
  received_clip = *clip;
  did_change_view_called.Signal();
}

PP_Bool received_has_focus;
base::WaitableEvent did_change_focus_called(false, false);
void DidChangeFocus(PP_Instance instance, PP_Bool has_focus) {
  received_instance = instance;
  received_has_focus = has_focus;
  did_change_focus_called.Signal();
}

PP_InputEvent received_event;
PP_Bool HandleInputEvent(PP_Instance instance, const PP_InputEvent* event) {
  received_instance = instance;
  memcpy(&received_event, event, sizeof(*event));;
  return bool_to_return;
}

PP_Bool HandleDocumentLoad(PP_Instance instance, PP_Resource url_loader) {
  // This one requires use of the PPB_URLLoader proxy and PPB_Core, plus a
  // resource tracker for the url_loader resource.
  // TODO(dmichael): Mock those out and test this function.
  NOTREACHED();
  return PP_FALSE;
}

PP_Var var_to_return;
PP_Var GetInstanceObject(PP_Instance instance) {
  received_instance = instance;
  return var_to_return;
}

// Clear all the 'received' values for our mock.  Call this before you expect
// one of the functions to be invoked.  TODO(dmichael): It would be better to
// have a flag also for each function, so we know the right one got called.
void ResetReceived() {
  received_instance = 0;
  received_argc = 0;
  received_argn.clear();
  received_argv.clear();
  memset(&received_position, 0, sizeof(received_position));
  memset(&received_clip, 0, sizeof(received_clip));
  received_has_focus = PP_FALSE;
  memset(&received_event, 0, sizeof(received_event));
}

PPP_Instance_0_4 ppp_instance_0_4 = {
  &DidCreate,
  &DidDestroy,
  &DidChangeView,
  &DidChangeFocus,
  &HandleInputEvent,
  &HandleDocumentLoad,
  &GetInstanceObject
};

PPP_Instance_0_5 ppp_instance_0_5 = {
  &DidCreate,
  &DidDestroy,
  &DidChangeView,
  &DidChangeFocus,
  &HandleInputEvent,
  &HandleDocumentLoad
};

// PPP_Instance_Proxy::DidChangeView relies on PPB_FullscreenDev being
// available with a valid implementation of IsFullScreen, so we mock it.
PP_Bool IsFullscreen(PP_Instance instance) {
  return PP_FALSE;
}
PPB_Fullscreen_Dev ppb_fullscreen_dev = { &IsFullscreen };

}  // namespace

class PPP_Instance_ProxyTest : public TwoWayTest {
 public:
   PPP_Instance_ProxyTest()
       : TwoWayTest(TwoWayTest::TEST_PPP_INTERFACE) {
   }
};

TEST_F(PPP_Instance_ProxyTest, PPPInstance0_4) {
  plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_0_4, &ppp_instance_0_4);
  host().RegisterTestInterface(PPB_FULLSCREEN_DEV_INTERFACE,
                               &ppb_fullscreen_dev);

  // Try requesting the 0.5 version, like the browser does. This should come
  // back NULL, since we're not registering 0.5.  But this ensures that the
  // behavior through the proxy code reflects more closely what happens for a
  // real plug-in.
  const void* interface =
      host().host_dispatcher()->GetProxiedInterface(PPP_INSTANCE_INTERFACE_0_5);
  EXPECT_EQ(NULL, interface);

  // Grab the host-side proxy for the 0.4 interface.
  const PPP_Instance_0_4* ppp_instance = static_cast<const PPP_Instance_0_4*>(
      host().host_dispatcher()->GetProxiedInterface(
          PPP_INSTANCE_INTERFACE_0_4));

  // Call each function in turn, make sure we get the expected values and
  // returns.
  //
  // We don't test DidDestroy, because it has the side-effect of removing the
  // PP_Instance from the PluginDispatcher, which will cause a failure later
  // when the test is torn down.
  PP_Instance expected_instance = pp_instance();
  std::vector<std::string> expected_argn, expected_argv;
  expected_argn.push_back("Hello");
  expected_argn.push_back("world.");
  expected_argv.push_back("elloHay");
  expected_argv.push_back("orldway.");
  std::vector<const char*> argn_to_pass, argv_to_pass;
  CHECK(expected_argn.size() == expected_argv.size());
  for (size_t i = 0; i < expected_argn.size(); ++i) {
    argn_to_pass.push_back(expected_argn[i].c_str());
    argv_to_pass.push_back(expected_argv[i].c_str());
  }
  uint32_t expected_argc = expected_argn.size();
  bool_to_return = PP_TRUE;
  ResetReceived();
  EXPECT_EQ(bool_to_return, ppp_instance->DidCreate(expected_instance,
                                                    expected_argc,
                                                    &argn_to_pass[0],
                                                    &argv_to_pass[0]));
  EXPECT_EQ(received_instance, expected_instance);
  EXPECT_EQ(received_argc, expected_argc);
  EXPECT_EQ(received_argn, expected_argn);
  EXPECT_EQ(received_argv, expected_argv);

  PP_Rect expected_position = { {1, 2}, {3, 4} };
  PP_Rect expected_clip = { {5, 6}, {7, 8} };
  ResetReceived();
  ppp_instance->DidChangeView(expected_instance, &expected_position,
                              &expected_clip);
  did_change_view_called.Wait();
  EXPECT_EQ(received_instance, expected_instance);
  // If I define operator== for PP_Rect, it has to come before gtest's template
  // definitions in the translation unit, or else it's not found.  So instead of
  // defining operator== before the #include that brings in gtest, I compare the
  // individual parts.
  EXPECT_EQ(received_position.point.x, expected_position.point.x);
  EXPECT_EQ(received_position.point.y, expected_position.point.y);
  EXPECT_EQ(received_position.size.width, expected_position.size.width);
  EXPECT_EQ(received_position.size.height, expected_position.size.height);
  EXPECT_EQ(received_clip.point.x, expected_clip.point.x);
  EXPECT_EQ(received_clip.point.y, expected_clip.point.y);
  EXPECT_EQ(received_clip.size.width, expected_clip.size.width);
  EXPECT_EQ(received_clip.size.height, expected_clip.size.height);

  PP_Bool expected_has_focus = PP_TRUE;
  ResetReceived();
  ppp_instance->DidChangeFocus(expected_instance, expected_has_focus);
  did_change_focus_called.Wait();
  EXPECT_EQ(received_instance, expected_instance);
  EXPECT_EQ(received_has_focus, expected_has_focus);

  PP_InputEvent expected_event = { PP_INPUTEVENT_TYPE_KEYDOWN,  // type
                                   0,  // padding
                                   1.0,  // time_stamp
                                   { { 2, 3 } } };  // u (as PP_InputEvent_Key)
  ResetReceived();
  EXPECT_EQ(bool_to_return,
            ppp_instance->HandleInputEvent(expected_instance, &expected_event));
  EXPECT_EQ(received_instance, expected_instance);
  ASSERT_EQ(received_event.type, expected_event.type);
  // Ignore padding; it's okay if it's not serialized.
  EXPECT_EQ(received_event.time_stamp, expected_event.time_stamp);
  EXPECT_EQ(received_event.u.key.modifier, expected_event.u.key.modifier);
  EXPECT_EQ(received_event.u.key.key_code, expected_event.u.key.key_code);

  //  TODO(dmichael): Need to mock out a resource Tracker to be able to test
  //                  HandleResourceLoad. It also requires
  //                  PPB_Core.AddRefResource and for PPB_URLLoader to be
  //                  registered.

  var_to_return = PP_MakeInt32(100);
  ResetReceived();
  PP_Var result(ppp_instance->GetInstanceObject(expected_instance));
  ASSERT_EQ(var_to_return.type, result.type);
  EXPECT_EQ(var_to_return.value.as_int, result.value.as_int);
  EXPECT_EQ(received_instance, expected_instance);
}

TEST_F(PPP_Instance_ProxyTest, PPPInstance0_5) {
  plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_0_5, &ppp_instance_0_5);
  host().RegisterTestInterface(PPB_FULLSCREEN_DEV_INTERFACE,
                               &ppb_fullscreen_dev);

  // Grab the host-side proxy for the 0.5 interface.
  const PPP_Instance_0_5* ppp_instance = static_cast<const PPP_Instance_0_5*>(
      host().host_dispatcher()->GetProxiedInterface(
          PPP_INSTANCE_INTERFACE_0_5));

  // Call each function in turn, make sure we get the expected values and
  // returns.
  //
  // We don't test DidDestroy, because it has the side-effect of removing the
  // PP_Instance from the PluginDispatcher, which will cause a failure later
  // when the test is torn down.
  PP_Instance expected_instance = pp_instance();
  std::vector<std::string> expected_argn, expected_argv;
  expected_argn.push_back("Hello");
  expected_argn.push_back("world.");
  expected_argv.push_back("elloHay");
  expected_argv.push_back("orldway.");
  std::vector<const char*> argn_to_pass, argv_to_pass;
  CHECK(expected_argn.size() == expected_argv.size());
  for (size_t i = 0; i < expected_argn.size(); ++i) {
    argn_to_pass.push_back(expected_argn[i].c_str());
    argv_to_pass.push_back(expected_argv[i].c_str());
  }
  uint32_t expected_argc = expected_argn.size();
  bool_to_return = PP_TRUE;
  ResetReceived();
  EXPECT_EQ(bool_to_return, ppp_instance->DidCreate(expected_instance,
                                                    expected_argc,
                                                    &argn_to_pass[0],
                                                    &argv_to_pass[0]));
  EXPECT_EQ(received_instance, expected_instance);
  EXPECT_EQ(received_argc, expected_argc);
  EXPECT_EQ(received_argn, expected_argn);
  EXPECT_EQ(received_argv, expected_argv);

  PP_Rect expected_position = { {1, 2}, {3, 4} };
  PP_Rect expected_clip = { {5, 6}, {7, 8} };
  ResetReceived();
  ppp_instance->DidChangeView(expected_instance, &expected_position,
                              &expected_clip);
  did_change_view_called.Wait();
  EXPECT_EQ(received_instance, expected_instance);
  EXPECT_EQ(received_position.point.x, expected_position.point.x);
  EXPECT_EQ(received_position.point.y, expected_position.point.y);
  EXPECT_EQ(received_position.size.width, expected_position.size.width);
  EXPECT_EQ(received_position.size.height, expected_position.size.height);
  EXPECT_EQ(received_clip.point.x, expected_clip.point.x);
  EXPECT_EQ(received_clip.point.y, expected_clip.point.y);
  EXPECT_EQ(received_clip.size.width, expected_clip.size.width);
  EXPECT_EQ(received_clip.size.height, expected_clip.size.height);

  PP_Bool expected_has_focus = PP_TRUE;
  ResetReceived();
  ppp_instance->DidChangeFocus(expected_instance, expected_has_focus);
  did_change_focus_called.Wait();
  EXPECT_EQ(received_instance, expected_instance);
  EXPECT_EQ(received_has_focus, expected_has_focus);

  PP_InputEvent expected_event = { PP_INPUTEVENT_TYPE_KEYDOWN,  // type
                                   0,  // padding
                                   1.0,  // time_stamp
                                   { { 2, 3 } } };  // u (as PP_InputEvent_Key)
  ResetReceived();
  EXPECT_EQ(bool_to_return,
            ppp_instance->HandleInputEvent(expected_instance, &expected_event));
  EXPECT_EQ(received_instance, expected_instance);
  ASSERT_EQ(received_event.type, expected_event.type);
  // Ignore padding; it's okay if it's not serialized.
  EXPECT_EQ(received_event.time_stamp, expected_event.time_stamp);
  EXPECT_EQ(received_event.u.key.modifier, expected_event.u.key.modifier);
  EXPECT_EQ(received_event.u.key.key_code, expected_event.u.key.key_code);

  //  TODO(dmichael): Need to mock out a resource Tracker to be able to test
  //                  HandleResourceLoad. It also requires
  //                  PPB_Core.AddRefResource and for PPB_URLLoader to be
  //                  registered.
}

}  // namespace proxy
}  // namespace pp