Refactor Pickle Read methods to use higher performance PickleIterator.

content/browser/renderer_host/resource_dispatcher_host_unittest.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 "content/browser/renderer_host/resource_dispatcher_host.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_path.h"
@@ skipping 37 matching lines @@
 namespace {
 
 // Returns the resource response header structure for this request.
 void GetResponseHead(const std::vector<IPC::Message>& messages,
                      content::ResourceResponseHead* response_head) {
   ASSERT_GE(messages.size(), 2U);
 
   // The first messages should be received response.
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
-  void* iter = NULL;
+  PickleIterator iter(messages[0]);
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&messages[0], &iter, response_head));
 }
 
 }  // namespace
 
 static int RequestIDForMessage(const IPC::Message& msg) {
   int request_id = -1;
   switch (msg.type()) {
@@ skipping 463 matching lines @@
   // are appropriate.
   ASSERT_EQ(3U, messages.size());
 
   // The first messages should be received response
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
   // followed by the data, currently we only do the data in one chunk, but
   // should probably test multiple chunks later
   ASSERT_EQ(ResourceMsg_DataReceived::ID, messages[1].type());
 
-  void* iter = NULL;
+  PickleIterator iter(messages[1]);
   int request_id;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &request_id));
   base::SharedMemoryHandle shm_handle;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_handle));
   uint32 data_len;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &data_len));
 
   ASSERT_EQ(reference_data.size(), data_len);
   base::SharedMemory shared_mem(shm_handle, true);  // read only
   shared_mem.Map(data_len);
@@ skipping 58 matching lines @@
   CheckSuccessfulRequest(msgs[2], net::URLRequestTestJob::test_data_3());
 
   // Check that request 2 got canceled.
   ASSERT_EQ(2U, msgs[1].size());
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[1][0].type());
   ASSERT_EQ(ResourceMsg_RequestComplete::ID, msgs[1][1].type());
 
   int request_id;
   net::URLRequestStatus status;
 
-  void* iter = NULL;
+  PickleIterator iter(msgs[1][1]);
   ASSERT_TRUE(IPC::ReadParam(&msgs[1][1], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&msgs[1][1], &iter, &status));
 
   EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
 }
 
 TEST_F(ResourceDispatcherHostTest, CancelWhileStartIsDeferred) {
   EXPECT_EQ(0, host_.GetOutstandingRequestsMemoryCost(0));
 
   bool was_deleted = false;
@@ skipping 56 matching lines @@
   ASSERT_EQ(1U, msgs.size());
 
   // Check that request 1 got canceled.
   ASSERT_EQ(2U, msgs[0].size());
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[0][0].type());
   ASSERT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][1].type());
 
   int request_id;
   net::URLRequestStatus status;
 
-  void* iter = NULL;
+  PickleIterator iter(msgs[0][1]);
   ASSERT_TRUE(IPC::ReadParam(&msgs[0][1], &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&msgs[0][1], &iter, &status));
 
   EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
 }
 
 // The host delegate acts as a second one so we can have some requests
 // pending and some canceled.
 class TestFilter : public ForwardingFilter {
  public:
@@ skipping 353 matching lines @@
     // Should have sent a single RequestComplete message.
     int index = kMaxRequests + i;
     EXPECT_EQ(1U, msgs[index].size());
     EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[index][0].type());
 
     // The RequestComplete message should have had status
     // (CANCELLED, ERR_INSUFFICIENT_RESOURCES).
     int request_id;
     net::URLRequestStatus status;
 
-    void* iter = NULL;
+    PickleIterator iter(msgs[index][0]);
     EXPECT_TRUE(IPC::ReadParam(&msgs[index][0], &iter, &request_id));
     EXPECT_TRUE(IPC::ReadParam(&msgs[index][0], &iter, &status));
 
     EXPECT_EQ(index + 1, request_id);
     EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
     EXPECT_EQ(net::ERR_INSUFFICIENT_RESOURCES, status.error());
   }
 
   // The final 2 requests should have succeeded.
   CheckSuccessfulRequest(msgs[kMaxRequests + 2],
@@ skipping 143 matching lines @@
 
   // We should have gotten one RequestComplete message.
   ASSERT_EQ(1U, msgs[0].size());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
   // The RequestComplete message should have had status
   // (CANCELED, ERR_FILE_NOT_FOUND).
   int request_id;
   net::URLRequestStatus status;
 
-  void* iter = NULL;
+  PickleIterator iter(msgs[0][0]);
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &status));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(net::URLRequestStatus::CANCELED, status.status());
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, status.error());
 }
 
 // Test for http://crbug.com/76202 .  We don't want to destroy a
 // download request prematurely when processing a cancellation from
@@ skipping 133 matching lines @@
 
   // We should have gotten one RequestComplete message.
   ASSERT_EQ(1U, msgs[0].size());
   EXPECT_EQ(ResourceMsg_RequestComplete::ID, msgs[0][0].type());
 
   // The RequestComplete message should have had status
   // (FAILED, ERR_UNKNOWN_URL_SCHEME).
   int request_id;
   net::URLRequestStatus status;
 
-  void* iter = NULL;
+  PickleIterator iter(msgs[0][0]);
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &request_id));
   EXPECT_TRUE(IPC::ReadParam(&msgs[0][0], &iter, &status));
 
   EXPECT_EQ(1, request_id);
   EXPECT_EQ(net::URLRequestStatus::FAILED, status.status());
   EXPECT_EQ(net::ERR_UNKNOWN_URL_SCHEME, status.error());
 }