Pepper: Change ResourceMessageTestSink API for getting multiple messages.

ppapi/proxy/resource_message_test_sink.cc

 // 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.
 
 #include "ppapi/proxy/resource_message_test_sink.h"
 
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/resource_message_params.h"
 #include "ppapi/proxy/serialized_handle.h"
 
 namespace ppapi {
 namespace proxy {
 
 namespace {
 
 // Backend for GetFirstResource[Call|Reply]Matching.
 template<class WrapperMessage, class Params>
-int GetNextResourceMessageMatching(const ResourceMessageTestSink& sink,
-                                   uint32 id,
-                                   int start_index,
-                                   Params* params,
-                                   IPC::Message* nested_msg) {
-  if (start_index < 0)
-    return -1;
-  int message_count = static_cast<int>(sink.message_count());
-  for (int i = start_index; i < message_count; i++) {
+bool GetFirstResourceMessageMatching(const ResourceMessageTestSink& sink,
+                                     uint32 id,
+                                     Params* params,
+                                     IPC::Message* nested_msg) {
+  for (size_t i = 0; i < sink.message_count(); i++) {
     const IPC::Message* msg = sink.GetMessageAt(i);
     if (msg->type() == WrapperMessage::ID) {
       Params cur_params;
       IPC::Message cur_msg;
       WrapperMessage::Read(msg, &cur_params, &cur_msg);
       if (cur_msg.type() == id) {
         *params = cur_params;
         *nested_msg = cur_msg;
-        return i;
+        return true;
       }
     }
   }
-  return -1;
+  return false;
+}
+
+// Backend for GetAllResource[Calls|Replies]Matching.
+template<class WrapperMessage, class Params>
+std::vector<std::pair<Params, IPC::Message> >
+GetAllResourceMessagesMatching(const ResourceMessageTestSink& sink,
+                               uint32 id) {
+  std::vector<std::pair<Params, IPC::Message> > result;
+  for (size_t i = 0; i < sink.message_count(); i++) {
+    const IPC::Message* msg = sink.GetMessageAt(i);
+    if (msg->type() == WrapperMessage::ID) {
+      Params cur_params;
+      IPC::Message cur_msg;
+      WrapperMessage::Read(msg, &cur_params, &cur_msg);
+      if (cur_msg.type() == id) {
+        result.push_back(std::make_pair(cur_params, cur_msg));
+      }
+    }
+  }
+  return result;
 }
 
 }  // namespace
 
-ResourceMessageTestSink::ResourceMessageTestSink()
-    : next_resource_call_(0),
-      next_resource_reply_(0) {
+ResourceMessageTestSink::ResourceMessageTestSink() {
 }
 
 ResourceMessageTestSink::~ResourceMessageTestSink() {
 }
 
 bool ResourceMessageTestSink::Send(IPC::Message* msg) {
   int message_id = 0;
   scoped_ptr<IPC::MessageReplyDeserializer> reply_deserializer;
   if (msg->is_sync()) {
     reply_deserializer.reset(
@@ skipping 13 matching lines @@
 
 void ResourceMessageTestSink::SetSyncReplyMessage(IPC::Message* reply_msg) {
   DCHECK(!sync_reply_msg_.get());
   sync_reply_msg_.reset(reply_msg);
 }
 
 bool ResourceMessageTestSink::GetFirstResourceCallMatching(
     uint32 id,
     ResourceMessageCallParams* params,
     IPC::Message* nested_msg) const {
-  int index = GetNextResourceMessageMatching<PpapiHostMsg_ResourceCall,
-                                             ResourceMessageCallParams>(
-      *this, id, 0 /* start_index */, params, nested_msg);
-  return index >= 0;
+  return GetFirstResourceMessageMatching<PpapiHostMsg_ResourceCall,
+                                         ResourceMessageCallParams>(
+      *this, id, params, nested_msg);
 }
 
 bool ResourceMessageTestSink::GetFirstResourceReplyMatching(
     uint32 id,
     ResourceMessageReplyParams* params,
     IPC::Message* nested_msg) {
-  int index = GetNextResourceMessageMatching<PpapiPluginMsg_ResourceReply,
-                                             ResourceMessageReplyParams>(
-      *this, id, 0 /* start_index */, params, nested_msg);
-  return index >= 0;
+  return GetFirstResourceMessageMatching<PpapiPluginMsg_ResourceReply,
+                                         ResourceMessageReplyParams>(
+      *this, id, params, nested_msg);
 }
 
-bool ResourceMessageTestSink::GetNextResourceCallMatching(
-    uint32 id,
-    ResourceMessageCallParams* params,
-    IPC::Message* nested_msg) {
-  int index = GetNextResourceMessageMatching<PpapiHostMsg_ResourceCall,
-                                             ResourceMessageCallParams>(
-      *this, id, next_resource_call_, params, nested_msg);
-  if (index >= 0) {
-    next_resource_call_ = index + 1;
-    return true;
-  }
-  return false;
+ResourceMessageTestSink::ResourceCallVector
+ResourceMessageTestSink::GetAllResourceCallsMatching(uint32 id) {
+  return GetAllResourceMessagesMatching<PpapiHostMsg_ResourceCall,
+                                        ResourceMessageCallParams>(*this, id);
 }
 
-bool ResourceMessageTestSink::GetNextResourceReplyMatching(
-    uint32 id,
-    ResourceMessageReplyParams* params,
-    IPC::Message* nested_msg) {
-  int index = GetNextResourceMessageMatching<PpapiPluginMsg_ResourceReply,
-                                             ResourceMessageReplyParams>(
-      *this, id, next_resource_reply_, params, nested_msg);
-  if (index >= 0) {
-    next_resource_reply_ = index + 1;
-    return true;
-  }
-  return false;
+ResourceMessageTestSink::ResourceReplyVector
+ResourceMessageTestSink::GetAllResourceRepliesMatching(uint32 id) {
+  return GetAllResourceMessagesMatching<PpapiPluginMsg_ResourceReply,
+                                        ResourceMessageReplyParams>(*this, id);
 }
 
 ResourceSyncCallHandler::ResourceSyncCallHandler(
     ResourceMessageTestSink* test_sink,
     uint32 incoming_type,
     int32_t result,
     const IPC::Message& reply_msg)
     : test_sink_(test_sink),
       incoming_type_(incoming_type),
       result_(result),
@@ skipping 25 matching lines @@
       wrapper_reply_msg, reply_params, reply_msg_);
   test_sink_->SetSyncReplyMessage(wrapper_reply_msg);
 
   // Stash a copy of the message for inspection later.
   last_handled_msg_ = call_msg;
   return true;
 }
 
 }  // namespace proxy
 }  // namespace ppapi