Change most uses of Pickle to base::Pickle

content/browser/loader/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 <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 51 matching lines @@
 namespace {
 
 // Returns the resource response header structure for this request.
 void GetResponseHead(const std::vector<IPC::Message>& messages,
                      ResourceResponseHead* response_head) {
   ASSERT_GE(messages.size(), 2U);
 
   // The first messages should be received response.
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
-  PickleIterator iter(messages[0]);
+  base::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));
 }
 
 void GenerateIPCMessage(
     scoped_refptr<ResourceMessageFilter> filter,
     scoped_ptr<IPC::Message> message) {
   ResourceDispatcherHostImpl::Get()->OnMessageReceived(
       *message, filter.get());
 }
 
 // On Windows, ResourceMsg_SetDataBuffer supplies a HANDLE which is not
 // automatically released.
 //
 // See ResourceDispatcher::ReleaseResourcesInDataMessage.
 //
 // TODO(davidben): It would be nice if the behavior for base::SharedMemoryHandle
 // were more like it is in POSIX where the received fds are tracked in a
 // ref-counted core that closes them if not extracted.
 void ReleaseHandlesInMessage(const IPC::Message& message) {
   if (message.type() == ResourceMsg_SetDataBuffer::ID) {
-    PickleIterator iter(message);
+    base::PickleIterator iter(message);
     int request_id;
     CHECK(iter.ReadInt(&request_id));
     base::SharedMemoryHandle shm_handle;
     if (IPC::ParamTraits<base::SharedMemoryHandle>::Read(&message,
                                                          &iter,
                                                          &shm_handle)) {
       if (base::SharedMemory::IsHandleValid(shm_handle))
         base::SharedMemory::CloseHandle(shm_handle);
     }
   }
 }
 
 }  // namespace
 
 static int RequestIDForMessage(const IPC::Message& msg) {
   int request_id = -1;
   switch (msg.type()) {
     case ResourceMsg_UploadProgress::ID:
     case ResourceMsg_ReceivedResponse::ID:
     case ResourceMsg_ReceivedRedirect::ID:
     case ResourceMsg_SetDataBuffer::ID:
     case ResourceMsg_DataReceived::ID:
     case ResourceMsg_DataDownloaded::ID:
     case ResourceMsg_RequestComplete::ID: {
-      bool result = PickleIterator(msg).ReadInt(&request_id);
+      bool result = base::PickleIterator(msg).ReadInt(&request_id);
       DCHECK(result);
       break;
     }
   }
   return request_id;
 }
 
 static ResourceHostMsg_Request CreateResourceRequest(const char* method,
                                                      ResourceType type,
                                                      const GURL& url) {
@@ skipping 779 matching lines @@
   // Intercepts requests for the given protocol.
   void HandleScheme(const std::string& scheme) {
     job_factory_->HandleScheme(scheme);
     EnsureSchemeIsAllowed(scheme);
   }
 
   void GenerateDataReceivedACK(const IPC::Message& msg) {
     EXPECT_EQ(ResourceMsg_DataReceived::ID, msg.type());
 
     int request_id = -1;
-    bool result = PickleIterator(msg).ReadInt(&request_id);
+    bool result = base::PickleIterator(msg).ReadInt(&request_id);
     DCHECK(result);
     scoped_ptr<IPC::Message> ack(
         new ResourceHostMsg_DataReceived_ACK(request_id));
 
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&GenerateIPCMessage, filter_, base::Passed(&ack)));
   }
 
   // Setting filters for testing renderer messages.
@@ skipping 69 matching lines @@
 }
 
 void CheckRequestCompleteErrorCode(const IPC::Message& message,
                                    int expected_error_code) {
   // Verify the expected error code was received.
   int request_id;
   int error_code;
 
   ASSERT_EQ(ResourceMsg_RequestComplete::ID, message.type());
 
-  PickleIterator iter(message);
+  base::PickleIterator iter(message);
   ASSERT_TRUE(IPC::ReadParam(&message, &iter, &request_id));
   ASSERT_TRUE(IPC::ReadParam(&message, &iter, &error_code));
   ASSERT_EQ(expected_error_code, error_code);
 }
 
 testing::AssertionResult ExtractDataOffsetAndLength(const IPC::Message& message,
                                                     int* data_offset,
                                                     int* data_length) {
-  PickleIterator iter(message);
+  base::PickleIterator iter(message);
   int request_id;
   if (!IPC::ReadParam(&message, &iter, &request_id))
     return testing::AssertionFailure() << "Could not read request_id";
   if (!IPC::ReadParam(&message, &iter, data_offset))
     return testing::AssertionFailure() << "Could not read data_offset";
   if (!IPC::ReadParam(&message, &iter, data_length))
     return testing::AssertionFailure() << "Could not read data_length";
   return testing::AssertionSuccess();
 }
 
@@ skipping 10 matching lines @@
   // This function verifies that we received 4 messages and that they are
   // appropriate. It allows for an error code other than net::OK if the request
   // should successfully receive data and then abort, e.g., on cancel.
   ASSERT_EQ(4U, messages.size());
 
   // The first messages should be received response
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
 
   ASSERT_EQ(ResourceMsg_SetDataBuffer::ID, messages[1].type());
 
-  PickleIterator iter(messages[1]);
+  base::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));
   int shm_size;
   ASSERT_TRUE(IPC::ReadParam(&messages[1], &iter, &shm_size));
 
   // 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[2].type());
@@ skipping 1945 matching lines @@
 
   // ReceivedResponse
   ResourceResponseHead response_head;
   GetResponseHead(messages, &response_head);
   ASSERT_FALSE(response_head.download_file_path.empty());
 
   // DataDownloaded
   size_t total_len = 0;
   for (size_t i = 1; i < messages.size() - 1; i++) {
     ASSERT_EQ(ResourceMsg_DataDownloaded::ID, messages[i].type());
-    PickleIterator iter(messages[i]);
+    base::PickleIterator iter(messages[i]);
     int request_id, data_len;
     ASSERT_TRUE(IPC::ReadParam(&messages[i], &iter, &request_id));
     ASSERT_TRUE(IPC::ReadParam(&messages[i], &iter, &data_len));
     total_len += data_len;
   }
   EXPECT_EQ(net::URLRequestTestJob::test_data_1().size(), total_len);
 
   // RequestComplete
   CheckRequestCompleteErrorCode(messages.back(), net::OK);
 
@@ skipping 215 matching lines @@
   return nullptr;
 }
 
 net::URLRequestJob* TestURLRequestJobFactory::MaybeInterceptResponse(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   return nullptr;
 }
 
 }  // namespace content