Change most uses of Pickle to base::Pickle

chrome/browser/android/tab_state.cc

 // Copyright 2014 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 "chrome/browser/android/tab_state.h"
 
 #include <jni.h>
 #include <limits>
 #include <vector>
 
@@ skipping 15 matching lines @@
 #include "jni/TabState_jni.h"
 
 using base::android::ConvertUTF16ToJavaString;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaLocalRef;
 using content::NavigationController;
 using content::WebContents;
 
 namespace {
 
-bool WriteStateHeaderToPickle(bool off_the_record, int entry_count,
-    int current_entry_index, Pickle* pickle) {
+bool WriteStateHeaderToPickle(bool off_the_record,
+                              int entry_count,
+                              int current_entry_index,
+                              base::Pickle* pickle) {
   return pickle->WriteBool(off_the_record) &&
       pickle->WriteInt(entry_count) &&
       pickle->WriteInt(current_entry_index);
 }
 
 // Migrates a pickled SerializedNavigationEntry from Android tab version 0 to
 // 2 or (Chrome 18->26).
 //
 // Due to the fact that all SerializedNavigationEntrys were previously stored
 // in a single pickle on Android, this function has to read the fields exactly
@@ skipping 11 matching lines @@
 //   transition_type
 //   type_mask
 //
 // 2. For each tab navigation:
 //   referrer
 //   is_overriding_user_agent
 //
 void UpgradeNavigationFromV0ToV2(
     std::vector<sessions::SerializedNavigationEntry>* navigations,
     int entry_count,
-    PickleIterator* iterator) {
-
+    base::PickleIterator* iterator) {
   for (int i = 0; i < entry_count; ++i) {
-    Pickle v2_pickle;
+    base::Pickle v2_pickle;
     std::string virtual_url_spec;
     std::string str_referrer;
     base::string16 title;
     std::string content_state;
     int transition_type_int;
     if (!iterator->ReadString(&virtual_url_spec) ||
         !iterator->ReadString(&str_referrer) ||
         !iterator->ReadString16(&title) ||
         !iterator->ReadString(&content_state) ||
         !iterator->ReadInt(&transition_type_int))
@@ skipping 14 matching lines @@
     v2_pickle.WriteInt(0);
     // original_request_url_spec
     v2_pickle.WriteString(std::string());
     // is_overriding_user_agent
     v2_pickle.WriteBool(false);
     // timestamp_internal_value
     v2_pickle.WriteInt64(0);
     // search_terms
     v2_pickle.WriteString16(base::string16());
 
-    PickleIterator tab_navigation_pickle_iterator(v2_pickle);
+    base::PickleIterator tab_navigation_pickle_iterator(v2_pickle);
     sessions::SerializedNavigationEntry nav;
     if (nav.ReadFromPickle(&tab_navigation_pickle_iterator)) {
       navigations->push_back(nav);
     } else {
       LOG(ERROR) << "Failed to read SerializedNavigationEntry from pickle "
                  << "(index=" << i << ", url=" << virtual_url_spec;
     }
 
   }
 
@@ skipping 27 matching lines @@
 // type_mask
 // referrer
 // original_request_url
 // is_overriding_user_agent
 // timestamp
 //
 // And finally search_terms was added and this function appends it.
 void UpgradeNavigationFromV1ToV2(
     std::vector<sessions::SerializedNavigationEntry>* navigations,
     int entry_count,
-    PickleIterator* iterator) {
+    base::PickleIterator* iterator) {
   for (int i = 0; i < entry_count; ++i) {
-    Pickle v2_pickle;
+    base::Pickle v2_pickle;
 
     int index;
     std::string virtual_url_spec;
     base::string16 title;
     std::string content_state;
     int transition_type_int;
     if (!iterator->ReadInt(&index) ||
         !iterator->ReadString(&virtual_url_spec) ||
         !iterator->ReadString16(&title) ||
         !iterator->ReadString(&content_state) ||
@@ skipping 28 matching lines @@
     if (iterator->ReadBool(&is_overriding_user_agent))
       v2_pickle.WriteBool(is_overriding_user_agent);
 
     int64 timestamp_internal_value = 0;
     if (iterator->ReadInt64(&timestamp_internal_value))
       v2_pickle.WriteInt64(timestamp_internal_value);
 
     // Force output of search_terms
     v2_pickle.WriteString16(base::string16());
 
-    PickleIterator tab_navigation_pickle_iterator(v2_pickle);
+    base::PickleIterator tab_navigation_pickle_iterator(v2_pickle);
     sessions::SerializedNavigationEntry nav;
     if (nav.ReadFromPickle(&tab_navigation_pickle_iterator)) {
       navigations->push_back(nav);
     } else {
       LOG(ERROR) << "Failed to read SerializedNavigationEntry from pickle "
                  << "(index=" << i << ", url=" << virtual_url_spec;
     }
   }
 }
 
 // Extracts state and navigation entries from the given Pickle data and returns
 // whether un-pickling the data succeeded
 bool ExtractNavigationEntries(
     void* data,
     int size,
     int saved_state_version,
     bool* is_off_the_record,
     int* current_entry_index,
     std::vector<sessions::SerializedNavigationEntry>* navigations) {
   int entry_count;
-  Pickle pickle(static_cast<char*>(data), size);
-  PickleIterator iter(pickle);
+  base::Pickle pickle(static_cast<char*>(data), size);
+  base::PickleIterator iter(pickle);
   if (!iter.ReadBool(is_off_the_record) || !iter.ReadInt(&entry_count) ||
       !iter.ReadInt(current_entry_index)) {
     LOG(ERROR) << "Failed to restore state from byte array (length=" << size
                << ").";
     return false;
   }
 
   if (!saved_state_version) {
     // When |saved_state_version| is 0, it predates our notion of each tab
     // having a saved version id. For that version of tab serialization, we
@@ skipping 12 matching lines @@
       int tab_navigation_data_length = 0;
       const char* tab_navigation_data = NULL;
       if (!iter.ReadInt(&tab_navigation_data_length) ||
           !iter.ReadBytes(&tab_navigation_data, tab_navigation_data_length)) {
         LOG(ERROR)
             << "Failed to restore tab entry from byte array. "
             << "(SerializedNavigationEntry size=" << tab_navigation_data_length
             << ").";
         return false;  // It's dangerous to keep deserializing now, give up.
       }
-      Pickle tab_navigation_pickle(tab_navigation_data,
-                                   tab_navigation_data_length);
-      PickleIterator tab_navigation_pickle_iterator(tab_navigation_pickle);
+      base::Pickle tab_navigation_pickle(tab_navigation_data,
+                                         tab_navigation_data_length);
+      base::PickleIterator tab_navigation_pickle_iterator(
+          tab_navigation_pickle);
       sessions::SerializedNavigationEntry nav;
       if (!nav.ReadFromPickle(&tab_navigation_pickle_iterator))
         return false;  // If we failed to read a navigation, give up on others.
 
       navigations->push_back(nav);
     }
   }
 
   // Validate the data.
   if (*current_entry_index < 0 ||
@@ skipping 40 matching lines @@
 }
 
 // Common implementation for GetContentsStateAsByteBuffer() and
 // CreateContentsStateAsByteBuffer(). Does not assume ownership of the
 // navigations.
 ScopedJavaLocalRef<jobject> WebContentsState::WriteNavigationsAsByteBuffer(
     JNIEnv* env,
     bool is_off_the_record,
     const std::vector<content::NavigationEntry*>& navigations,
     int current_entry) {
-  Pickle pickle;
+  base::Pickle pickle;
   if (!WriteStateHeaderToPickle(is_off_the_record, navigations.size(),
                                 current_entry, &pickle)) {
     LOG(ERROR) << "Failed to serialize tab state (entry count=" <<
         navigations.size() << ").";
     return ScopedJavaLocalRef<jobject>();
   }
 
   // Write out all of the NavigationEntrys.
   for (size_t i = 0; i < navigations.size(); ++i) {
     // Write each SerializedNavigationEntry as a separate pickle to avoid
     // optional reads of one tab bleeding into the next tab's data.
-    Pickle tab_navigation_pickle;
+    base::Pickle tab_navigation_pickle;
     // Max size taken from BaseSessionService::CreateUpdateTabNavigationCommand.
     static const size_t max_state_size =
         std::numeric_limits<sessions::SessionCommand::size_type>::max() - 1024;
     sessions::ContentSerializedNavigationBuilder::FromNavigationEntry(
         i, *navigations[i])
         .WriteToPickle(max_state_size, &tab_navigation_pickle);
     pickle.WriteInt(tab_navigation_pickle.size());
     pickle.WriteBytes(tab_navigation_pickle.data(),
                       tab_navigation_pickle.size());
   }
@@ skipping 216 matching lines @@
                                                       state,
                                                       saved_state_version,
                                                       true));
   if (web_contents.get())
     TabAndroid::CreateHistoricalTabFromContents(web_contents.get());
 }
 
 bool RegisterTabState(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }