ppapi/proxy/resource_message_test_sink.h

   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_