Rename card 'type' into 'issuer network.'

components/autofill/core/browser/webdata/autofill_table.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/autofill/core/browser/webdata/autofill_table.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <cmath>
@@ skipping 27 matching lines @@
 #include "components/autofill/core/common/form_field_data.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/protocol/entity_metadata.pb.h"
 #include "components/sync/protocol/model_type_state.pb.h"
 #include "components/webdata/common/web_database.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
-using base::ASCIIToUTF16;
-using base::Time;
-using base::TimeDelta;
-
 namespace autofill {
 namespace {
 
+using ::base::ASCIIToUTF16;
+using ::base::Time;
+using ::base::TimeDelta;

[Peter Kasting, 2017/04/26 01:27:28]

Nit: Any particular reason to move these?

(I'd love to see us just nuke these if it doesn't blow up the code below too
badly, but this is already a huge CL.)

[please use gerrit instead, 2017/04/26 16:34:15]

There's a wealth of explanations in go/totw/119. The gist is: "Declare namespace
aliases and using-declarations inside your own namespace."
Nuking works for me, because the benefit of not typing "base::" is too small.
This patch is already ~1k lines, so adding a couple extra lines does not affect
it much.

+
 // The period after which autocomplete entries should expire in days.
 const int64_t kExpirationPeriodInDays = 60;
 
 // Helper struct for AutofillTable::RemoveFormElementsAddedBetween().
 // Contains all the necessary fields to update a row in the 'autofill' table.
 struct AutofillUpdate {
   base::string16 name;
   base::string16 value;
   time_t date_created;
   time_t date_last_used;
@@ skipping 156 matching lines @@
     profile->SetRawInfo(NAME_LAST, s.ColumnString16(3));
     profile->SetRawInfo(NAME_FULL, s.ColumnString16(4));
   }
   return s.Succeeded();
 }
 
 bool AddAutofillProfileEmailsToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   // TODO(estade): update schema so that multiple emails are not associated per
   // unique profile guid. Please refer https://crbug.com/497934.
-  sql::Statement s(db->GetUniqueStatement(
-      "SELECT guid, email "
-      "FROM autofill_profile_emails "
-      "WHERE guid=?"
-      "LIMIT 1"));
+  sql::Statement s(
+      db->GetUniqueStatement("SELECT guid, email "
+                             "FROM autofill_profile_emails "
+                             "WHERE guid=?"
+                             "LIMIT 1"));
   s.BindString(0, profile->guid());
 
   if (!s.is_valid())
     return false;
 
   if (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     profile->SetRawInfo(EMAIL_ADDRESS, s.ColumnString16(1));
   }
   return s.Succeeded();
 }
 
 bool AddAutofillProfilePhonesToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   // TODO(estade): update schema so that multiple phone numbers are not
   // associated per unique profile guid. Please refer https://crbug.com/497934.
-  sql::Statement s(db->GetUniqueStatement(
-      "SELECT guid, number "
-      "FROM autofill_profile_phones "
-      "WHERE guid=?"
-      "LIMIT 1"));
+  sql::Statement s(
+      db->GetUniqueStatement("SELECT guid, number "
+                             "FROM autofill_profile_phones "
+                             "WHERE guid=?"
+                             "LIMIT 1"));
   s.BindString(0, profile->guid());
 
   if (!s.is_valid())
     return false;
 
   if (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     profile->SetRawInfo(PHONE_HOME_WHOLE_NUMBER, s.ColumnString16(1));
   }
   return s.Succeeded();
