Change most uses of Pickle to base::Pickle

chrome/browser/password_manager/native_backend_kwallet_x.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 "chrome/browser/password_manager/native_backend_kwallet_x.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 49 matching lines @@
          a.signon_realm     == b.signon_realm &&
          a.username_element == b.username_element &&
          a.username_value   == b.username_value;
 }
 
 // Checks a serialized list of PasswordForms for sanity. Returns true if OK.
 // Note that |realm| is only used for generating a useful warning message.
 bool CheckSerializedValue(const uint8_t* byte_array,
                           size_t length,
                           const std::string& realm) {
-  const Pickle::Header* header =
-      reinterpret_cast<const Pickle::Header*>(byte_array);
+  const base::Pickle::Header* header =
+      reinterpret_cast<const base::Pickle::Header*>(byte_array);
   if (length < sizeof(*header) ||
       header->payload_size > length - sizeof(*header)) {
     LOG(WARNING) << "Invalid KWallet entry detected (realm: " << realm << ")";
     return false;
   }
   return true;
 }
 
 // Convenience function to read a GURL from a Pickle. Assumes the URL has
 // been written as a UTF-8 string. Returns true on success.
-bool ReadGURL(PickleIterator* iter, bool warn_only, GURL* url) {
+bool ReadGURL(base::PickleIterator* iter, bool warn_only, GURL* url) {
   std::string url_string;
   if (!iter->ReadString(&url_string)) {
     if (!warn_only)
       LOG(ERROR) << "Failed to deserialize URL.";
     *url = GURL();
     return false;
   }
   *url = GURL(url_string);
   return true;
 }
@@ skipping 13 matching lines @@
 }
 
 // Deserializes a list of credentials from the wallet to |forms| (replacing
 // the contents of |forms|). |size_32| controls reading the size field within
 // the pickle as 32 bits. We used to use Pickle::WriteSize() to write the number
 // of password forms, but that has a different size on 32- and 64-bit systems.
 // So, now we always write a 64-bit quantity, but we support trying to read it
 // as either size when reading old pickles that fail to deserialize using the
 // native size. Returns true on success.
 bool DeserializeValueSize(const std::string& signon_realm,
-                          const PickleIterator& init_iter,
+                          const base::PickleIterator& init_iter,
                           int version,
                           bool size_32,
                           bool warn_only,
                           ScopedVector<autofill::PasswordForm>* forms) {
-  PickleIterator iter = init_iter;
+  base::PickleIterator iter = init_iter;
 
   size_t count = 0;
   if (size_32) {
     uint32_t count_32 = 0;
     if (!iter.ReadUInt32(&count_32)) {
       LOG(ERROR) << "Failed to deserialize KWallet entry "
                  << "(realm: " << signon_realm << ")";
       return false;
     }
     count = count_32;
@@ skipping 96 matching lines @@
 
     converted_forms.push_back(form.Pass());
   }
 
   forms->swap(converted_forms);
   return true;
 }
 
 // Serializes a list of PasswordForms to be stored in the wallet.
 void SerializeValue(const std::vector<autofill::PasswordForm*>& forms,
-                    Pickle* pickle) {
+                    base::Pickle* pickle) {
   pickle->WriteInt(kPickleVersion);
   pickle->WriteSizeT(forms.size());
   for (autofill::PasswordForm* form : forms) {
     pickle->WriteInt(form->scheme);
     pickle->WriteString(form->origin.spec());
     pickle->WriteString(form->action.spec());
     pickle->WriteString16(form->username_element);
     pickle->WriteString16(form->username_value);
     pickle->WriteString16(form->password_element);
     pickle->WriteString16(form->password_value);
@@ skipping 381 matching lines @@
       return false;
     if (!CheckSerializedValue(bytes, length, signon_realm)) {
       // This is weird, but we choose not to call it an error. There is an
       // invalid entry somehow, but by just ignoring it, we make it easier to
       // repair without having to delete it using kwalletmanager (that is, by
       // just saving a new password within this realm to overwrite it).
       return true;
     }
 
     // Can't we all just agree on whether bytes are signed or not? Please?
-    Pickle pickle(reinterpret_cast<const char*>(bytes), length);
+    base::Pickle pickle(reinterpret_cast<const char*>(bytes), length);
     *forms = DeserializeValue(signon_realm, pickle);
   }
 
   return true;
 }
 
 bool NativeBackendKWallet::GetLoginsList(
     BlacklistOptions options,
     int wallet_handle,
     ScopedVector<autofill::PasswordForm>* forms) {
@@ skipping 61 matching lines @@
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
       LOG(ERROR) << "Error reading response from kwalletd (readEntry): "
                  << response->ToString();
       return false;
     }
     if (!bytes || !CheckSerializedValue(bytes, length, signon_realm))
       continue;
 
     // Can't we all just agree on whether bytes are signed or not? Please?
