ppapi/proxy/resource_message_test_sink.h

// Copyright (c) 2012 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.

#ifndef PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_
#define PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_

#include "ipc/ipc_listener.h"
#include "ipc/ipc_test_sink.h"
#include "ppapi/c/pp_stdint.h"

namespace ppapi {
namespace proxy {

class ResourceMessageCallParams;
class ResourceMessageReplyParams;
class SerializedHandle;

// Extends IPC::TestSink to add extra capabilities for searching for and
// decoding resource messages.
class ResourceMessageTestSink : public IPC::TestSink {
 public:
  ResourceMessageTestSink();
  ~ResourceMessageTestSink() override;

  // IPC::TestSink.
  // Overridden to handle sync messages.
  bool Send(IPC::Message* msg) override;

  // Sets the reply message that will be returned to the next sync message sent.
  // This test sink owns any reply messages passed into this method.
  void SetSyncReplyMessage(IPC::Message* reply_msg);

  // Searches the queue for the first resource call message with a nested
  // message matching the given ID. On success, returns true and populates the
  // given params and nested message.
  bool GetFirstResourceCallMatching(uint32_t id,
                                    ResourceMessageCallParams* params,
                                    IPC::Message* nested_msg) const;

  // Like GetFirstResourceCallMatching except for replies.
  bool GetFirstResourceReplyMatching(uint32_t id,
                                     ResourceMessageReplyParams* params,
                                     IPC::Message* nested_msg);

  // Searches the queue for all resource call messages with a nested message
  // matching the given ID.
  typedef std::pair<ResourceMessageCallParams, IPC::Message> ResourceCall;
  typedef std::vector<ResourceCall> ResourceCallVector;
  ResourceCallVector GetAllResourceCallsMatching(uint32_t id);

  // Like GetAllResourceCallsMatching except for replies.
  typedef std::pair<ResourceMessageReplyParams, IPC::Message> ResourceReply;
  typedef std::vector<ResourceReply> ResourceReplyVector;
  ResourceReplyVector GetAllResourceRepliesMatching(uint32_t id);

 private:
  std::unique_ptr<IPC::Message> sync_reply_msg_;
};

// This is a message handler which generates reply messages for synchronous
// resource calls. This allows unit testing of the plugin side of resources
// which send sync messages. If you want to reply to a sync message type named
// |PpapiHostMsg_X_Y| with |PpapiPluginMsg_X_YReply| then usage would be as
// follows (from within |PluginProxyTest|s):
//
// PpapiHostMsg_X_YReply my_reply;
// ResourceSyncCallHandler handler(&sink(),
//                                 PpapiHostMsg_X_Y::ID,
//                                 PP_OK,
//                                 my_reply);
// sink().AddFilter(&handler);
// // Do stuff to send a sync message ...
// // You can check handler.last_handled_msg() to ensure the correct message was
// // handled.
// sink().RemoveFilter(&handler);
class ResourceSyncCallHandler : public IPC::Listener {
 public:
  ResourceSyncCallHandler(ResourceMessageTestSink* test_sink,
                          uint32_t incoming_type,
                          int32_t result,
                          const IPC::Message& reply_msg);
  ~ResourceSyncCallHandler() override;

  // IPC::Listener.
  bool OnMessageReceived(const IPC::Message& message) override;

  IPC::Message last_handled_msg() { return last_handled_msg_; }

  // Sets a handle to be appended to the ReplyParams.
  void set_serialized_handle(
      std::unique_ptr<SerializedHandle> serialized_handle);

 private:
  ResourceMessageTestSink* test_sink_;
  uint32_t incoming_type_;
  int32_t result_;
  std::unique_ptr<SerializedHandle> serialized_handle_;
  IPC::Message reply_msg_;
  IPC::Message last_handled_msg_;
};

}  // namespace proxy
}  // namespace ppapi

#endif  // PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_