@@ skipping 11 matching lines @@
   s.BindString16(2, profile.GetRawInfo(NAME_MIDDLE));
   s.BindString16(3, profile.GetRawInfo(NAME_LAST));
   s.BindString16(4, profile.GetRawInfo(NAME_FULL));
 
   return s.Run();
 }
 
 bool AddAutofillProfileEmails(const AutofillProfile& profile,
                               sql::Connection* db) {
   // Add the new email.
-  sql::Statement s(db->GetUniqueStatement(
-      "INSERT INTO autofill_profile_emails"
-      " (guid, email) "
-      "VALUES (?,?)"));
+  sql::Statement s(
+      db->GetUniqueStatement("INSERT INTO autofill_profile_emails"
+                             " (guid, email) "
+                             "VALUES (?,?)"));
   s.BindString(0, profile.guid());
   s.BindString16(1, profile.GetRawInfo(EMAIL_ADDRESS));
 
   return s.Run();
 }
 
 bool AddAutofillProfilePhones(const AutofillProfile& profile,
                               sql::Connection* db) {
   // Add the new number.
-  sql::Statement s(db->GetUniqueStatement(
-      "INSERT INTO autofill_profile_phones"
-      " (guid, number) "
-      "VALUES (?,?)"));
+  sql::Statement s(
+      db->GetUniqueStatement("INSERT INTO autofill_profile_phones"
+                             " (guid, number) "
+                             "VALUES (?,?)"));
   s.BindString(0, profile.guid());
   s.BindString16(1, profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER));
 
   return s.Run();
 }
 
 bool AddAutofillProfilePieces(const AutofillProfile& profile,
                               sql::Connection* db) {
   if (!AddAutofillProfileNames(profile, db))
     return false;
@@ skipping 90 matching lines @@
 
 // static
 const size_t AutofillTable::kMaxDataLength = 1024;
 
 AutofillTable::AutofillTable()
     : autofill_table_encryptor_(
           AutofillTableEncryptorFactory::GetInstance()->Create()) {
   DCHECK(autofill_table_encryptor_);
 }
 
-AutofillTable::~AutofillTable() {
-}
+AutofillTable::~AutofillTable() {}
 
 AutofillTable* AutofillTable::FromWebDatabase(WebDatabase* db) {
   return static_cast<AutofillTable*>(db->GetTable(GetKey()));
 }
 
 WebDatabaseTable::TypeKey AutofillTable::GetTypeKey() const {
   return GetKey();
 }
 
 bool AutofillTable::CreateTablesIfNecessary() {
@@ skipping 49 matching lines @@
       return MigrateToVersion66AddCardBillingAddress();
     case 67:
       *update_compatible_version = false;
       return MigrateToVersion67AddMaskedCardBillingAddress();
     case 70:
       *update_compatible_version = false;
       return MigrateToVersion70AddSyncMetadata();
     case 71:
       *update_compatible_version = true;
       return MigrateToVersion71AddHasConvertedAndBillingAddressIdMetadata();
+    case 72:
+      *update_compatible_version = false;

[Peter Kasting, 2017/04/26 01:27:28]

Wait, shouldn't this be true?

[please use gerrit instead, 2017/04/26 16:34:15]

Is there any documentation to read up on why this should be true or false?
There're 5 "true" and 9 "false" the switch statement. I chose the more commonly
used.

[Peter Kasting, 2017/04/26 17:47:56]

You need to set this to true iff you need to bump the compatible version number
-- that is, if you're changing the "compatible version" constant.

The "compatible version" is for forward compatibility -- it basically says "the
current database version is safe to read and use by code that only understands
version X".  So if Chrome 50 is built to work with version 70, and Chrome 51 is
built to work with version 71, but marks the compatible version as 70, then if
you run a profile from Chrome 51 on Chrome 50, it will happily use it.  If you
mark the compatible version here as 71, then Chrome 50 will complain that it
can't open the profile, since it's from a newer version.

Basically, it's safe to leave the compatible version alone if you're adding an
optional column to the DB, but it needs to be bumped if you're removing columns,
adding mandatory columns, or renaming things.

In this case, you're making a change that will break previous versions if they
try to read your DB, so you do need to bump the compatible version.

+      return MigrateToVersion72RenameCardTypeToIssuerNetwork();
   }
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, AutofillClock::Now());
 }
 
 bool AutofillTable::AddFormFieldValue(const FormFieldData& element,
                                       std::vector<AutofillChange>* changes) {
   return AddFormFieldValueTime(element, changes, AutofillClock::Now());
 }
 
 bool AutofillTable::GetFormValuesForElementName(
     const base::string16& name,
     const base::string16& prefix,
     std::vector<base::string16>* values,
     int limit) {
   DCHECK(values);
   bool succeeded = false;
 
   if (prefix.empty()) {
     sql::Statement s;
-    s.Assign(db_->GetUniqueStatement(
-        "SELECT value FROM autofill "
-        "WHERE name = ? "
-        "ORDER BY count DESC "
-        "LIMIT ?"));
+    s.Assign(
+        db_->GetUniqueStatement("SELECT value FROM autofill "
+                                "WHERE name = ? "
+                                "ORDER BY count DESC "
+                                "LIMIT ?"));
     s.BindString16(0, name);
     s.BindInt(1, limit);
 
     values->clear();
     while (s.Step())
       values->push_back(s.ColumnString16(0));
 
     succeeded = s.Succeeded();
   } else {
     base::string16 prefix_lower = base::i18n::ToLower(prefix);
     base::string16 next_prefix = prefix_lower;
     next_prefix.back()++;
 
     sql::Statement s1;
-    s1.Assign(db_->GetUniqueStatement(
-        "SELECT value FROM autofill "
-        "WHERE name = ? AND "
-        "value_lower >= ? AND "
-        "value_lower < ? "
-        "ORDER BY count DESC "
-        "LIMIT ?"));
+    s1.Assign(
+        db_->GetUniqueStatement("SELECT value FROM autofill "
+                                "WHERE name = ? AND "
+                                "value_lower >= ? AND "
+                                "value_lower < ? "
+                                "ORDER BY count DESC "
+                                "LIMIT ?"));
     s1.BindString16(0, name);
     s1.BindString16(1, prefix_lower);
     s1.BindString16(2, next_prefix);
     s1.BindInt(3, limit);
 
     values->clear();
     while (s1.Step())
       values->push_back(s1.ColumnString16(0));
 
     succeeded = s1.Succeeded();
@@ skipping 75 matching lines @@
       //   count_new = 1 + (date_last_used_new - date_created_new) / avg_delta
       //             = 1 + ((count - 1) *
       //                    (date_last_used_new - date_created_new) /
       //                    (date_last_used_orig - date_created_orig))
       // Interpolating might not give a result that completely accurately
       // reflects the user's history, but it's the best that can be done given
       // the information in the database.
       AutofillUpdate updated_entry;
       updated_entry.name = name;
       updated_entry.value = value;
-      updated_entry.date_created =
-          date_created_time_t < delete_begin_time_t ?
-          date_created_time_t :
-          delete_end_time_t;
-      updated_entry.date_last_used =
-          date_last_used_time_t >= delete_end_time_t ?
-          date_last_used_time_t :
-          delete_begin_time_t - 1;
+      updated_entry.date_created = date_created_time_t < delete_begin_time_t
+                                       ? date_created_time_t
+                                       : delete_end_time_t;
+      updated_entry.date_last_used = date_last_used_time_t >= delete_end_time_t
+                                         ? date_last_used_time_t
+                                         : delete_begin_time_t - 1;
       updated_entry.count =
           1 +
           Round(1.0 * (count - 1) *
                 (updated_entry.date_last_used - updated_entry.date_created) /
                 (date_last_used_time_t - date_created_time_t));
       updates.push_back(updated_entry);
     }
 
     tentative_changes.push_back(
         AutofillChange(change_type, AutofillKey(name, value)));
   }
   if (!s.Succeeded())
     return false;
 
   // As a single transaction, remove or update the elements appropriately.
   sql::Statement s_delete(db_->GetUniqueStatement(
       "DELETE FROM autofill WHERE date_created >= ? AND date_last_used < ?"));
   s_delete.BindInt64(0, delete_begin_time_t);
   s_delete.BindInt64(1, delete_end_time_t);
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
   if (!s_delete.Run())
     return false;
   for (size_t i = 0; i < updates.size(); ++i) {
     sql::Statement s_update(db_->GetUniqueStatement(
-      "UPDATE autofill SET date_created = ?, date_last_used = ?, count = ?"
-      "WHERE name = ? AND value = ?"));
+        "UPDATE autofill SET date_created = ?, date_last_used = ?, count = ?"
+        "WHERE name = ? AND value = ?"));
     s_update.BindInt64(0, updates[i].date_created);
     s_update.BindInt64(1, updates[i].date_last_used);
     s_update.BindInt(2, updates[i].count);
     s_update.BindString16(3, updates[i].name);
     s_update.BindString16(4, updates[i].value);
     if (!s_update.Run())
       return false;
   }
   if (!transaction.Commit())
     return false;
@@ skipping 16 matching lines @@
   while (select_for_delete.Step()) {
     base::string16 name = select_for_delete.ColumnString16(0);
     base::string16 value = select_for_delete.ColumnString16(1);
     tentative_changes.push_back(
         AutofillChange(AutofillChange::REMOVE, AutofillKey(name, value)));
   }
 
   if (!select_for_delete.Succeeded())
     return false;
 
-  sql::Statement delete_data_statement(db_->GetUniqueStatement(
-      "DELETE FROM autofill WHERE date_last_used < ?"));
+  sql::Statement delete_data_statement(
+      db_->GetUniqueStatement("DELETE FROM autofill WHERE date_last_used < ?"));
   delete_data_statement.BindInt64(0, expiration_time.ToTimeT());
   if (!delete_data_statement.Run())
     return false;
 
   *changes = tentative_changes;
   return true;
 }
 
 bool AutofillTable::AddFormFieldValuesTime(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes,
     Time time) {
   // Only add one new entry for each unique element name.  Use |seen_names| to
   // track this.  Add up to |kMaximumUniqueNames| unique entries per form.
   const size_t kMaximumUniqueNames = 256;
   std::set<base::string16> seen_names;
   bool result = true;
   for (const FormFieldData& element : elements) {
     if (seen_names.size() >= kMaximumUniqueNames)
       break;
     if (base::ContainsKey(seen_names, element.name))
       continue;
     result = result && AddFormFieldValueTime(element, changes, time);
     seen_names.insert(element.name);
   }
   return result;
 }
 
-int AutofillTable::GetCountOfValuesContainedBetween(
-    const Time& begin,
-    const Time& end) {
+int AutofillTable::GetCountOfValuesContainedBetween(const Time& begin,
+                                                    const Time& end) {
   const time_t begin_time_t = begin.ToTimeT();
   const time_t end_time_t = GetEndTime(end);
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT COUNT(DISTINCT(value1)) FROM ( "
       "  SELECT value AS value1 FROM autofill "
       "  WHERE NOT EXISTS ( "
       "    SELECT value AS value2, date_created, date_last_used FROM autofill "
       "    WHERE value1 = value2 AND "
       "          (date_created < ? OR date_last_used >= ?)))"));
@@ skipping 121 matching lines @@
       return false;
   }
 
   AutofillChange::Type change_type =
       already_exists ? AutofillChange::UPDATE : AutofillChange::ADD;
   changes->push_back(
       AutofillChange(change_type, AutofillKey(element.name, element.value)));
   return true;
 }
 
-
 bool AutofillTable::RemoveFormElement(const base::string16& name,
                                       const base::string16& value) {
   sql::Statement s(db_->GetUniqueStatement(
       "DELETE FROM autofill WHERE name = ? AND value= ?"));
   s.BindString16(0, name);
   s.BindString16(1, value);
   return s.Run();
 }
 
 bool AutofillTable::AddAutofillProfile(const AutofillProfile& profile) {
@@ skipping 41 matching lines @@
   AddAutofillProfilePhonesToProfile(db_, p.get());
 
   return p;
 }
 
 bool AutofillTable::GetAutofillProfiles(
     std::vector<std::unique_ptr<AutofillProfile>>* profiles) {
   DCHECK(profiles);
   profiles->clear();
 
-  sql::Statement s(db_->GetUniqueStatement(
-      "SELECT guid "
-      "FROM autofill_profiles "
-      "ORDER BY date_modified DESC, guid"));
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT guid "
+                              "FROM autofill_profiles "
+                              "ORDER BY date_modified DESC, guid"));
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     std::unique_ptr<AutofillProfile> profile = GetAutofillProfile(guid);
     if (!profile)
       return false;
     profiles->push_back(std::move(profile));
   }
 
   return s.Succeeded();
