ppapi/proxy/talk_resource_unittest.cc

   1 // Copyright 2013 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/locking_resource_releaser.h"
   6 #include "ppapi/proxy/ppapi_messages.h"
   7 #include "ppapi/proxy/ppapi_proxy_test.h"
   8 #include "ppapi/proxy/talk_resource.h"
   9 #include "ppapi/thunk/thunk.h"
  10
  11 namespace ppapi {
  12 namespace proxy {
  13
  14 namespace {
  15
  16 template <class ResultType>
  17 class MockCallbackBase {
  18  public:
  19   MockCallbackBase() : called_(false) {
  20   }
  21
  22   bool called() {
  23     return called_;
  24   }
  25
  26   ResultType result() {
  27     return result_;
  28   }
  29
  30   void Reset() {
  31     called_ = false;
  32   }
  33
  34   static void Callback(void* user_data, ResultType result) {
  35     MockCallbackBase* that = reinterpret_cast<MockCallbackBase*>(user_data);
  36     that->called_ = true;
  37     that->result_ = result;
  38   }
  39
  40  private:
  41   bool called_;
  42   ResultType result_;
  43 };
  44
  45 typedef MockCallbackBase<int32_t> MockCompletionCallback;
  46 typedef MockCallbackBase<PP_TalkEvent> TalkEventCallback;
  47
  48 class TalkResourceTest : public PluginProxyTest {
  49  public:
  50   void SendReply(
  51       uint32_t id,
  52       const IPC::Message& reply,
  53       int32_t result) {
  54     IPC::Message msg;
  55     ResourceMessageCallParams params;
  56     ASSERT_TRUE(sink().GetFirstResourceCallMatching(id, &params, &msg));
  57
  58     ResourceMessageReplyParams reply_params(params.pp_resource(),
  59                                             params.sequence());
  60     reply_params.set_result(result);
  61     IPC::Message reply_msg = PpapiPluginMsg_ResourceReply(reply_params, reply);
  62     ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(reply_msg));
  63   }
  64 };
  65
  66
  67 }  // namespace
  68
  69 TEST_F(TalkResourceTest, GetPermission) {
  70   const PPB_Talk_Private_1_0* talk = thunk::GetPPB_Talk_Private_1_0_Thunk();
  71   LockingResourceReleaser res(talk->Create(pp_instance()));
  72   MockCompletionCallback callback;
  73
  74   int32_t result = talk->GetPermission(
  75       res.get(),
  76       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
  77   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
  78
  79   ResourceMessageCallParams params;
  80   IPC::Message msg;
  81   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
  82       PpapiHostMsg_Talk_RequestPermission::ID, &params, &msg));
  83
  84   ResourceMessageReplyParams reply_params(params.pp_resource(),
  85                                           params.sequence());
  86   reply_params.set_result(1);
  87   IPC::Message reply = PpapiPluginMsg_ResourceReply(
  88       reply_params, PpapiPluginMsg_Talk_RequestPermissionReply());
  89   ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(reply));
  90
  91   ASSERT_TRUE(callback.called());
  92   ASSERT_EQ(1, callback.result());
  93 }
  94
  95 TEST_F(TalkResourceTest, RequestPermission) {
  96   const PPB_Talk_Private_2_0* talk = thunk::GetPPB_Talk_Private_2_0_Thunk();
  97   LockingResourceReleaser res(talk->Create(pp_instance()));
  98   MockCompletionCallback callback;
  99
 100   int32_t result = talk->RequestPermission(
 101       res.get(),
 102       PP_TALKPERMISSION_REMOTING_CONTINUE,
 103       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
 104   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 105
 106   ResourceMessageCallParams params;
 107   IPC::Message msg;
 108   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
 109       PpapiHostMsg_Talk_RequestPermission::ID, &params, &msg));
 110
 111   ResourceMessageReplyParams reply_params(params.pp_resource(),
 112                                           params.sequence());
 113   reply_params.set_result(1);
 114   IPC::Message reply = PpapiPluginMsg_ResourceReply(
 115       reply_params, PpapiPluginMsg_Talk_RequestPermissionReply());
 116   ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(reply));
 117
 118   ASSERT_TRUE(callback.called());
 119   ASSERT_EQ(1, callback.result());
 120 }
 121
 122 TEST_F(TalkResourceTest, StartStopRemoting) {
 123   const PPB_Talk_Private_2_0* talk = thunk::GetPPB_Talk_Private_2_0_Thunk();
 124   LockingResourceReleaser res(talk->Create(pp_instance()));
 125   MockCompletionCallback callback;
 126   TalkEventCallback event_callback;
 127
 128   // Start
 129   int32_t result = talk->StartRemoting(
 130       res.get(),
 131       &TalkEventCallback::Callback,
 132       &event_callback,
 133       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
 134   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 135
 136   SendReply(PpapiHostMsg_Talk_StartRemoting::ID,
 137             PpapiPluginMsg_Talk_StartRemotingReply(),
 138             PP_OK);
 139
 140   ASSERT_TRUE(callback.called());
 141   ASSERT_EQ(PP_OK, callback.result());
 142
 143   // Receive an event
 144   ASSERT_FALSE(event_callback.called());
 145   ResourceMessageReplyParams notify_params(res.get(), 0);
 146   IPC::Message notify = PpapiPluginMsg_ResourceReply(
 147       notify_params, PpapiPluginMsg_Talk_NotifyEvent(PP_TALKEVENT_ERROR));
 148   ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(notify));
 149   ASSERT_TRUE(event_callback.called());
 150   ASSERT_EQ(PP_TALKEVENT_ERROR, event_callback.result());
 151
 152   // Stop
 153   callback.Reset();
 154   result = talk->StopRemoting(
 155       res.get(),
 156       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
 157   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 158
 159   SendReply(PpapiHostMsg_Talk_StopRemoting::ID,
 160            PpapiPluginMsg_Talk_StopRemotingReply(),
 161            PP_OK);
 162
 163   ASSERT_TRUE(callback.called());
 164   ASSERT_EQ(PP_OK, callback.result());
 165
 166   // Events should be discarded at this point
 167   event_callback.Reset();
 168   ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(notify));
 169   ASSERT_FALSE(event_callback.called());
 170 }
 171
 172 }  // namespace proxy
 173 }  // namespace ppapi