Change most uses of Pickle to base::Pickle

components/sessions/serialized_navigation_entry.cc

 // Copyright 2013 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 "components/sessions/serialized_navigation_entry.h"
 
 #include "base/pickle.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/sessions/core/serialized_navigation_driver.h"
 #include "sync/protocol/session_specifics.pb.h"
@@ skipping 126 matching lines @@
 
 namespace {
 
 // Helper used by SerializedNavigationEntry::WriteToPickle(). 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.
 //
 // 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) {
   int num_bytes = str.size() * sizeof(char);
   if (*bytes_written + num_bytes < max_bytes) {
     *bytes_written += num_bytes;
     pickle->WriteString(str);
   } else {
     pickle->WriteString(std::string());
   }
 }
 
 // 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) {
   int num_bytes = str.size() * sizeof(base::char16);
   if (*bytes_written + num_bytes < max_bytes) {
     *bytes_written += num_bytes;
     pickle->WriteString16(str);
   } else {
     pickle->WriteString16(base::string16());
   }
@@ skipping 25 matching lines @@
 // referrer_url_
 // referrer_policy_ (broken, crbug.com/450589)
 // original_request_url_
 // is_overriding_user_agent_
 // timestamp_
 // search_terms_
 // http_status_code_
 // referrer_policy_
 
 void SerializedNavigationEntry::WriteToPickle(int max_size,
-                                              Pickle* pickle) const {
+                                              base::Pickle* pickle) const {
   pickle->WriteInt(index_);
 
   int bytes_written = 0;
 
   WriteStringToPickle(pickle, &bytes_written, max_size,
                       virtual_url_.spec());
 
   WriteString16ToPickle(pickle, &bytes_written, max_size, title_);
 
   const std::string encoded_page_state =
@@ skipping 23 matching lines @@
   pickle->WriteBool(is_overriding_user_agent_);
   pickle->WriteInt64(timestamp_.ToInternalValue());
 
   WriteString16ToPickle(pickle, &bytes_written, max_size, search_terms_);
 
   pickle->WriteInt(http_status_code_);
 
   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;
   if (!iterator->ReadInt(&index_) ||
       !iterator->ReadString(&virtual_url_spec) ||
       !iterator->ReadString16(&title_) ||
       !iterator->ReadString(&encoded_page_state_) ||
       !iterator->ReadInt(&transition_type_int))
     return false;
   virtual_url_ = GURL(virtual_url_spec);
@@ skipping 200 matching lines @@
           redirect_chain_[last_entry].spec());
     }
   }
 
   sync_data.set_is_restored(is_restored_);
 
   return sync_data;
 }
 
 }  // namespace sessions