@@ skipping 63 matching lines @@
   return s.Succeeded();
 }
 
 void AutofillTable::SetServerProfiles(
     const std::vector<AutofillProfile>& profiles) {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return;
 
   // Delete all old ones first.
-  sql::Statement delete_old(db_->GetUniqueStatement(
-      "DELETE FROM server_addresses"));
+  sql::Statement delete_old(
+      db_->GetUniqueStatement("DELETE FROM server_addresses"));
   delete_old.Run();
 
   sql::Statement insert(db_->GetUniqueStatement(
       "INSERT INTO server_addresses("
-        "id,"
-        "recipient_name,"
-        "company_name,"
-        "street_address,"
-        "address_1,"  // ADDRESS_HOME_STATE
-        "address_2,"  // ADDRESS_HOME_CITY
-        "address_3,"  // ADDRESS_HOME_DEPENDENT_LOCALITY
-        "address_4,"  // Not supported in AutofillProfile yet.
-        "postal_code,"  // ADDRESS_HOME_ZIP
-        "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
-        "country_code,"  // ADDRESS_HOME_COUNTRY
-        "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
-        "language_code) "
+      "id,"
+      "recipient_name,"
+      "company_name,"
+      "street_address,"
+      "address_1,"     // ADDRESS_HOME_STATE
+      "address_2,"     // ADDRESS_HOME_CITY
+      "address_3,"     // ADDRESS_HOME_DEPENDENT_LOCALITY
+      "address_4,"     // Not supported in AutofillProfile yet.
+      "postal_code,"   // ADDRESS_HOME_ZIP
+      "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
+      "country_code,"  // ADDRESS_HOME_COUNTRY
+      "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
+      "language_code) "
       "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)"));
   for (const auto& profile : profiles) {
     DCHECK(profile.record_type() == AutofillProfile::SERVER_PROFILE);
 
     int index = 0;
     insert.BindString(index++, profile.server_id());
     insert.BindString16(index++, profile.GetRawInfo(NAME_FULL));
     insert.BindString16(index++, profile.GetRawInfo(COMPANY_NAME));
     insert.BindString16(index++,
                         profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
@@ skipping 11 matching lines @@
     insert.Run();
     insert.Reset(true);
 
     // Save the use count and use date of the profile.
     UpdateServerAddressMetadata(profile);
   }
 
   // Delete metadata that's no longer relevant.
   sql::Statement metadata_delete(db_->GetUniqueStatement(
       "DELETE FROM server_address_metadata WHERE id NOT IN "
-          "(SELECT id FROM server_addresses)"));
+      "(SELECT id FROM server_addresses)"));
   metadata_delete.Run();
 
   transaction.Commit();
 }
 
 bool AutofillTable::UpdateAutofillProfile(const AutofillProfile& profile) {
   DCHECK(base::IsValidGUID(profile.guid()));
 
   // Don't update anything until the trash has been emptied.  There may be
   // pending modifications to process.
@@ skipping 38 matching lines @@
   if (IsAutofillGUIDInTrash(guid)) {
     sql::Statement s_trash(db_->GetUniqueStatement(
         "DELETE FROM autofill_profiles_trash WHERE guid = ?"));
     s_trash.BindString(0, guid);
 
     bool success = s_trash.Run();
     DCHECK_GT(db_->GetLastChangeCount(), 0) << "Expected item in trash";
     return success;
   }
 
-  sql::Statement s(db_->GetUniqueStatement(
-      "DELETE FROM autofill_profiles WHERE guid = ?"));
+  sql::Statement s(
+      db_->GetUniqueStatement("DELETE FROM autofill_profiles WHERE guid = ?"));
   s.BindString(0, guid);
 
   if (!s.Run())
     return false;
 
   return RemoveAutofillProfilePieces(guid, db_);
 }
 
 bool AutofillTable::ClearAutofillProfiles() {
-  sql::Statement s1(db_->GetUniqueStatement(
-      "DELETE FROM autofill_profiles"));
+  sql::Statement s1(db_->GetUniqueStatement("DELETE FROM autofill_profiles"));
 
   if (!s1.Run())
     return false;
 
-  sql::Statement s2(db_->GetUniqueStatement(
-      "DELETE FROM autofill_profile_names"));
+  sql::Statement s2(
+      db_->GetUniqueStatement("DELETE FROM autofill_profile_names"));
 
   if (!s2.Run())
     return false;
 
-  sql::Statement s3(db_->GetUniqueStatement(
-      "DELETE FROM autofill_profile_emails"));
+  sql::Statement s3(
+      db_->GetUniqueStatement("DELETE FROM autofill_profile_emails"));
 
   if (!s3.Run())
     return false;
 
-  sql::Statement s4(db_->GetUniqueStatement(
-      "DELETE FROM autofill_profile_phones"));
+  sql::Statement s4(
+      db_->GetUniqueStatement("DELETE FROM autofill_profile_phones"));
 
   return s4.Run();
 }
 
 bool AutofillTable::AddCreditCard(const CreditCard& credit_card) {
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO credit_cards"
       "(guid, name_on_card, expiration_month, expiration_year, "
       " card_number_encrypted, use_count, use_date, date_modified, origin,"
       " billing_address_id)"
       "VALUES (?,?,?,?,?,?,?,?,?,?)"));
   BindCreditCardToStatement(credit_card, AutofillClock::Now(), &s,
                             *autofill_table_encryptor_);
 
   if (!s.Run())
     return false;
 
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return true;
 }
 
 std::unique_ptr<CreditCard> AutofillTable::GetCreditCard(
     const std::string& guid) {
   DCHECK(base::IsValidGUID(guid));
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, name_on_card, expiration_month, expiration_year, "
-             "card_number_encrypted, use_count, use_date, date_modified, "
-             "origin, billing_address_id "
+      "card_number_encrypted, use_count, use_date, date_modified, "
+      "origin, billing_address_id "
       "FROM credit_cards "
       "WHERE guid = ?"));
   s.BindString(0, guid);
 
   if (!s.Step())
     return std::unique_ptr<CreditCard>();
 
   return CreditCardFromStatement(s, *autofill_table_encryptor_);
 }
 
 bool AutofillTable::GetCreditCards(
     std::vector<std::unique_ptr<CreditCard>>* credit_cards) {
   DCHECK(credit_cards);
   credit_cards->clear();
 
-  sql::Statement s(db_->GetUniqueStatement(
-      "SELECT guid "
-      "FROM credit_cards "
-      "ORDER BY date_modified DESC, guid"));
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT guid "
+                              "FROM credit_cards "
+                              "ORDER BY date_modified DESC, guid"));
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     std::unique_ptr<CreditCard> credit_card = GetCreditCard(guid);
     if (!credit_card)
       return false;
     credit_cards->push_back(std::move(credit_card));
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::GetServerCreditCards(
     std::vector<std::unique_ptr<CreditCard>>* credit_cards) const {
   credit_cards->clear();
 
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT "
       "card_number_encrypted, "       // 0
       "last_four,"                    // 1
       "masked.id,"                    // 2
       "metadata.use_count,"           // 3
       "metadata.use_date,"            // 4
-      "type,"                         // 5
+      "network,"                      // 5
       "status,"                       // 6
       "name_on_card,"                 // 7
       "exp_month,"                    // 8
       "exp_year,"                     // 9
       "metadata.billing_address_id "  // 10
       "FROM masked_credit_cards masked "
       "LEFT OUTER JOIN unmasked_credit_cards USING (id) "
       "LEFT OUTER JOIN server_card_metadata metadata USING (id)"));
   while (s.Step()) {
     int index = 0;
 
     // If the card_number_encrypted field is nonempty, we can assume this card
     // is a full card, otherwise it's masked.
     base::string16 full_card_number =
         UnencryptedCardFromColumn(s, index++, *autofill_table_encryptor_);
     base::string16 last_four = s.ColumnString16(index++);
-    CreditCard::RecordType record_type = full_card_number.empty() ?
-        CreditCard::MASKED_SERVER_CARD :
-        CreditCard::FULL_SERVER_CARD;
+    CreditCard::RecordType record_type = full_card_number.empty()
+                                             ? CreditCard::MASKED_SERVER_CARD
+                                             : CreditCard::FULL_SERVER_CARD;
     std::string server_id = s.ColumnString(index++);
     std::unique_ptr<CreditCard> card =
         base::MakeUnique<CreditCard>(record_type, server_id);
-    card->SetRawInfo(
-        CREDIT_CARD_NUMBER,
-        record_type == CreditCard::MASKED_SERVER_CARD ? last_four
-                                                      : full_card_number);
+    card->SetRawInfo(CREDIT_CARD_NUMBER,
+                     record_type == CreditCard::MASKED_SERVER_CARD
+                         ? last_four
+                         : full_card_number);
     card->set_use_count(s.ColumnInt64(index++));
     card->set_use_date(Time::FromInternalValue(s.ColumnInt64(index++)));
     // Modification date is not tracked for server cards. Explicitly set it here
     // to override the default value of AutofillClock::Now().
     card->set_modification_date(Time());
 
-    std::string card_type = s.ColumnString(index++);
+    std::string card_network = s.ColumnString(index++);
     if (record_type == CreditCard::MASKED_SERVER_CARD) {
-      // The type must be set after setting the number to override the
-      // autodetected type.
-      card->SetTypeForMaskedCard(card_type.c_str());
+      // The issuer network must be set after setting the number to override the
+      // autodetected issuer network.
+      card->SetNetworkForMaskedCard(card_network.c_str());
     } else {
-      DCHECK_EQ(CreditCard::GetCreditCardType(full_card_number), card_type);
+      DCHECK_EQ(CreditCard::GetCardNetwork(full_card_number), card_network);
     }
 
     card->SetServerStatus(ServerStatusStringToEnum(s.ColumnString(index++)));
     card->SetRawInfo(CREDIT_CARD_NAME_FULL, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_MONTH, s.ColumnString16(index++));
     card->SetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR, s.ColumnString16(index++));
     card->set_billing_address_id(s.ColumnString(index++));
     credit_cards->push_back(std::move(card));
   }
   return s.Succeeded();
 }
 
 void AutofillTable::AddMaskedCreditCards(
     const std::vector<CreditCard>& credit_cards) {
   DCHECK_GT(db_->transaction_nesting(), 0);
   sql::Statement masked_insert(
       db_->GetUniqueStatement("INSERT INTO masked_credit_cards("
                               "id,"            // 0
-                              "type,"          // 1
+                              "network,"       // 1
                               "status,"        // 2
                               "name_on_card,"  // 3
                               "last_four,"     // 4
                               "exp_month,"     // 5
                               "exp_year)"      // 6
                               "VALUES (?,?,?,?,?,?,?)"));
   for (const CreditCard& card : credit_cards) {
     DCHECK_EQ(CreditCard::MASKED_SERVER_CARD, card.record_type());
     masked_insert.BindString(0, card.server_id());
-    masked_insert.BindString(1, card.type());
+    masked_insert.BindString(1, card.network());
     masked_insert.BindString(2,
                              ServerStatusEnumToString(card.GetServerStatus()));
     masked_insert.BindString16(3, card.GetRawInfo(CREDIT_CARD_NAME_FULL));
     masked_insert.BindString16(4, card.LastFourDigits());
     masked_insert.BindString16(5, card.GetRawInfo(CREDIT_CARD_EXP_MONTH));
     masked_insert.BindString16(6,
                                card.GetRawInfo(CREDIT_CARD_EXP_4_DIGIT_YEAR));
 
     masked_insert.Run();
     masked_insert.Reset(true);
@@ skipping 12 matching lines @@
   // Delete all old values.
   sql::Statement masked_delete(
       db_->GetUniqueStatement("DELETE FROM masked_credit_cards"));
   masked_delete.Run();
 
   AddMaskedCreditCards(credit_cards);
 
   // Delete all items in the unmasked table that aren't in the new set.
   sql::Statement unmasked_delete(db_->GetUniqueStatement(
       "DELETE FROM unmasked_credit_cards WHERE id NOT IN "
-          "(SELECT id FROM masked_credit_cards)"));
+      "(SELECT id FROM masked_credit_cards)"));
   unmasked_delete.Run();
   // Do the same for metadata.
   sql::Statement metadata_delete(db_->GetUniqueStatement(
       "DELETE FROM server_card_metadata WHERE id NOT IN "
-          "(SELECT id FROM masked_credit_cards)"));
+      "(SELECT id FROM masked_credit_cards)"));
   metadata_delete.Run();
 
   transaction.Commit();
 }
 
 bool AutofillTable::AddFullServerCreditCard(const CreditCard& credit_card) {
   DCHECK_EQ(CreditCard::FULL_SERVER_CARD, credit_card.record_type());
   DCHECK(!credit_card.number().empty());
   DCHECK(!credit_card.server_id().empty());
 
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
 
   // Make sure there aren't duplicates for this card.
   DeleteFromUnmaskedCreditCards(credit_card.server_id());
   DeleteFromMaskedCreditCards(credit_card.server_id());
 
   CreditCard masked(credit_card);
   masked.set_record_type(CreditCard::MASKED_SERVER_CARD);
   masked.SetNumber(credit_card.LastFourDigits());
   masked.RecordAndLogUse();
-  DCHECK(!masked.type().empty());
+  DCHECK(!masked.network().empty());
   AddMaskedCreditCards({masked});
 
   AddUnmaskedCreditCard(credit_card.server_id(), credit_card.number());
 
   transaction.Commit();
 
   return db_->GetLastChangeCount() > 0;
 }
 
 void AutofillTable::AddUnmaskedCreditCard(const std::string& id,
@@ skipping 53 matching lines @@
   return db_->GetLastChangeCount() > 0;
 }
 
 bool AutofillTable::MaskServerCreditCard(const std::string& id) {
   return DeleteFromUnmaskedCreditCards(id);
 }
 
 bool AutofillTable::UpdateServerCardMetadata(const CreditCard& credit_card) {
   DCHECK_NE(CreditCard::LOCAL_CARD, credit_card.record_type());
 
-  sql::Statement remove(db_->GetUniqueStatement(
-      "DELETE FROM server_card_metadata WHERE id = ?"));
+  sql::Statement remove(
+      db_->GetUniqueStatement("DELETE FROM server_card_metadata WHERE id = ?"));
   remove.BindString(0, credit_card.server_id());
   remove.Run();
 
   sql::Statement s(
       db_->GetUniqueStatement("INSERT INTO server_card_metadata(use_count, "
                               "use_date, billing_address_id, id)"
                               "VALUES (?,?,?,?)"));
   s.BindInt64(0, credit_card.use_count());
   s.BindInt64(1, credit_card.use_date().ToInternalValue());
   s.BindString(2, credit_card.billing_address_id());
@@ skipping 31 matching lines @@
   transaction.Commit();
 
   return db_->GetLastChangeCount() > 0;
 }
 
 bool AutofillTable::ClearAllServerData() {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;  // Some error, nothing was changed.
 
-  sql::Statement masked(db_->GetUniqueStatement(
-      "DELETE FROM masked_credit_cards"));
+  sql::Statement masked(
+      db_->GetUniqueStatement("DELETE FROM masked_credit_cards"));
   masked.Run();
   bool changed = db_->GetLastChangeCount() > 0;
 
-  sql::Statement unmasked(db_->GetUniqueStatement(
-      "DELETE FROM unmasked_credit_cards"));
+  sql::Statement unmasked(
+      db_->GetUniqueStatement("DELETE FROM unmasked_credit_cards"));
   unmasked.Run();
   changed |= db_->GetLastChangeCount() > 0;
 
-  sql::Statement addresses(db_->GetUniqueStatement(
-      "DELETE FROM server_addresses"));
+  sql::Statement addresses(
+      db_->GetUniqueStatement("DELETE FROM server_addresses"));
   addresses.Run();
   changed |= db_->GetLastChangeCount() > 0;
 
-  sql::Statement card_metadata(db_->GetUniqueStatement(
-      "DELETE FROM server_card_metadata"));
+  sql::Statement card_metadata(
+      db_->GetUniqueStatement("DELETE FROM server_card_metadata"));
   card_metadata.Run();
   changed |= db_->GetLastChangeCount() > 0;
 
-  sql::Statement address_metadata(db_->GetUniqueStatement(
-      "DELETE FROM server_address_metadata"));
+  sql::Statement address_metadata(
+      db_->GetUniqueStatement("DELETE FROM server_address_metadata"));
   address_metadata.Run();
   changed |= db_->GetLastChangeCount() > 0;
 
   transaction.Commit();
   return changed;
 }
 
 bool AutofillTable::UpdateCreditCard(const CreditCard& credit_card) {
   DCHECK(base::IsValidGUID(credit_card.guid()));
 
   std::unique_ptr<CreditCard> old_credit_card =
       GetCreditCard(credit_card.guid());
   if (!old_credit_card)
     return false;
 
   bool update_modification_date = *old_credit_card != credit_card;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE credit_cards "
       "SET guid=?, name_on_card=?, expiration_month=?,"
-          "expiration_year=?, card_number_encrypted=?, use_count=?, use_date=?,"
-          "date_modified=?, origin=?, billing_address_id=?"
+      "expiration_year=?, card_number_encrypted=?, use_count=?, use_date=?,"
+      "date_modified=?, origin=?, billing_address_id=?"
       "WHERE guid=?1"));
   BindCreditCardToStatement(credit_card,
                             update_modification_date
                                 ? AutofillClock::Now()
                                 : old_credit_card->modification_date(),
                             &s, *autofill_table_encryptor_);
 
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   return result;
 }
 
 bool AutofillTable::RemoveCreditCard(const std::string& guid) {
   DCHECK(base::IsValidGUID(guid));
-  sql::Statement s(db_->GetUniqueStatement(
-      "DELETE FROM credit_cards WHERE guid = ?"));
+  sql::Statement s(
+      db_->GetUniqueStatement("DELETE FROM credit_cards WHERE guid = ?"));
   s.BindString(0, guid);
 
   return s.Run();
 }
 
 bool AutofillTable::RemoveAutofillDataModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end,
     std::vector<std::string>* profile_guids,
     std::vector<std::string>* credit_card_guids) {
@@ skipping 45 matching lines @@
   // Remove Autofill credit cards in the time range.
   sql::Statement s_credit_cards(db_->GetUniqueStatement(
       "DELETE FROM credit_cards "
       "WHERE date_modified >= ? AND date_modified < ?"));
   s_credit_cards.BindInt64(0, delete_begin_t);
   s_credit_cards.BindInt64(1, delete_end_t);
   if (!s_credit_cards.Run())
     return false;
 
   // Remove unmasked credit cards in the time range.
-  sql::Statement s_unmasked_cards(db_->GetUniqueStatement(
-      "DELETE FROM unmasked_credit_cards "
-      "WHERE unmask_date >= ? AND unmask_date < ?"));
+  sql::Statement s_unmasked_cards(
+      db_->GetUniqueStatement("DELETE FROM unmasked_credit_cards "
+                              "WHERE unmask_date >= ? AND unmask_date < ?"));
   s_unmasked_cards.BindInt64(0, delete_begin.ToInternalValue());
   s_unmasked_cards.BindInt64(1, delete_end.ToInternalValue());
   return s_unmasked_cards.Run();
 }
 
 bool AutofillTable::RemoveOriginURLsModifiedBetween(
     const Time& delete_begin,
     const Time& delete_end,
     std::vector<std::unique_ptr<AutofillProfile>>* profiles) {
   DCHECK(delete_end.is_null() || delete_begin < delete_end);
@@ skipping 59 matching lines @@
       return false;
   }
 
   return true;
 }
 
 bool AutofillTable::GetAutofillProfilesInTrash(
     std::vector<std::string>* guids) {
   guids->clear();
 
-  sql::Statement s(db_->GetUniqueStatement(
-      "SELECT guid "
-      "FROM autofill_profiles_trash"));
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT guid "
+                              "FROM autofill_profiles_trash"));
 
   while (s.Step()) {
     std::string guid = s.ColumnString(0);
     guids->push_back(guid);
   }
 
   return s.Succeeded();
 }
 
 bool AutofillTable::EmptyAutofillProfilesTrash() {
-  sql::Statement s(db_->GetUniqueStatement(
-      "DELETE FROM autofill_profiles_trash"));
+  sql::Statement s(
+      db_->GetUniqueStatement("DELETE FROM autofill_profiles_trash"));
 
   return s.Run();
 }
 