-    Pickle pickle(reinterpret_cast<const char*>(bytes), length);
+    base::Pickle pickle(reinterpret_cast<const char*>(bytes), length);
     AppendSecondToFirst(forms, DeserializeValue(signon_realm, pickle));
   }
   return true;
 }
 
 bool NativeBackendKWallet::SetLoginsList(
     const std::vector<autofill::PasswordForm*>& forms,
     const std::string& signon_realm,
     int wallet_handle) {
   if (forms.empty()) {
@@ skipping 16 matching lines @@
     if (!reader.PopInt32(&ret)) {
       LOG(ERROR) << "Error reading response from kwalletd (removeEntry): "
                  << response->ToString();
       return false;
     }
     if (ret != 0)
       LOG(ERROR) << "Bad return code " << ret << " from KWallet removeEntry";
     return ret == 0;
   }
 
-  Pickle value;
+  base::Pickle value;
   SerializeValue(forms, &value);
 
   dbus::MethodCall method_call(kKWalletInterface, "writeEntry");
   dbus::MessageWriter builder(&method_call);
   builder.AppendInt32(wallet_handle);  // handle
   builder.AppendString(folder_name_);  // folder
   builder.AppendString(signon_realm);  // key
   builder.AppendArrayOfBytes(static_cast<const uint8_t*>(value.data()),
                              value.size());  // value
   builder.AppendString(app_name_);     // appid
@@ skipping 79 matching lines @@
     size_t length = 0;
     if (!reader.PopArrayOfBytes(&bytes, &length)) {
       LOG(ERROR) << "Error reading response from kwalletd (readEntry): "
                  << response->ToString();
       continue;
     }
     if (!bytes || !CheckSerializedValue(bytes, length, signon_realm))
       continue;
 
     // Can't we all just agree on whether bytes are signed or not? Please?
-    Pickle pickle(reinterpret_cast<const char*>(bytes), length);
+    base::Pickle pickle(reinterpret_cast<const char*>(bytes), length);
     ScopedVector<autofill::PasswordForm> all_forms =
         DeserializeValue(signon_realm, pickle);
 
     ScopedVector<autofill::PasswordForm> kept_forms;
     kept_forms.reserve(all_forms.size());
     base::Time autofill::PasswordForm::*date_member =
         date_to_compare == CREATION_TIMESTAMP
             ? &autofill::PasswordForm::date_created
             : &autofill::PasswordForm::date_synced;
     for (auto& saved_form : all_forms) {
@@ skipping 11 matching lines @@
       ok = false;
       changes->clear();
     }
   }
   return ok;
 }
 
 // static
 ScopedVector<autofill::PasswordForm> NativeBackendKWallet::DeserializeValue(
     const std::string& signon_realm,
-    const Pickle& pickle) {
-  PickleIterator iter(pickle);
+    const base::Pickle& pickle) {
+  base::PickleIterator iter(pickle);
 
   int version = -1;
   if (!iter.ReadInt(&version) ||
       version < 0 || version > kPickleVersion) {
     LOG(ERROR) << "Failed to deserialize KWallet entry "
                << "(realm: " << signon_realm << ")";
     return ScopedVector<autofill::PasswordForm>();
   }
 
   ScopedVector<autofill::PasswordForm> forms;
@@ skipping 102 matching lines @@
   }
 
   return handle;
 }
 
 std::string NativeBackendKWallet::GetProfileSpecificFolderName() const {
   // Originally, the folder name was always just "Chrome Form Data".
   // Now we use it to distinguish passwords for different profiles.
   return base::StringPrintf("%s (%d)", kKWalletFolder, profile_id_);
 }