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 #ifndef PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_ 6 #define PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_ 7 8 #include "ipc/ipc_listener.h" 9 #include "ipc/ipc_test_sink.h" 10 #include "ppapi/c/pp_stdint.h" 11 12 namespace ppapi { 13 namespace proxy { 14 15 class ResourceMessageCallParams; 16 class ResourceMessageReplyParams; 17 class SerializedHandle; 18 19 // Extends IPC::TestSink to add extra capabilities for searching for and 20 // decoding resource messages. 21 class ResourceMessageTestSink : public IPC::TestSink { 22 public: 23 ResourceMessageTestSink(); 24 virtual ~ResourceMessageTestSink(); 25 26 // IPC::TestSink. 27 // Overridden to handle sync messages. 28 virtual bool Send(IPC::Message* msg) OVERRIDE; 29 30 // Sets the reply message that will be returned to the next sync message sent. 31 // This test sink owns any reply messages passed into this method. 32 void SetSyncReplyMessage(IPC::Message* reply_msg); 33 34 // Searches the queue for the first resource call message with a nested 35 // message matching the given ID. On success, returns true and populates the 36 // given params and nested message. 37 bool GetFirstResourceCallMatching( 38 uint32 id, 39 ResourceMessageCallParams* params, 40 IPC::Message* nested_msg) const; 41 42 // Like GetFirstResourceCallMatching except for replies. 43 bool GetFirstResourceReplyMatching( 44 uint32 id, 45 ResourceMessageReplyParams* params, 46 IPC::Message* nested_msg); 47 48 // Searches the queue for all resource call messages with a nested message 49 // matching the given ID. 50 typedef std::pair<ResourceMessageCallParams, IPC::Message> ResourceCall; 51 typedef std::vector<ResourceCall> ResourceCallVector; 52 ResourceCallVector GetAllResourceCallsMatching(uint32 id); 53 54 // Like GetAllResourceCallsMatching except for replies. 55 typedef std::pair<ResourceMessageReplyParams, IPC::Message> ResourceReply; 56 typedef std::vector<ResourceReply> ResourceReplyVector; 57 ResourceReplyVector GetAllResourceRepliesMatching(uint32 id); 58 59 private: 60 scoped_ptr<IPC::Message> sync_reply_msg_; 61 }; 62 63 // This is a message handler which generates reply messages for synchronous 64 // resource calls. This allows unit testing of the plugin side of resources 65 // which send sync messages. If you want to reply to a sync message type named 66 // |PpapiHostMsg_X_Y| with |PpapiPluginMsg_X_YReply| then usage would be as 67 // follows (from within |PluginProxyTest|s): 68 // 69 // PpapiHostMsg_X_YReply my_reply; 70 // ResourceSyncCallHandler handler(&sink(), 71 // PpapiHostMsg_X_Y::ID, 72 // PP_OK, 73 // my_reply); 74 // sink().AddFilter(&handler); 75 // // Do stuff to send a sync message ... 76 // // You can check handler.last_handled_msg() to ensure the correct message was 77 // // handled. 78 // sink().RemoveFilter(&handler); 79 class ResourceSyncCallHandler : public IPC::Listener { 80 public: 81 ResourceSyncCallHandler(ResourceMessageTestSink* test_sink, 82 uint32 incoming_type, 83 int32_t result, 84 const IPC::Message& reply_msg); 85 virtual ~ResourceSyncCallHandler(); 86 87 // IPC::Listener. 88 virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE; 89 last_handled_msg()90 IPC::Message last_handled_msg() { return last_handled_msg_; } 91 92 // Sets a handle to be appended to the ReplyParams. The pointer is owned by 93 // the caller. set_serialized_handle(const SerializedHandle * serialized_handle)94 void set_serialized_handle(const SerializedHandle* serialized_handle) { 95 serialized_handle_ = serialized_handle; 96 } 97 98 private: 99 ResourceMessageTestSink* test_sink_; 100 uint32 incoming_type_; 101 int32_t result_; 102 const SerializedHandle* serialized_handle_; // Non-owning pointer. 103 IPC::Message reply_msg_; 104 IPC::Message last_handled_msg_; 105 }; 106 107 } // namespace proxy 108 } // namespace ppapi 109 110 #endif // PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_ 111