-
 bool AutofillTable::AddAutofillGUIDToTrash(const std::string& guid) {
-  sql::Statement s(db_->GetUniqueStatement(
-    "INSERT INTO autofill_profiles_trash"
-    " (guid) "
-    "VALUES (?)"));
+  sql::Statement s(
+      db_->GetUniqueStatement("INSERT INTO autofill_profiles_trash"
+                              " (guid) "
+                              "VALUES (?)"));
   s.BindString(0, guid);
 
   return s.Run();
 }
 
 bool AutofillTable::IsAutofillProfilesTrashEmpty() {
-  sql::Statement s(db_->GetUniqueStatement(
-      "SELECT guid "
-      "FROM autofill_profiles_trash"));
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT guid "
+                              "FROM autofill_profiles_trash"));
 
   return !s.Step();
 }
 
 bool AutofillTable::IsAutofillGUIDInTrash(const std::string& guid) {
-  sql::Statement s(db_->GetUniqueStatement(
-      "SELECT guid "
-      "FROM autofill_profiles_trash "
-      "WHERE guid = ?"));
+  sql::Statement s(
+      db_->GetUniqueStatement("SELECT guid "
+                              "FROM autofill_profiles_trash "
+                              "WHERE guid = ?"));
   s.BindString(0, guid);
 
   return s.Step();
 }
 
 bool AutofillTable::GetAllSyncMetadata(syncer::ModelType model_type,
                                        syncer::MetadataBatch* metadata_batch) {
   DCHECK_EQ(model_type, syncer::AUTOFILL)
       << "Only the AUTOFILL model type is supported";
   DCHECK(metadata_batch);
@@ skipping 112 matching lines @@
                       "name VARCHAR, "
                       "value VARCHAR, "
                       "value_lower VARCHAR, "
                       "date_created INTEGER DEFAULT 0, "
                       "date_last_used INTEGER DEFAULT 0, "
                       "count INTEGER DEFAULT 1, "
                       "PRIMARY KEY (name, value))") ||
         !db_->Execute("CREATE INDEX autofill_name ON autofill (name)") ||
         !db_->Execute("CREATE INDEX autofill_name_value_lower ON "
                       "autofill (name, value_lower)")) {
-       NOTREACHED();
-       return false;
+      NOTREACHED();
+      return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitCreditCardsTable() {
   if (!db_->DoesTableExist("credit_cards")) {
     if (!db_->Execute("CREATE TABLE credit_cards ( "
                       "guid VARCHAR PRIMARY KEY, "
                       "name_on_card VARCHAR, "
@@ skipping 86 matching lines @@
   }
   return true;
 }
 
 bool AutofillTable::InitMaskedCreditCardsTable() {
   if (!db_->DoesTableExist("masked_credit_cards")) {
     if (!db_->Execute("CREATE TABLE masked_credit_cards ("
                       "id VARCHAR,"
                       "status VARCHAR,"
                       "name_on_card VARCHAR,"
-                      "type VARCHAR,"
+                      "network VARCHAR,"
                       "last_four VARCHAR,"
                       "exp_month INTEGER DEFAULT 0,"
                       "exp_year INTEGER DEFAULT 0)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
@@ skipping 34 matching lines @@
                       "id VARCHAR,"
                       "company_name VARCHAR,"
                       "street_address VARCHAR,"
                       "address_1 VARCHAR,"
                       "address_2 VARCHAR,"
                       "address_3 VARCHAR,"
                       "address_4 VARCHAR,"
                       "postal_code VARCHAR,"
                       "sorting_code VARCHAR,"
                       "country_code VARCHAR,"
-                      "language_code VARCHAR, "  // Space required.
+                      "language_code VARCHAR, "   // Space required.
                       "recipient_name VARCHAR, "  // Ditto.
                       "phone_number VARCHAR)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitServerAddressMetadataTable() {
@@ skipping 187 matching lines @@
     return false;
   }
 
   // Create indices on the new table, for fast lookups.
   if (!db_->Execute("CREATE INDEX autofill_name ON autofill (name)") ||
       !db_->Execute("CREATE INDEX autofill_name_value_lower ON "
                     "autofill (name, value_lower)")) {
     return false;
   }
 
-
   return transaction.Commit();
 }
 
 bool AutofillTable::MigrateToVersion56AddProfileLanguageCodeForFormatting() {
-  return db_->Execute("ALTER TABLE autofill_profiles "
-                      "ADD COLUMN language_code VARCHAR");
+  return db_->Execute(
+      "ALTER TABLE autofill_profiles "
+      "ADD COLUMN language_code VARCHAR");

[Peter Kasting, 2017/04/26 01:27:28]

Nit: This all fits on one line now (two places)

[please use gerrit instead, 2017/04/26 16:34:15]

Done.

 }
 
 bool AutofillTable::MigrateToVersion57AddFullNameField() {
-  return db_->Execute("ALTER TABLE autofill_profile_names "
-                      "ADD COLUMN full_name VARCHAR");
+  return db_->Execute(
+      "ALTER TABLE autofill_profile_names "
+      "ADD COLUMN full_name VARCHAR");
 }
 
 bool AutofillTable::MigrateToVersion60AddServerCards() {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
 
   if (!db_->DoesTableExist("masked_credit_cards") &&
       !db_->Execute("CREATE TABLE masked_credit_cards ("
                     "id VARCHAR,"
@@ skipping 143 matching lines @@
       !db_->Execute("CREATE TABLE server_address_metadata ("
                     "id VARCHAR NOT NULL,"
                     "use_count INTEGER NOT NULL DEFAULT 0, "
                     "use_date INTEGER NOT NULL DEFAULT 0)")) {
     return false;
   }
 
   // Get existing server addresses and generate IDs for them.
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT "
-        "id,"
-        "recipient_name,"
-        "company_name,"
-        "street_address,"
-        "address_1,"  // ADDRESS_HOME_STATE
-        "address_2,"  // ADDRESS_HOME_CITY
-        "address_3,"  // ADDRESS_HOME_DEPENDENT_LOCALITY
-        "address_4,"  // Not supported in AutofillProfile yet.
-        "postal_code,"  // ADDRESS_HOME_ZIP
-        "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
-        "country_code,"  // ADDRESS_HOME_COUNTRY
-        "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
-        "language_code "
+      "id,"
+      "recipient_name,"
+      "company_name,"
+      "street_address,"
+      "address_1,"     // ADDRESS_HOME_STATE
+      "address_2,"     // ADDRESS_HOME_CITY
+      "address_3,"     // ADDRESS_HOME_DEPENDENT_LOCALITY
+      "address_4,"     // Not supported in AutofillProfile yet.
+      "postal_code,"   // ADDRESS_HOME_ZIP
+      "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
+      "country_code,"  // ADDRESS_HOME_COUNTRY
+      "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
+      "language_code "
       "FROM server_addresses addresses"));
   std::vector<AutofillProfile> profiles;
   while (s.Step()) {
     int index = 0;
-    AutofillProfile profile(
-        AutofillProfile::SERVER_PROFILE, s.ColumnString(index++));
+    AutofillProfile profile(AutofillProfile::SERVER_PROFILE,
+                            s.ColumnString(index++));
 
     base::string16 recipient_name = s.ColumnString16(index++);
     profile.SetRawInfo(COMPANY_NAME, s.ColumnString16(index++));
     profile.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, s.ColumnString16(index++));
     profile.SetRawInfo(ADDRESS_HOME_STATE, s.ColumnString16(index++));
     profile.SetRawInfo(ADDRESS_HOME_CITY, s.ColumnString16(index++));
     profile.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
                        s.ColumnString16(index++));
     index++;  // Skip address_4 which we haven't added to AutofillProfile yet.
     profile.SetRawInfo(ADDRESS_HOME_ZIP, s.ColumnString16(index++));
     profile.SetRawInfo(ADDRESS_HOME_SORTING_CODE, s.ColumnString16(index++));
     profile.SetRawInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(index++));
     base::string16 phone_number = s.ColumnString16(index++);
     profile.set_language_code(s.ColumnString(index++));
     profile.SetInfo(AutofillType(NAME_FULL), recipient_name,
                     profile.language_code());
     profile.SetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), phone_number,
                     profile.language_code());
     profile.GenerateServerProfileIdentifier();
     profiles.push_back(profile);
   }
 
   // Reinsert with the generated IDs.
