Change most uses of Pickle to base::Pickle

There should be no behavior change.

TBR=jschuh (IPC messages)

Review URL: https://codereview.chromium.org/1154283003

Cr-Commit-Position: refs/heads/master@{#332552}

21 files changed, 125 insertions, 118 deletions

diff --git a/components/autofill/core/common/form_data.cc b/components/autofill/core/common/form_data.cc
index 8bfb352..3691b6a 100644
--- a/components/autofill/core/common/form_data.cc
+++ b/components/autofill/core/common/form_data.cc
@@ -16,7 +16,7 @@ namespace {
 
 const int kPickleVersion = 3;
 
-bool ReadGURL(PickleIterator* iter, GURL* url) {
+bool ReadGURL(base::PickleIterator* iter, GURL* url) {
   std::string spec;
   if (!iter->ReadString(&spec))
     return false;
@@ -26,14 +26,14 @@ bool ReadGURL(PickleIterator* iter, GURL* url) {
 }
 
 void SerializeFormFieldDataVector(const std::vector<FormFieldData>& fields,
-                                  Pickle* pickle) {
+                                  base::Pickle* pickle) {
   pickle->WriteInt(static_cast<int>(fields.size()));
   for (size_t i = 0; i < fields.size(); ++i) {
     SerializeFormFieldData(fields[i], pickle);
   }
 }
 
-bool DeserializeFormFieldDataVector(PickleIterator* iter,
+bool DeserializeFormFieldDataVector(base::PickleIterator* iter,
                                     std::vector<FormFieldData>* fields) {
   int size;
   if (!iter->ReadInt(&size))
@@ -115,7 +115,7 @@ std::ostream& operator<<(std::ostream& os, const FormData& form) {
   return os;
 }
 
-void SerializeFormData(const FormData& form_data, Pickle* pickle) {
+void SerializeFormData(const FormData& form_data, base::Pickle* pickle) {
   pickle->WriteInt(kPickleVersion);
   pickle->WriteString16(form_data.name);
   pickle->WriteString(form_data.origin.spec());
@@ -127,14 +127,14 @@ void SerializeFormData(const FormData& form_data, Pickle* pickle) {
 
 void SerializeFormDataToBase64String(const FormData& form_data,
                                      std::string* output) {
-  Pickle pickle;
+  base::Pickle pickle;
   SerializeFormData(form_data, &pickle);
   Base64Encode(
       base::StringPiece(static_cast<const char*>(pickle.data()), pickle.size()),
       output);
 }
 
-bool DeserializeFormData(PickleIterator* iter, FormData* form_data) {
+bool DeserializeFormData(base::PickleIterator* iter, FormData* form_data) {
   int version;
   FormData temp_form_data;
   if (!iter->ReadInt(&version)) {
@@ -187,8 +187,8 @@ bool DeserializeFormDataFromBase64String(const base::StringPiece& input,
     return false;
   std::string pickle_data;
   Base64Decode(input, &pickle_data);
-  Pickle pickle(pickle_data.data(), static_cast<int>(pickle_data.size()));
-  PickleIterator iter(pickle);
+  base::Pickle pickle(pickle_data.data(), static_cast<int>(pickle_data.size()));
+  base::PickleIterator iter(pickle);
   return DeserializeFormData(&iter, form_data);
 }
 
diff --git a/components/autofill/core/common/form_data_unittest.cc b/components/autofill/core/common/form_data_unittest.cc
index 01e99c5..e2faaf1 100644
--- a/components/autofill/core/common/form_data_unittest.cc
+++ b/components/autofill/core/common/form_data_unittest.cc
@@ -16,7 +16,8 @@ namespace {
 // This function serializes the form data into the pickle in version one format.
 // It should always be possible to deserialize it using DeserializeFormData(),
 // even when version changes. See kPickleVersion in form_data.cc.
-void SerializeInVersion1Format(const FormData& form_data, Pickle* pickle) {
+void SerializeInVersion1Format(const FormData& form_data,
+                               base::Pickle* pickle) {
   DCHECK_EQ(true, form_data.is_form_tag);
   pickle->WriteInt(1);
   pickle->WriteString16(form_data.name);
@@ -31,7 +32,8 @@ void SerializeInVersion1Format(const FormData& form_data, Pickle* pickle) {
   }
 }
 
-void SerializeInVersion2Format(const FormData& form_data, Pickle* pickle) {
+void SerializeInVersion2Format(const FormData& form_data,
+                               base::Pickle* pickle) {
   DCHECK_EQ(true, form_data.is_form_tag);
   pickle->WriteInt(2);
   pickle->WriteString16(form_data.name);
@@ -46,7 +48,7 @@ void SerializeInVersion2Format(const FormData& form_data, Pickle* pickle) {
 
 // This function serializes the form data into the pickle in incorrect format
 // (no version number).
-void SerializeIncorrectFormat(const FormData& form_data, Pickle* pickle) {
+void SerializeIncorrectFormat(const FormData& form_data, base::Pickle* pickle) {
   pickle->WriteString16(form_data.name);
   pickle->WriteString(form_data.origin.spec());
   pickle->WriteString(form_data.action.spec());
@@ -97,10 +99,10 @@ TEST(FormDataTest, SerializeAndDeserialize) {
   FillInDummyFormData(&data);
   data.is_form_tag = false;
 
-  Pickle pickle;
+  base::Pickle pickle;
   SerializeFormData(data, &pickle);
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormData actual;
   EXPECT_TRUE(DeserializeFormData(&iter, &actual));
 
@@ -111,10 +113,10 @@ TEST(FormDataTest, Serialize_v1_Deserialize_vCurrent) {
   FormData data;
   FillInDummyFormData(&data);
 
-  Pickle pickle;
+  base::Pickle pickle;
   SerializeInVersion1Format(data, &pickle);
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormData actual;
   EXPECT_TRUE(DeserializeFormData(&iter, &actual));
 
@@ -125,10 +127,10 @@ TEST(FormDataTest, Serialize_v2_Deserialize_vCurrent) {
   FormData data;
   FillInDummyFormData(&data);
 
-  Pickle pickle;
+  base::Pickle pickle;
   SerializeInVersion2Format(data, &pickle);
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormData actual;
   EXPECT_TRUE(DeserializeFormData(&iter, &actual));
 
@@ -139,10 +141,10 @@ TEST(FormDataTest, SerializeIncorrectFormatAndDeserialize) {
   FormData data;
   FillInDummyFormData(&data);
 
-  Pickle pickle;
+  base::Pickle pickle;
   SerializeIncorrectFormat(data, &pickle);
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormData actual;
   EXPECT_FALSE(DeserializeFormData(&iter, &actual));
 
diff --git a/components/autofill/core/common/form_field_data.cc b/components/autofill/core/common/form_field_data.cc
index e82472e..1ae3446 100644
--- a/components/autofill/core/common/form_field_data.cc
+++ b/components/autofill/core/common/form_field_data.cc
@@ -17,14 +17,14 @@ namespace {
 const int kPickleVersion = 2;
 
 void AddVectorToPickle(std::vector<base::string16> strings,
-                       Pickle* pickle) {
+                       base::Pickle* pickle) {
   pickle->WriteInt(static_cast<int>(strings.size()));
   for (size_t i = 0; i < strings.size(); ++i) {
     pickle->WriteString16(strings[i]);
   }
 }
 
-bool ReadStringVector(PickleIterator* iter,
+bool ReadStringVector(base::PickleIterator* iter,
                       std::vector<base::string16>* strings) {
   int size;
   if (!iter->ReadInt(&size))
@@ -41,7 +41,7 @@ bool ReadStringVector(PickleIterator* iter,
 }
 
 template <typename T>
-bool ReadAsInt(PickleIterator* iter, T* target_value) {
+bool ReadAsInt(base::PickleIterator* iter, T* target_value) {
   int pickle_data;
   if (!iter->ReadInt(&pickle_data))
     return false;
@@ -50,7 +50,7 @@ bool ReadAsInt(PickleIterator* iter, T* target_value) {
   return true;
 }
 
-bool DeserializeCommonSection1(PickleIterator* iter,
+bool DeserializeCommonSection1(base::PickleIterator* iter,
                                FormFieldData* field_data) {
   return iter->ReadString16(&field_data->label) &&
          iter->ReadString16(&field_data->name) &&
@@ -65,14 +65,14 @@ bool DeserializeCommonSection1(PickleIterator* iter,
          iter->ReadBool(&field_data->should_autocomplete);
 }
 
-bool DeserializeCommonSection2(PickleIterator* iter,
+bool DeserializeCommonSection2(base::PickleIterator* iter,
                                FormFieldData* field_data) {
   return ReadAsInt(iter, &field_data->text_direction) &&
          ReadStringVector(iter, &field_data->option_values) &&
          ReadStringVector(iter, &field_data->option_contents);
 }
 
-bool DeserializeVersion2Specific(PickleIterator* iter,
+bool DeserializeVersion2Specific(base::PickleIterator* iter,
                                  FormFieldData* field_data) {
   return ReadAsInt(iter, &field_data->role);
 }
@@ -143,7 +143,7 @@ bool FormFieldData::operator<(const FormFieldData& field) const {
 }
 
 void SerializeFormFieldData(const FormFieldData& field_data,
-                            Pickle* pickle) {
+                            base::Pickle* pickle) {
   pickle->WriteInt(kPickleVersion);
   pickle->WriteString16(field_data.label);
   pickle->WriteString16(field_data.name);
@@ -162,7 +162,7 @@ void SerializeFormFieldData(const FormFieldData& field_data,
   AddVectorToPickle(field_data.option_contents, pickle);
 }
 
-bool DeserializeFormFieldData(PickleIterator* iter,
+bool DeserializeFormFieldData(base::PickleIterator* iter,
                               FormFieldData* field_data) {
   int version;
   FormFieldData temp_form_field_data;
diff --git a/components/autofill/core/common/form_field_data_unittest.cc b/components/autofill/core/common/form_field_data_unittest.cc
index 8d77d2c..dc17277 100644
--- a/components/autofill/core/common/form_field_data_unittest.cc
+++ b/components/autofill/core/common/form_field_data_unittest.cc
@@ -32,7 +32,7 @@ void FillCommonFields(FormFieldData* data) {
   data->option_contents.push_back(base::ASCIIToUTF16("Second"));
 }
 
-void WriteCommonSection1(const FormFieldData& data, Pickle* pickle) {
+void WriteCommonSection1(const FormFieldData& data, base::Pickle* pickle) {
   pickle->WriteString16(data.label);
   pickle->WriteString16(data.name);
   pickle->WriteString16(data.value);
@@ -46,7 +46,7 @@ void WriteCommonSection1(const FormFieldData& data, Pickle* pickle) {
   pickle->WriteBool(data.should_autocomplete);
 }
 
-void WriteCommonSection2(const FormFieldData& data, Pickle* pickle) {
+void WriteCommonSection2(const FormFieldData& data, base::Pickle* pickle) {
   pickle->WriteInt(data.text_direction);
   pickle->WriteInt(static_cast<int>(data.option_values.size()));
   for (auto s : data.option_values)
@@ -63,10 +63,10 @@ TEST(FormFieldDataTest, SerializeAndDeserialize) {
   FillCommonFields(&data);
   data.role = FormFieldData::ROLE_ATTRIBUTE_PRESENTATION;
 
-  Pickle pickle;
+  base::Pickle pickle;
   SerializeFormFieldData(data, &pickle);
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormFieldData actual;
   EXPECT_TRUE(DeserializeFormFieldData(&iter, &actual));
 
@@ -77,12 +77,12 @@ TEST(FormFieldDataTest, DeserializeVersion1) {
   FormFieldData data;
   FillCommonFields(&data);
 
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(1);
   WriteCommonSection1(data, &pickle);
   WriteCommonSection2(data, &pickle);
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormFieldData actual;
   EXPECT_TRUE(DeserializeFormFieldData(&iter, &actual));
 
@@ -92,12 +92,12 @@ TEST(FormFieldDataTest, DeserializeVersion1) {
 // Verify that if the data isn't valid, the FormFieldData isn't populated
 // during deserialization.
 TEST(FormFieldDataTest, DeserializeBadData) {
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(255);
   pickle.WriteString16(base::ASCIIToUTF16("random"));
   pickle.WriteString16(base::ASCIIToUTF16("data"));
 
-  PickleIterator iter(pickle);
+  base::PickleIterator iter(pickle);
   FormFieldData actual;
   EXPECT_FALSE(DeserializeFormFieldData(&iter, &actual));
 
diff --git a/components/bookmarks/browser/bookmark_node_data.cc b/components/bookmarks/browser/bookmark_node_data.cc
index a781516..36b1bdd 100644
--- a/components/bookmarks/browser/bookmark_node_data.cc
+++ b/components/bookmarks/browser/bookmark_node_data.cc
@@ -37,7 +37,7 @@ BookmarkNodeData::Element::Element(const BookmarkNode* node)
 BookmarkNodeData::Element::~Element() {
 }
 
-void BookmarkNodeData::Element::WriteToPickle(Pickle* pickle) const {
+void BookmarkNodeData::Element::WriteToPickle(base::Pickle* pickle) const {
   pickle->WriteBool(is_url);
   pickle->WriteString(url.spec());
   pickle->WriteString16(title);
@@ -57,7 +57,7 @@ void BookmarkNodeData::Element::WriteToPickle(Pickle* pickle) const {
   }
 }
 
-bool BookmarkNodeData::Element::ReadFromPickle(PickleIterator* iterator) {
+bool BookmarkNodeData::Element::ReadFromPickle(base::PickleIterator* iterator) {
   std::string url_spec;
   if (!iterator->ReadBool(&is_url) ||
       !iterator->ReadString(&url_spec) ||
@@ -194,7 +194,7 @@ void BookmarkNodeData::WriteToClipboard(ui::ClipboardType clipboard_type) {
     scw.WriteText(text);
   }
 
-  Pickle pickle;
+  base::Pickle pickle;
   WriteToPickle(base::FilePath(), &pickle);
   scw.WritePickledData(pickle,
                        ui::Clipboard::GetFormatType(kClipboardFormatString));
@@ -208,7 +208,7 @@ bool BookmarkNodeData::ReadFromClipboard(ui::ClipboardType type) {
                       &data);
 
   if (!data.empty()) {
-    Pickle pickle(data.data(), static_cast<int>(data.size()));
+    base::Pickle pickle(data.data(), static_cast<int>(data.size()));
     if (ReadFromPickle(&pickle))
       return true;
   }
@@ -232,7 +232,7 @@ bool BookmarkNodeData::ReadFromClipboard(ui::ClipboardType type) {
 #endif
 
 void BookmarkNodeData::WriteToPickle(const base::FilePath& profile_path,
-                                     Pickle* pickle) const {
+                                     base::Pickle* pickle) const {
   profile_path.WriteToPickle(pickle);
   pickle->WriteSizeT(size());
 
@@ -240,8 +240,8 @@ void BookmarkNodeData::WriteToPickle(const base::FilePath& profile_path,
     elements[i].WriteToPickle(pickle);
 }
 
-bool BookmarkNodeData::ReadFromPickle(Pickle* pickle) {
-  PickleIterator data_iterator(*pickle);
+bool BookmarkNodeData::ReadFromPickle(base::Pickle* pickle) {
+  base::PickleIterator data_iterator(*pickle);
   size_t element_count;
   if (profile_path_.ReadFromPickle(&data_iterator) &&
       data_iterator.ReadSizeT(&element_count)) {
diff --git a/components/bookmarks/browser/bookmark_node_data_views.cc b/components/bookmarks/browser/bookmark_node_data_views.cc
index 809113d..efd2733 100644
--- a/components/bookmarks/browser/bookmark_node_data_views.cc
+++ b/components/bookmarks/browser/bookmark_node_data_views.cc
@@ -37,7 +37,7 @@ void BookmarkNodeData::Write(const base::FilePath& profile_path,
     }
   }
 
-  Pickle data_pickle;
+  base::Pickle data_pickle;
   WriteToPickle(profile_path, &data_pickle);
 
   data->SetPickledData(GetBookmarkCustomFormat(), data_pickle);
@@ -49,7 +49,7 @@ bool BookmarkNodeData::Read(const ui::OSExchangeData& data) {
   profile_path_.clear();
 
   if (data.HasCustomFormat(GetBookmarkCustomFormat())) {
-    Pickle drag_data_pickle;
+    base::Pickle drag_data_pickle;
     if (data.GetPickledData(GetBookmarkCustomFormat(), &drag_data_pickle)) {
       if (!ReadFromPickle(&drag_data_pickle))
         return false;
diff --git a/components/nacl/browser/nacl_browser.cc b/components/nacl/browser/nacl_browser.cc
index 12e759c..3e69458 100644
--- a/components/nacl/browser/nacl_browser.cc
+++ b/components/nacl/browser/nacl_browser.cc
@@ -86,7 +86,7 @@ void ReadCache(const base::FilePath& filename, std::string* data) {
   }
 }
 
-void WriteCache(const base::FilePath& filename, const Pickle* pickle) {
+void WriteCache(const base::FilePath& filename, const base::Pickle* pickle) {
   base::WriteFile(filename, static_cast<const char*>(pickle->data()),
                        pickle->size());
 }
@@ -359,7 +359,7 @@ void NaClBrowser::OnValidationCacheLoaded(const std::string *data) {
     // No file found.
     validation_cache_.Reset();
   } else {
-    Pickle pickle(data->data(), data->size());
+    base::Pickle pickle(data->data(), data->size());
     validation_cache_.Deserialize(&pickle);
   }
   validation_cache_state_ = NaClResourceReady;
@@ -529,7 +529,7 @@ void NaClBrowser::PersistValidationCache() {
   // validation_cache_file_path_ may be empty if something went wrong during
   // initialization.
   if (validation_cache_is_modified_ && !validation_cache_file_path_.empty()) {
-    Pickle* pickle = new Pickle();
+    base::Pickle* pickle = new base::Pickle();
     validation_cache_.Serialize(pickle);
 
     // Pass the serialized data to another thread to write to disk.  File IO is
diff --git a/components/nacl/browser/nacl_validation_cache.cc b/components/nacl/browser/nacl_validation_cache.cc
index 574d818..e956cb1 100644
--- a/components/nacl/browser/nacl_validation_cache.cc
+++ b/components/nacl/browser/nacl_validation_cache.cc
@@ -52,7 +52,7 @@ void NaClValidationCache::SetKnownToValidate(const std::string& signature) {
   }
 }
 
-void NaClValidationCache::Serialize(Pickle* pickle) const {
+void NaClValidationCache::Serialize(base::Pickle* pickle) const {
   // Mark the beginning of the data stream.
   pickle->WriteString(kValidationCacheBeginMagic);
   pickle->WriteString(validation_cache_key_);
@@ -76,7 +76,7 @@ void NaClValidationCache::Reset() {
   validation_cache_.Clear();
 }
 
-bool NaClValidationCache::Deserialize(const Pickle* pickle) {
+bool NaClValidationCache::Deserialize(const base::Pickle* pickle) {
   bool success = DeserializeImpl(pickle);
   if (!success) {
     Reset();
@@ -84,8 +84,8 @@ bool NaClValidationCache::Deserialize(const Pickle* pickle) {
   return success;
 }
 
-bool NaClValidationCache::DeserializeImpl(const Pickle* pickle) {
-  PickleIterator iter(*pickle);
+bool NaClValidationCache::DeserializeImpl(const base::Pickle* pickle) {
+  base::PickleIterator iter(*pickle);
   std::string buffer;
   int count;
 
diff --git a/components/nacl/browser/nacl_validation_cache_unittest.cc b/components/nacl/browser/nacl_validation_cache_unittest.cc
index 945db2f..00378d0 100644
--- a/components/nacl/browser/nacl_validation_cache_unittest.cc
+++ b/components/nacl/browser/nacl_validation_cache_unittest.cc
@@ -144,7 +144,7 @@ TEST_F(NaClValidationCacheTest, SerializeDeserialize) {
   cache1.SetKnownToValidate(sig1);
   cache1.SetKnownToValidate(sig2);
 
-  Pickle pickle;
+  base::Pickle pickle;
   cache1.Serialize(&pickle);
   ASSERT_TRUE(cache2.Deserialize(&pickle));
   ASSERT_EQ(2, (int) cache2.size());
@@ -157,9 +157,10 @@ TEST_F(NaClValidationCacheTest, SerializeDeserializeTruncated) {
   cache1.SetKnownToValidate(sig1);
   cache1.SetKnownToValidate(sig2);
 
-  Pickle pickle;
+  base::Pickle pickle;
   cache1.Serialize(&pickle);
-  Pickle truncated(static_cast<const char*>(pickle.data()), pickle.size()-20);
+  base::Pickle truncated(static_cast<const char*>(pickle.data()),
+                         pickle.size() - 20);
   ASSERT_FALSE(cache2.Deserialize(&truncated));
   ASSERT_EQ(0, (int) cache2.size());
 }
@@ -170,7 +171,7 @@ TEST_F(NaClValidationCacheTest, DeserializeBadKey) {
   cache1.SetKnownToValidate(sig1);
   cache1.SetKnownToValidate(sig2);
 
-  Pickle pickle;
+  base::Pickle pickle;
   cache1.Serialize(&pickle);
   ASSERT_FALSE(cache2.Deserialize(&pickle));
   ASSERT_EQ(0, (int) cache2.size());
@@ -178,14 +179,14 @@ TEST_F(NaClValidationCacheTest, DeserializeBadKey) {
 
 TEST_F(NaClValidationCacheTest, DeserializeNothing) {
   cache1.SetKnownToValidate(sig1);
-  Pickle pickle("", 0);
+  base::Pickle pickle("", 0);
   ASSERT_FALSE(cache1.Deserialize(&pickle));
   ASSERT_EQ(0, (int) cache1.size());
 }
 
 TEST_F(NaClValidationCacheTest, DeserializeJunk) {
   cache1.SetKnownToValidate(sig1);
-  Pickle pickle(key1, strlen(key1));
+  base::Pickle pickle(key1, strlen(key1));
   ASSERT_FALSE(cache1.Deserialize(&pickle));
   ASSERT_EQ(0, (int) cache1.size());
 }
diff --git a/components/nacl/loader/nacl_helper_linux.cc b/components/nacl/loader/nacl_helper_linux.cc
index ac7648f..5b92b5c 100644
--- a/components/nacl/loader/nacl_helper_linux.cc
+++ b/components/nacl/loader/nacl_helper_linux.cc
@@ -169,8 +169,8 @@ void ChildNaClLoaderInit(ScopedVector<base::ScopedFD> child_fds,
 bool HandleForkRequest(ScopedVector<base::ScopedFD> child_fds,
                        const NaClLoaderSystemInfo& system_info,
                        nacl::NaClSandbox* nacl_sandbox,
-                       PickleIterator* input_iter,
-                       Pickle* output_pickle) {
+                       base::PickleIterator* input_iter,
+                       base::Pickle* output_pickle) {
   bool uses_nonsfi_mode;
   if (!input_iter->ReadBool(&uses_nonsfi_mode)) {
     LOG(ERROR) << "Could not read uses_nonsfi_mode status";
@@ -215,8 +215,8 @@ bool HandleForkRequest(ScopedVector<base::ScopedFD> child_fds,
   return true;
 }
 
-bool HandleGetTerminationStatusRequest(PickleIterator* input_iter,
-                                       Pickle* output_pickle) {
+bool HandleGetTerminationStatusRequest(base::PickleIterator* input_iter,
+                                       base::Pickle* output_pickle) {
   pid_t child_to_wait;
   if (!input_iter->ReadInt(&child_to_wait)) {
     LOG(ERROR) << "Could not read pid to wait for";
@@ -253,8 +253,8 @@ bool HonorRequestAndReply(int reply_fd,
                           ScopedVector<base::ScopedFD> attached_fds,
                           const NaClLoaderSystemInfo& system_info,
                           nacl::NaClSandbox* nacl_sandbox,
-                          PickleIterator* input_iter) {
-  Pickle write_pickle;
+                          base::PickleIterator* input_iter) {
+  base::Pickle write_pickle;
   bool have_to_reply = false;
   // Commands must write anything to send back to |write_pickle|.
   switch (command_type) {
@@ -309,8 +309,8 @@ bool HandleZygoteRequest(int zygote_ipc_fd,
     return false;
   }
 
-  Pickle read_pickle(buf, msglen);
-  PickleIterator read_iter(read_pickle);
+  base::Pickle read_pickle(buf, msglen);
+  base::PickleIterator read_iter(read_pickle);
   int command_type;
   if (!read_iter.ReadInt(&command_type)) {
     LOG(ERROR) << "Unable to read command from Zygote";
diff --git a/components/nacl/loader/nacl_ipc_adapter.cc b/components/nacl/loader/nacl_ipc_adapter.cc
index 8e402e1..a9ea0b8 100644
--- a/components/nacl/loader/nacl_ipc_adapter.cc
+++ b/components/nacl/loader/nacl_ipc_adapter.cc
@@ -485,7 +485,7 @@ bool NaClIPCAdapter::OnMessageReceived(const IPC::Message& msg) {
   // Handle PpapiHostMsg_OpenResource outside the lock as it requires sending
   // IPC to handle properly.
   if (type == PpapiHostMsg_OpenResource::ID) {
-    PickleIterator iter = IPC::SyncMessage::GetDataIterator(&msg);
+    base::PickleIterator iter = IPC::SyncMessage::GetDataIterator(&msg);
     ppapi::proxy::SerializedHandle sh;
     uint64_t token_lo;
     uint64_t token_hi;
@@ -639,7 +639,7 @@ void NaClIPCAdapter::SaveOpenResourceMessage(
     // The file token didn't resolve successfully, so we give the
     // original FD to the client without making a validated NaClDesc.
     // However, we must rewrite the message to clear the file tokens.
-    PickleIterator iter = IPC::SyncMessage::GetDataIterator(&orig_msg);
+    base::PickleIterator iter = IPC::SyncMessage::GetDataIterator(&orig_msg);
     ppapi::proxy::SerializedHandle sh;
 
     // We know that this can be read safely; see the original read in
diff --git a/components/nacl/zygote/nacl_fork_delegate_linux.cc b/components/nacl/zygote/nacl_fork_delegate_linux.cc
index 820ac09..12d265c 100644
--- a/components/nacl/zygote/nacl_fork_delegate_linux.cc
+++ b/components/nacl/zygote/nacl_fork_delegate_linux.cc
@@ -98,7 +98,7 @@ bool NonZeroSegmentBaseIsSlow() {
 // requests.
 bool SendIPCRequestAndReadReply(int ipc_channel,
                                 const std::vector<int>& attached_fds,
-                                const Pickle& request_pickle,
+                                const base::Pickle& request_pickle,
                                 char* reply_data_buffer,
                                 size_t reply_data_buffer_size,
                                 ssize_t* reply_size) {
@@ -367,7 +367,7 @@ pid_t NaClForkDelegate::Fork(const std::string& process_type,
   }
 
   // First, send a remote fork request.
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   write_pickle.WriteInt(nacl::kNaClForkRequest);
   // TODO(hamaji): When we split the helper binary for non-SFI mode
   // from nacl_helper, stop sending this information.
@@ -385,8 +385,8 @@ pid_t NaClForkDelegate::Fork(const std::string& process_type,
   }
 
   // Now see if the other end managed to fork.
-  Pickle reply_pickle(reply_buf, reply_size);
-  PickleIterator iter(reply_pickle);
+  base::Pickle reply_pickle(reply_buf, reply_size);
+  base::PickleIterator iter(reply_pickle);
   pid_t nacl_child;
   if (!iter.ReadInt(&nacl_child)) {
     LOG(ERROR) << "NaClForkDelegate::Fork: pickle failed";
@@ -403,7 +403,7 @@ bool NaClForkDelegate::GetTerminationStatus(pid_t pid, bool known_dead,
   DCHECK(status);
   DCHECK(exit_code);
 
-  Pickle write_pickle;
+  base::Pickle write_pickle;
   write_pickle.WriteInt(nacl::kNaClGetTerminationStatusRequest);
   write_pickle.WriteInt(pid);
   write_pickle.WriteBool(known_dead);
@@ -419,8 +419,8 @@ bool NaClForkDelegate::GetTerminationStatus(pid_t pid, bool known_dead,
     return false;
   }
 
-  Pickle reply_pickle(reply_buf, reply_size);
-  PickleIterator iter(reply_pickle);
+  base::Pickle reply_pickle(reply_buf, reply_size);
+  base::PickleIterator iter(reply_pickle);
   int termination_status;
   if (!iter.ReadInt(&termination_status) ||
       termination_status < 0 ||
diff --git a/components/network_hints/common/network_hints_messages.cc b/components/network_hints/common/network_hints_messages.cc
index e97e1a2..82eaf6e 100644
--- a/components/network_hints/common/network_hints_messages.cc
+++ b/components/network_hints/common/network_hints_messages.cc
@@ -16,7 +16,7 @@ void ParamTraits<network_hints::LookupRequest>::Write(
 
 bool ParamTraits<network_hints::LookupRequest>::Read(
     const Message* m,
-    PickleIterator* iter,
+    base::PickleIterator* iter,
     network_hints::LookupRequest* request) {
   // Verify the hostname limits after deserialization success.
   if (IPC::ReadParam(m, iter, &request->hostname_list)) {
diff --git a/components/password_manager/core/browser/login_database.cc b/components/password_manager/core/browser/login_database.cc
index 91c71d0..9039b8c 100644
--- a/components/password_manager/core/browser/login_database.cc
+++ b/components/password_manager/core/browser/login_database.cc
@@ -32,19 +32,19 @@ namespace password_manager {
 const int kCurrentVersionNumber = 13;
 static const int kCompatibleVersionNumber = 1;
 
-Pickle SerializeVector(const std::vector<base::string16>& vec) {
-  Pickle p;
+base::Pickle SerializeVector(const std::vector<base::string16>& vec) {
+  base::Pickle p;
   for (size_t i = 0; i < vec.size(); ++i) {
     p.WriteString16(vec[i]);
   }
   return p;
 }
 
-std::vector<base::string16> DeserializeVector(const Pickle& p) {
+std::vector<base::string16> DeserializeVector(const base::Pickle& p) {
   std::vector<base::string16> ret;
   base::string16 str;
 
-  PickleIterator iterator(p);
+  base::PickleIterator iterator(p);
   while (iterator.ReadString16(&str)) {
     ret.push_back(str);
   }
@@ -98,12 +98,13 @@ void BindAddStatement(const PasswordForm& form,
   s->BindInt(COLUMN_BLACKLISTED_BY_USER, form.blacklisted_by_user);
   s->BindInt(COLUMN_SCHEME, form.scheme);
   s->BindInt(COLUMN_PASSWORD_TYPE, form.type);
-  Pickle usernames_pickle = SerializeVector(form.other_possible_usernames);
+  base::Pickle usernames_pickle =
+      SerializeVector(form.other_possible_usernames);
   s->BindBlob(COLUMN_POSSIBLE_USERNAMES,
               usernames_pickle.data(),
               usernames_pickle.size());
   s->BindInt(COLUMN_TIMES_USED, form.times_used);
-  Pickle form_data_pickle;
+  base::Pickle form_data_pickle;
   autofill::SerializeFormData(form.form_data, &form_data_pickle);
   s->BindBlob(COLUMN_FORM_DATA,
               form_data_pickle.data(),
@@ -612,7 +613,7 @@ PasswordStoreChangeList LoginDatabase::UpdateLogin(const PasswordForm& form) {
              static_cast<int>(encrypted_password.length()));
   s.BindInt(2, form.ssl_valid);
   s.BindInt(3, form.preferred);
-  Pickle pickle = SerializeVector(form.other_possible_usernames);
+  base::Pickle pickle = SerializeVector(form.other_possible_usernames);
   s.BindBlob(4, pickle.data(), pickle.size());
   s.BindInt(5, form.times_used);
   s.BindString16(6, form.submit_element);
@@ -729,17 +730,17 @@ LoginDatabase::EncryptionResult LoginDatabase::InitPasswordFormFromStatement(
   DCHECK(type_int >= 0 && type_int <= PasswordForm::TYPE_GENERATED);
   form->type = static_cast<PasswordForm::Type>(type_int);
   if (s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES)) {
-    Pickle pickle(
+    base::Pickle pickle(
         static_cast<const char*>(s.ColumnBlob(COLUMN_POSSIBLE_USERNAMES)),
         s.ColumnByteLength(COLUMN_POSSIBLE_USERNAMES));
     form->other_possible_usernames = DeserializeVector(pickle);
   }
   form->times_used = s.ColumnInt(COLUMN_TIMES_USED);
   if (s.ColumnByteLength(COLUMN_FORM_DATA)) {
-    Pickle form_data_pickle(
+    base::Pickle form_data_pickle(
         static_cast<const char*>(s.ColumnBlob(COLUMN_FORM_DATA)),
         s.ColumnByteLength(COLUMN_FORM_DATA));
-    PickleIterator form_data_iter(form_data_pickle);
+    base::PickleIterator form_data_iter(form_data_pickle);
     bool success =
         autofill::DeserializeFormData(&form_data_iter, &form->form_data);
     metrics_util::FormDeserializationStatus status =
diff --git a/components/password_manager/core/browser/login_database_unittest.cc b/components/password_manager/core/browser/login_database_unittest.cc
index b47b92d..fd11d08 100644
--- a/components/password_manager/core/browser/login_database_unittest.cc
+++ b/components/password_manager/core/browser/login_database_unittest.cc
@@ -72,8 +72,8 @@ void GenerateExamplePasswordForm(PasswordForm* form) {
 }  // namespace
 
 // Serialization routines for vectors implemented in login_database.cc.
-Pickle SerializeVector(const std::vector<base::string16>& vec);
-std::vector<base::string16> DeserializeVector(const Pickle& pickle);
+base::Pickle SerializeVector(const std::vector<base::string16>& vec);
+std::vector<base::string16> DeserializeVector(const base::Pickle& pickle);
 
 class LoginDatabaseTest : public testing::Test {
  protected:
@@ -765,7 +765,7 @@ TEST_F(LoginDatabaseTest, BlacklistedLogins) {
 TEST_F(LoginDatabaseTest, VectorSerialization) {
   // Empty vector.
   std::vector<base::string16> vec;
-  Pickle temp = SerializeVector(vec);
+  base::Pickle temp = SerializeVector(vec);
   std::vector<base::string16> output = DeserializeVector(temp);
   EXPECT_THAT(output, Eq(vec));
 
diff --git a/components/sessions/base_session_service_commands.cc b/components/sessions/base_session_service_commands.cc
index 09eab43..e8aaeec 100644
--- a/components/sessions/base_session_service_commands.cc
+++ b/components/sessions/base_session_service_commands.cc
@@ -14,7 +14,9 @@ namespace {
 // Helper used by CreateUpdateTabNavigationCommand(). It writes |str| to
 // |pickle|, if and only if |str| fits within (|max_bytes| - |*bytes_written|).
 // |bytes_written| is incremented to reflect the data written.
-void WriteStringToPickle(Pickle& pickle, int* bytes_written, int max_bytes,
+void WriteStringToPickle(base::Pickle& pickle,
+                         int* bytes_written,
+                         int max_bytes,
                          const std::string& str) {
   int num_bytes = str.size() * sizeof(char);
   if (*bytes_written + num_bytes < max_bytes) {
@@ -32,7 +34,7 @@ scoped_ptr<SessionCommand> CreateUpdateTabNavigationCommand(
     SessionID::id_type tab_id,
     const sessions::SerializedNavigationEntry& navigation) {
   // Use pickle to handle marshalling.
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(tab_id);
   // We only allow navigations up to 63k (which should be completely
   // reasonable).
@@ -47,7 +49,7 @@ scoped_ptr<SessionCommand> CreateSetTabExtensionAppIDCommand(
     SessionID::id_type tab_id,
     const std::string& extension_id) {
   // Use pickle to handle marshalling.
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(tab_id);
 
   // Enforce a max for ids. They should never be anywhere near this size.
@@ -66,7 +68,7 @@ scoped_ptr<SessionCommand> CreateSetTabUserAgentOverrideCommand(
     SessionID::id_type tab_id,
     const std::string& user_agent_override) {
   // Use pickle to handle marshalling.
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(tab_id);
 
   // Enforce a max for the user agent length.  They should never be anywhere
@@ -87,7 +89,7 @@ scoped_ptr<SessionCommand> CreateSetWindowAppNameCommand(
     SessionID::id_type window_id,
     const std::string& app_name) {
   // Use pickle to handle marshalling.
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(window_id);
 
   // Enforce a max for ids. They should never be anywhere near this size.
@@ -105,43 +107,43 @@ bool RestoreUpdateTabNavigationCommand(
     const SessionCommand& command,
     sessions::SerializedNavigationEntry* navigation,
     SessionID::id_type* tab_id) {
-  scoped_ptr<Pickle> pickle(command.PayloadAsPickle());
+  scoped_ptr<base::Pickle> pickle(command.PayloadAsPickle());
   if (!pickle.get())
     return false;
-  PickleIterator iterator(*pickle);
+  base::PickleIterator iterator(*pickle);
   return iterator.ReadInt(tab_id) && navigation->ReadFromPickle(&iterator);
 }
 
 bool RestoreSetTabExtensionAppIDCommand(const SessionCommand& command,
                                         SessionID::id_type* tab_id,
                                         std::string* extension_app_id) {
-  scoped_ptr<Pickle> pickle(command.PayloadAsPickle());
+  scoped_ptr<base::Pickle> pickle(command.PayloadAsPickle());
   if (!pickle.get())
     return false;
 
-  PickleIterator iterator(*pickle);
+  base::PickleIterator iterator(*pickle);
   return iterator.ReadInt(tab_id) && iterator.ReadString(extension_app_id);
 }
 
 bool RestoreSetTabUserAgentOverrideCommand(const SessionCommand& command,
                                            SessionID::id_type* tab_id,
                                            std::string* user_agent_override) {
-  scoped_ptr<Pickle> pickle(command.PayloadAsPickle());
+  scoped_ptr<base::Pickle> pickle(command.PayloadAsPickle());
   if (!pickle.get())
     return false;
 
-  PickleIterator iterator(*pickle);
+  base::PickleIterator iterator(*pickle);
   return iterator.ReadInt(tab_id) && iterator.ReadString(user_agent_override);
 }
 
 bool RestoreSetWindowAppNameCommand(const SessionCommand& command,
                                     SessionID::id_type* window_id,
                                     std::string* app_name) {
-  scoped_ptr<Pickle> pickle(command.PayloadAsPickle());
+  scoped_ptr<base::Pickle> pickle(command.PayloadAsPickle());
   if (!pickle.get())
     return false;
 
-  PickleIterator iterator(*pickle);
+  base::PickleIterator iterator(*pickle);
   return iterator.ReadInt(window_id) && iterator.ReadString(app_name);
 }
 
diff --git a/components/sessions/serialized_navigation_entry.cc b/components/sessions/serialized_navigation_entry.cc
index 929c72f..e630c19 100644
--- a/components/sessions/serialized_navigation_entry.cc
+++ b/components/sessions/serialized_navigation_entry.cc
@@ -144,7 +144,7 @@ namespace {
 //
 // TODO(akalin): Unify this with the same function in
 // base_session_service.cc.
-void WriteStringToPickle(Pickle* pickle,
+void WriteStringToPickle(base::Pickle* pickle,
                          int* bytes_written,
                          int max_bytes,
                          const std::string& str) {
@@ -160,7 +160,7 @@ void WriteStringToPickle(Pickle* pickle,
 // base::string16 version of WriteStringToPickle.
 //
 // TODO(akalin): Unify this, too.
-void WriteString16ToPickle(Pickle* pickle,
+void WriteString16ToPickle(base::Pickle* pickle,
                            int* bytes_written,
                            int max_bytes,
                            const base::string16& str) {
@@ -206,7 +206,7 @@ enum TypeMask {
 // referrer_policy_
 
 void SerializedNavigationEntry::WriteToPickle(int max_size,
-                                              Pickle* pickle) const {
+                                              base::Pickle* pickle) const {
   pickle->WriteInt(index_);
 
   int bytes_written = 0;
@@ -250,7 +250,7 @@ void SerializedNavigationEntry::WriteToPickle(int max_size,
   pickle->WriteInt(referrer_policy_);
 }
 
-bool SerializedNavigationEntry::ReadFromPickle(PickleIterator* iterator) {
+bool SerializedNavigationEntry::ReadFromPickle(base::PickleIterator* iterator) {
   *this = SerializedNavigationEntry();
   std::string virtual_url_spec;
   int transition_type_int = 0;
diff --git a/components/sessions/serialized_navigation_entry_unittest.cc b/components/sessions/serialized_navigation_entry_unittest.cc
index ac6ae54..417601e 100644
--- a/components/sessions/serialized_navigation_entry_unittest.cc
+++ b/components/sessions/serialized_navigation_entry_unittest.cc
@@ -107,11 +107,11 @@ TEST(SerializedNavigationEntryTest, Pickle) {
   const SerializedNavigationEntry old_navigation =
       SerializedNavigationEntryTestHelper::CreateNavigationForTest();
 
-  Pickle pickle;
+  base::Pickle pickle;
   old_navigation.WriteToPickle(30000, &pickle);
 
   SerializedNavigationEntry new_navigation;
-  PickleIterator pickle_iterator(pickle);
+  base::PickleIterator pickle_iterator(pickle);
   EXPECT_TRUE(new_navigation.ReadFromPickle(&pickle_iterator));
 
   // Fields that are written to the pickle.
diff --git a/components/sessions/session_command.cc b/components/sessions/session_command.cc
index 59fc6fc..a7cd59d 100644
--- a/components/sessions/session_command.cc
+++ b/components/sessions/session_command.cc
@@ -14,7 +14,7 @@ SessionCommand::SessionCommand(id_type id, size_type size)
       contents_(size, 0) {
 }
 
-SessionCommand::SessionCommand(id_type id, const Pickle& pickle)
+SessionCommand::SessionCommand(id_type id, const base::Pickle& pickle)
     : id_(id),
       contents_(pickle.size(), 0) {
   DCHECK(pickle.size() < std::numeric_limits<size_type>::max());
@@ -28,8 +28,8 @@ bool SessionCommand::GetPayload(void* dest, size_t count) const {
   return true;
 }
 
-Pickle* SessionCommand::PayloadAsPickle() const {
-  return new Pickle(contents(), static_cast<int>(size()));
+base::Pickle* SessionCommand::PayloadAsPickle() const {
+  return new base::Pickle(contents(), static_cast<int>(size()));
 }
 
 }  // namespace sessions
diff --git a/components/sessions/session_service_commands.cc b/components/sessions/session_service_commands.cc
index a7f653d..60be71c 100644
--- a/components/sessions/session_service_commands.cc
+++ b/components/sessions/session_service_commands.cc
@@ -541,10 +541,10 @@ bool CreateTabsAndWindows(const ScopedVector<SessionCommand>& data,
       }
 
       case kCommandSessionStorageAssociated: {
-        scoped_ptr<Pickle> command_pickle(command->PayloadAsPickle());
+        scoped_ptr<base::Pickle> command_pickle(command->PayloadAsPickle());
         SessionID::id_type command_tab_id;
         std::string session_storage_persistent_id;
-        PickleIterator iter(*command_pickle.get());
+        base::PickleIterator iter(*command_pickle.get());
         if (!iter.ReadInt(&command_tab_id) ||
             !iter.ReadString(&session_storage_persistent_id))
           return true;
@@ -705,7 +705,7 @@ scoped_ptr<SessionCommand> CreatePinnedStateCommand(
 scoped_ptr<SessionCommand> CreateSessionStorageAssociatedCommand(
     const SessionID& tab_id,
     const std::string& session_storage_persistent_id) {
-  Pickle pickle;
+  base::Pickle pickle;
   pickle.WriteInt(tab_id.id());
   pickle.WriteString(session_storage_persistent_id);
   return scoped_ptr<SessionCommand>(
@@ -806,8 +806,8 @@ bool ReplacePendingCommand(BaseSessionService* base_session_service,
     SessionCommand* existing_command = *i;
     if ((*command)->id() == kCommandUpdateTabNavigation &&
         existing_command->id() == kCommandUpdateTabNavigation) {
-      scoped_ptr<Pickle> command_pickle((*command)->PayloadAsPickle());
-      PickleIterator iterator(*command_pickle);
+      scoped_ptr<base::Pickle> command_pickle((*command)->PayloadAsPickle());
+      base::PickleIterator iterator(*command_pickle);
       SessionID::id_type command_tab_id;
       int command_nav_index;
       if (!iterator.ReadInt(&command_tab_id) ||
@@ -820,8 +820,9 @@ bool ReplacePendingCommand(BaseSessionService* base_session_service,
         // Creating a pickle like this means the Pickle references the data from
         // the command. Make sure we delete the pickle before the command, else
         // the pickle references deleted memory.
-        scoped_ptr<Pickle> existing_pickle(existing_command->PayloadAsPickle());
-        iterator = PickleIterator(*existing_pickle);
+        scoped_ptr<base::Pickle> existing_pickle(
+            existing_command->PayloadAsPickle());
+        iterator = base::PickleIterator(*existing_pickle);
         if (!iterator.ReadInt(&existing_tab_id) ||
             !iterator.ReadInt(&existing_nav_index)) {
           return false;
diff --git a/components/visitedlink/test/visitedlink_unittest.cc b/components/visitedlink/test/visitedlink_unittest.cc
index 81d62ae..1b0454d 100644
--- a/components/visitedlink/test/visitedlink_unittest.cc
+++ b/components/visitedlink/test/visitedlink_unittest.cc
@@ -551,7 +551,7 @@ class VisitRelayingRenderProcessHost : public MockRenderProcessHost {
             GetBrowserContext());
 
     if (msg->type() == ChromeViewMsg_VisitedLink_Add::ID) {
-      PickleIterator iter(*msg);
+      base::PickleIterator iter(*msg);
       std::vector<uint64> fingerprints;
       CHECK(IPC::ReadParam(msg, &iter, &fingerprints));
       counting_context->CountAddEvent(fingerprints.size());