Pepper: Change ResourceMessageTestSink API for getting multiple messages.

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"
@@ skipping 15 matching lines @@
   // IPC::TestSink.
   // Overridden to handle sync messages.
   virtual 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
-  // givem params and nested message.
+  // given params and nested message.
   bool GetFirstResourceCallMatching(
       uint32 id,
       ResourceMessageCallParams* params,
       IPC::Message* nested_msg) const;
 
   // Like GetFirstResourceCallMatching except for replies.
   bool GetFirstResourceReplyMatching(

[raymes, 2014/01/08 02:21:22]

Can we get rid of these two methods now? Can't we just use
GetAllResourceCallsMatching(..)[0]?

[bbudge, 2014/01/08 03:05:17]

It won't be so simple for callers, since the vector could be empty. I think it's
a nice API for the general case where we expect only one message.

I can implement the GetFirst* methods in terms of the GetAll* ones though, to
reduce the amount of code.

       uint32 id,
       ResourceMessageReplyParams* params,
       IPC::Message* nested_msg);
 
-  // Searches the queue for the next resource call message with a nested
-  // message matching the given ID. On success, returns true and populates the
-  // givem params and nested message. The first time this is called, it is
-  // equivalent to GetFirstResourceCallMatching.
-  bool GetNextResourceCallMatching(
-      uint32 id,
-      ResourceMessageCallParams* 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 id);
 
-  // Like GetNextResourceCallMatching except for replies.
-  bool GetNextResourceReplyMatching(
-      uint32 id,
-      ResourceMessageReplyParams* params,
-      IPC::Message* nested_msg);
+  // Like GetAllResourceCallsMatching except for replies.
+  typedef std::pair<ResourceMessageReplyParams, IPC::Message> ResourceReply;
+  typedef std::vector<ResourceReply> ResourceReplyVector;
+  ResourceReplyVector GetAllResourceRepliesMatching(uint32 id);
 
  private:
   scoped_ptr<IPC::Message> sync_reply_msg_;
-  int next_resource_call_;
-  int next_resource_reply_;
 };
 
 // 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(),
@@ skipping 30 matching lines @@
   int32_t result_;
   const SerializedHandle* serialized_handle_;  // Non-owning pointer.
   IPC::Message reply_msg_;
   IPC::Message last_handled_msg_;
 };
 
 }  // namespace proxy
 }  // namespace ppapi
 
 #endif  // PPAPI_PROXY_RESOURCE_MESSAGE_TEST_SINK_H_