-  sql::Statement delete_old(db_->GetUniqueStatement(
-      "DELETE FROM server_addresses"));
+  sql::Statement delete_old(
+      db_->GetUniqueStatement("DELETE FROM server_addresses"));
   delete_old.Run();
 
   sql::Statement insert(db_->GetUniqueStatement(
       "INSERT INTO server_addresses("
-        "id,"
-        "recipient_name,"
-        "company_name,"
-        "street_address,"
-        "address_1,"  // ADDRESS_HOME_STATE
-        "address_2,"  // ADDRESS_HOME_CITY
-        "address_3,"  // ADDRESS_HOME_DEPENDENT_LOCALITY
-        "address_4,"  // Not supported in AutofillProfile yet.
-        "postal_code,"  // ADDRESS_HOME_ZIP
-        "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
-        "country_code,"  // ADDRESS_HOME_COUNTRY
-        "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
-        "language_code) "
+      "id,"
+      "recipient_name,"
+      "company_name,"
+      "street_address,"
+      "address_1,"     // ADDRESS_HOME_STATE
+      "address_2,"     // ADDRESS_HOME_CITY
+      "address_3,"     // ADDRESS_HOME_DEPENDENT_LOCALITY
+      "address_4,"     // Not supported in AutofillProfile yet.
+      "postal_code,"   // ADDRESS_HOME_ZIP
+      "sorting_code,"  // ADDRESS_HOME_SORTING_CODE
+      "country_code,"  // ADDRESS_HOME_COUNTRY
+      "phone_number,"  // PHONE_HOME_WHOLE_NUMBER
+      "language_code) "
       "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)"));
   for (const AutofillProfile& profile : profiles) {
     int index = 0;
     insert.BindString(index++, profile.server_id());
     insert.BindString16(index++, profile.GetRawInfo(NAME_FULL));
     insert.BindString16(index++, profile.GetRawInfo(COMPANY_NAME));
     insert.BindString16(index++,
                         profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
     insert.BindString16(index++, profile.GetRawInfo(ADDRESS_HOME_STATE));
     insert.BindString16(index++, profile.GetRawInfo(ADDRESS_HOME_CITY));
@@ skipping 92 matching lines @@
   // temporary table.
   if (!db_->Execute("DROP TABLE masked_credit_cards") ||
       !db_->Execute("ALTER TABLE masked_credit_cards_temp "
                     "RENAME TO masked_credit_cards")) {
     return false;
   }
 
   return transaction.Commit();
 }
 
+bool AutofillTable::MigrateToVersion72RenameCardTypeToIssuerNetwork() {
+  sql::Transaction transaction(db_);
+  if (!transaction.Begin())
+    return false;
+
+  if (db_->DoesTableExist("masked_credit_cards_temp") ||

[Peter Kasting, 2017/04/26 01:27:28]

It seems like if this table exists, it will block migration continuing forever. 
That sounds bad.  When would we expect this to exist?  Why would it not be wrong
to just blow it away?

It looks like the version 71 migration has this problem too.

[please use gerrit instead, 2017/04/26 16:34:15]

Good point. Fixed in both places.

+      !db_->Execute("CREATE TABLE masked_credit_cards_temp ("
+                    "id VARCHAR,"
+                    "status VARCHAR,"
+                    "name_on_card VARCHAR,"
+                    "network VARCHAR,"
+                    "last_four VARCHAR,"
+                    "exp_month INTEGER DEFAULT 0,"
+                    "exp_year INTEGER DEFAULT 0)")) {
+    return false;
+  }
+  if (!db_->Execute("INSERT INTO masked_credit_cards_temp "
+                    "(id, status, name_on_card, network, last_four, "
+                    "exp_month, exp_year) "
+                    "SELECT id, status, name_on_card, type, last_four, "
+                    "exp_month, exp_year "
+                    "FROM masked_credit_cards")) {
+    return false;
+  }
+  if (!db_->Execute("DROP TABLE masked_credit_cards"))
+    return false;
+  if (!db_->Execute("ALTER TABLE masked_credit_cards_temp "
+                    "RENAME TO masked_credit_cards")) {
+    return false;
+  }
+
+  return transaction.Commit();

[Peter Kasting, 2017/04/26 01:27:28]

Nit: Up to you, but you could also write this sorta like:

  return db_.Execute(...) &&
         db_.Execute(...) &&
         ...
         transaction.Commit();
         

[please use gerrit instead, 2017/04/26 16:34:15]

Done.

+}
+
 }  // namespace autofill