Home | History | Annotate | Download | only in proxy 
      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 
     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.
     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