ppp_messaging_proxy_unittest.cc revision 5821806d5e7f356e8fa4b058a389a808ea183019 
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 <cstring>
6
7#include "base/synchronization/waitable_event.h"
8#include "ppapi/c/pp_var.h"
9#include "ppapi/c/ppb_var.h"
10#include "ppapi/c/ppp_messaging.h"
11#include "ppapi/proxy/ppapi_proxy_test.h"
12#include "ppapi/shared_impl/var.h"
13
14namespace ppapi {
15namespace proxy {
16
17namespace {
18
19// This is a poor man's mock of PPP_Messaging using global variables. Eventually
20// we should generalize making PPAPI interface mocks by using IDL or macro/
21// template magic.
22PP_Instance received_instance;
23PP_Var received_var;
24base::WaitableEvent handle_message_called(false, false);
25
26void HandleMessage(PP_Instance instance, PP_Var message_data) {
27  received_instance = instance;
28  received_var = message_data;
29  handle_message_called.Signal();
30}
31
32// Clear all the 'received' values for our mock.  Call this before you expect
33// one of the functions to be invoked.
34void ResetReceived() {
35  received_instance = 0;
36  received_var.type = PP_VARTYPE_UNDEFINED;
37  received_var.value.as_id = 0;
38}
39
40PPP_Messaging ppp_messaging_mock = {
41  &HandleMessage
42};
43
44class PPP_Messaging_ProxyTest : public TwoWayTest {
45 public:
46  PPP_Messaging_ProxyTest()
47      : TwoWayTest(TwoWayTest::TEST_PPP_INTERFACE) {
48    plugin().RegisterTestInterface(PPP_MESSAGING_INTERFACE,
49                                   &ppp_messaging_mock);
50  }
51};
52
53void CompareAndReleaseStringVar(PluginProxyTestHarness* plugin_harness,
54                                PP_Var received_var,
55                                const std::string& test_string) {
56  Var* received_string = plugin_harness->var_tracker().GetVar(received_var);
57  ASSERT_TRUE(received_string);
58  ASSERT_TRUE(received_string->AsStringVar());
59  EXPECT_EQ(test_string, received_string->AsStringVar()->value());
60  // Now release the var, and the string should go away (because the ref
61  // count should be one).
62  plugin_harness->var_tracker().ReleaseVar(received_var);
63  EXPECT_FALSE(StringVar::FromPPVar(received_var));
64}
65
66}  // namespace
67
68TEST_F(PPP_Messaging_ProxyTest, SendMessages) {
69  // Grab the host-side proxy of ppp_messaging.
70  const PPP_Messaging* ppp_messaging = static_cast<const PPP_Messaging*>(
71      host().host_dispatcher()->GetProxiedInterface(
72          PPP_MESSAGING_INTERFACE));
73
74  PP_Instance expected_instance = pp_instance();
75  PP_Var expected_var = PP_MakeUndefined();
76  ResetReceived();
77  ppp_messaging->HandleMessage(expected_instance, expected_var);
78  handle_message_called.Wait();
79  EXPECT_EQ(expected_instance, received_instance);
80  EXPECT_EQ(expected_var.type, received_var.type);
81
82  expected_var = PP_MakeNull();
83  ResetReceived();
84  ppp_messaging->HandleMessage(expected_instance, expected_var);
85  handle_message_called.Wait();
86  EXPECT_EQ(expected_instance, received_instance);
87  EXPECT_EQ(expected_var.type, received_var.type);
88
89  expected_var = PP_MakeBool(PP_TRUE);
90  ResetReceived();
91  ppp_messaging->HandleMessage(expected_instance, expected_var);
92  handle_message_called.Wait();
93  EXPECT_EQ(expected_instance, received_instance);
94  EXPECT_EQ(expected_var.type, received_var.type);
95  EXPECT_EQ(expected_var.value.as_bool, received_var.value.as_bool);
96
97  expected_var = PP_MakeInt32(12345);
98  ResetReceived();
99  ppp_messaging->HandleMessage(expected_instance, expected_var);
100  handle_message_called.Wait();
101  EXPECT_EQ(expected_instance, received_instance);
102  EXPECT_EQ(expected_var.type, received_var.type);
103  EXPECT_EQ(expected_var.value.as_int, received_var.value.as_int);
104
105  expected_var = PP_MakeDouble(3.1415);
106  ResetReceived();
107  ppp_messaging->HandleMessage(expected_instance, expected_var);
108  handle_message_called.Wait();
109  EXPECT_EQ(expected_instance, received_instance);
110  EXPECT_EQ(expected_var.type, received_var.type);
111  EXPECT_EQ(expected_var.value.as_double, received_var.value.as_double);
112
113  const std::string kTestString("Hello world!");
114  expected_var = StringVar::StringToPPVar(kTestString);
115  ResetReceived();
116  ppp_messaging->HandleMessage(expected_instance, expected_var);
117  // Now release the var, and the string should go away (because the ref
118  // count should be one).
119  host().var_tracker().ReleaseVar(expected_var);
120  EXPECT_FALSE(StringVar::FromPPVar(expected_var));
121
122  handle_message_called.Wait();
123  EXPECT_EQ(expected_instance, received_instance);
124  EXPECT_EQ(expected_var.type, received_var.type);
125  PostTaskOnRemoteHarness(
126      base::Bind(CompareAndReleaseStringVar,
127                 &plugin(),
128                 received_var,
129                 kTestString));
130}
131
132}  // namespace proxy
133}  // namespace ppapi
134
135