Support using TrackedCallbacks as hints to determine the handling thread of resource reply messages

ppapi/proxy/talk_resource_unittest.cc

 // Copyright 2013 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 "ppapi/proxy/locking_resource_releaser.h"
+#include "ppapi/proxy/plugin_message_filter.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppapi_proxy_test.h"
 #include "ppapi/proxy/talk_resource.h"
 #include "ppapi/thunk/thunk.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
@@ skipping 35 matching lines @@
       uint32_t id,
       const IPC::Message& reply,
       int32_t result) {
     IPC::Message msg;
     ResourceMessageCallParams params;
     ASSERT_TRUE(sink().GetFirstResourceCallMatching(id, &params, &msg));
 
     ResourceMessageReplyParams reply_params(params.pp_resource(),
                                             params.sequence());
     reply_params.set_result(result);
-    IPC::Message reply_msg = PpapiPluginMsg_ResourceReply(reply_params, reply);
-    ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(reply_msg));
+    PluginMessageFilter::DispatchResourceReplyForTest(reply_params, reply);
   }
 };
 
 
 }  // namespace
 
 TEST_F(TalkResourceTest, GetPermission) {
   const PPB_Talk_Private_1_0* talk = thunk::GetPPB_Talk_Private_1_0_Thunk();
   LockingResourceReleaser res(talk->Create(pp_instance()));
   MockCompletionCallback callback;
 
   int32_t result = talk->GetPermission(
       res.get(),
       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   ResourceMessageCallParams params;
   IPC::Message msg;
   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
       PpapiHostMsg_Talk_RequestPermission::ID, &params, &msg));
 
   ResourceMessageReplyParams reply_params(params.pp_resource(),
                                           params.sequence());
   reply_params.set_result(1);
-  IPC::Message reply = PpapiPluginMsg_ResourceReply(
+  PluginMessageFilter::DispatchResourceReplyForTest(
       reply_params, PpapiPluginMsg_Talk_RequestPermissionReply());
-  ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(reply));
 
   ASSERT_TRUE(callback.called());
   ASSERT_EQ(1, callback.result());
 }
 
 TEST_F(TalkResourceTest, RequestPermission) {
   const PPB_Talk_Private_2_0* talk = thunk::GetPPB_Talk_Private_2_0_Thunk();
   LockingResourceReleaser res(talk->Create(pp_instance()));
   MockCompletionCallback callback;
 
   int32_t result = talk->RequestPermission(
       res.get(),
       PP_TALKPERMISSION_REMOTING_CONTINUE,
       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   ResourceMessageCallParams params;
   IPC::Message msg;
   ASSERT_TRUE(sink().GetFirstResourceCallMatching(
       PpapiHostMsg_Talk_RequestPermission::ID, &params, &msg));
 
   ResourceMessageReplyParams reply_params(params.pp_resource(),
                                           params.sequence());
   reply_params.set_result(1);
-  IPC::Message reply = PpapiPluginMsg_ResourceReply(
+  PluginMessageFilter::DispatchResourceReplyForTest(
       reply_params, PpapiPluginMsg_Talk_RequestPermissionReply());
-  ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(reply));
 
   ASSERT_TRUE(callback.called());
   ASSERT_EQ(1, callback.result());
 }
 
 TEST_F(TalkResourceTest, StartStopRemoting) {
   const PPB_Talk_Private_2_0* talk = thunk::GetPPB_Talk_Private_2_0_Thunk();
   LockingResourceReleaser res(talk->Create(pp_instance()));
   MockCompletionCallback callback;
   TalkEventCallback event_callback;
 
   // Start
   int32_t result = talk->StartRemoting(
       res.get(),
       &TalkEventCallback::Callback,
       &event_callback,
       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   SendReply(PpapiHostMsg_Talk_StartRemoting::ID,
             PpapiPluginMsg_Talk_StartRemotingReply(),
             PP_OK);
 
   ASSERT_TRUE(callback.called());
   ASSERT_EQ(PP_OK, callback.result());
 
   // Receive an event
   ASSERT_FALSE(event_callback.called());
   ResourceMessageReplyParams notify_params(res.get(), 0);
-  IPC::Message notify = PpapiPluginMsg_ResourceReply(
+  PluginMessageFilter::DispatchResourceReplyForTest(
       notify_params, PpapiPluginMsg_Talk_NotifyEvent(PP_TALKEVENT_ERROR));
-  ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(notify));
   ASSERT_TRUE(event_callback.called());
   ASSERT_EQ(PP_TALKEVENT_ERROR, event_callback.result());
 
   // Stop
   callback.Reset();
   result = talk->StopRemoting(
       res.get(),
       PP_MakeCompletionCallback(&MockCompletionCallback::Callback, &callback));
   ASSERT_EQ(PP_OK_COMPLETIONPENDING, result);
 
   SendReply(PpapiHostMsg_Talk_StopRemoting::ID,
            PpapiPluginMsg_Talk_StopRemotingReply(),
            PP_OK);
 
   ASSERT_TRUE(callback.called());
   ASSERT_EQ(PP_OK, callback.result());
 
   // Events should be discarded at this point
   event_callback.Reset();
-  ASSERT_TRUE(plugin_dispatcher()->OnMessageReceived(notify));
+  PluginMessageFilter::DispatchResourceReplyForTest(
+      notify_params, PpapiPluginMsg_Talk_NotifyEvent(PP_TALKEVENT_ERROR));
   ASSERT_FALSE(event_callback.called());
 }
 
 }  // namespace proxy
 }  // namespace ppapi