Change most uses of Pickle to base::Pickle

components/password_manager/core/browser/login_database.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 "components/password_manager/core/browser/login_database.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 14 matching lines @@
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using autofill::PasswordForm;
 
 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);
   }
   return ret;
 }
 
 namespace {
 
 // Convenience enum for interacting with SQL queries that use all the columns.
 enum LoginTableColumns {
@@ skipping 33 matching lines @@
   s->BindBlob(COLUMN_PASSWORD_VALUE, encrypted_password.data(),
               static_cast<int>(encrypted_password.length()));
   s->BindString16(COLUMN_SUBMIT_ELEMENT, form.submit_element);
   s->BindString(COLUMN_SIGNON_REALM, form.signon_realm);
   s->BindInt(COLUMN_SSL_VALID, form.ssl_valid);
   s->BindInt(COLUMN_PREFERRED, form.preferred);
   s->BindInt64(COLUMN_DATE_CREATED, form.date_created.ToInternalValue());
   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(),
               form_data_pickle.size());
   s->BindInt64(COLUMN_DATE_SYNCED, form.date_synced.ToInternalValue());
   s->BindString16(COLUMN_DISPLAY_NAME, form.display_name);
   s->BindString(COLUMN_AVATAR_URL, form.avatar_url.spec());
   s->BindString(COLUMN_FEDERATION_URL, form.federation_url.spec());
   s->BindInt(COLUMN_SKIP_ZERO_CLICK, form.skip_zero_click);
   s->BindInt(COLUMN_GENERATION_UPLOAD_STATUS, form.generation_upload_status);
@@ skipping 488 matching lines @@
                                           "WHERE origin_url = ? AND "
                                           "username_element = ? AND "
                                           "username_value = ? AND "
                                           "password_element = ? AND "
                                           "signon_realm = ?"));
   s.BindString(0, form.action.spec());
   s.BindBlob(1, encrypted_password.data(),
              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);
   s.BindInt64(7, form.date_synced.ToInternalValue());
   s.BindInt64(8, form.date_created.ToInternalValue());
   s.BindInt(9, form.blacklisted_by_user);
   s.BindInt(10, form.scheme);
   s.BindInt(11, form.type);
   s.BindString16(12, form.display_name);
   s.BindString(13, form.avatar_url.spec());
@@ skipping 96 matching lines @@
   form->date_created =
       base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_CREATED));
   form->blacklisted_by_user = (s.ColumnInt(COLUMN_BLACKLISTED_BY_USER) > 0);
   int scheme_int = s.ColumnInt(COLUMN_SCHEME);
   DCHECK((scheme_int >= 0) && (scheme_int <= PasswordForm::SCHEME_OTHER));
   form->scheme = static_cast<PasswordForm::Scheme>(scheme_int);
   int type_int = s.ColumnInt(COLUMN_PASSWORD_TYPE);
   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 =
         success ? metrics_util::LOGIN_DATABASE_SUCCESS
                 : metrics_util::LOGIN_DATABASE_FAILURE;
     metrics_util::LogFormDataDeserializationStatus(status);
   }
   form->date_synced =
       base::Time::FromInternalValue(s.ColumnInt64(COLUMN_DATE_SYNCED));
   form->display_name = s.ColumnString16(COLUMN_DISPLAY_NAME);
@@ skipping 201 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("PasswordManager.PslDomainMatchTriggering",
                               psl_domain_match_metric, PSL_DOMAIN_MATCH_COUNT);
   }
 
   if (!statement->Succeeded())
     return false;
   return true;
 }
 
 }  // namespace password_manager