Fill in more name fields with requestAutocomplete

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 <algorithm>
 #include <cmath>
 #include <limits>
 #include <map>
@@ skipping 149 matching lines @@
     index++;
   }
   credit_card->SetRawInfo(CREDIT_CARD_NUMBER, credit_card_number);
   // Intentionally skip column 5, which stores the modification date.
   index++;
   credit_card->set_origin(s.ColumnString(index++));
 
   return credit_card.Pass();
 }
 
+// Obsolete version of AddAutofillProfileNamesToProfile, but still needed
+// for MigrateToVersion37MergeAndCullOlderProfiles().
+bool AddAutofillProfileNamesToProfileForVersion37(sql::Connection* db,
+                                                  AutofillProfile* profile) {
+  sql::Statement s(db->GetUniqueStatement(
+      "SELECT guid, first_name, middle_name, last_name "
+      "FROM autofill_profile_names "
+      "WHERE guid=?"));
+  s.BindString(0, profile->guid());
+
+  if (!s.is_valid())
+    return false;
+
+  std::vector<base::string16> first_names;
+  std::vector<base::string16> middle_names;
+  std::vector<base::string16> last_names;
+  while (s.Step()) {
+    DCHECK_EQ(profile->guid(), s.ColumnString(0));
+    first_names.push_back(s.ColumnString16(1));
+    middle_names.push_back(s.ColumnString16(2));
+    last_names.push_back(s.ColumnString16(3));
+  }
+  if (!s.Succeeded())
+    return false;
+
+  profile->SetRawMultiInfo(NAME_FIRST, first_names);
+  profile->SetRawMultiInfo(NAME_MIDDLE, middle_names);
+  profile->SetRawMultiInfo(NAME_LAST, last_names);
+  return true;
+}
+
 bool AddAutofillProfileNamesToProfile(sql::Connection* db,
                                       AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
-      "SELECT guid, first_name, middle_name, last_name "
+      "SELECT guid, first_name, middle_name, last_name, full_name "
       "FROM autofill_profile_names "
       "WHERE guid=?"));
   s.BindString(0, profile->guid());
 
   if (!s.is_valid())
     return false;
 
   std::vector<base::string16> first_names;
   std::vector<base::string16> middle_names;
   std::vector<base::string16> last_names;
+  std::vector<base::string16> full_names;
   while (s.Step()) {
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     first_names.push_back(s.ColumnString16(1));
     middle_names.push_back(s.ColumnString16(2));
     last_names.push_back(s.ColumnString16(3));
+    full_names.push_back(s.ColumnString16(4));
   }
   if (!s.Succeeded())
     return false;
 
   profile->SetRawMultiInfo(NAME_FIRST, first_names);
   profile->SetRawMultiInfo(NAME_MIDDLE, middle_names);
   profile->SetRawMultiInfo(NAME_LAST, last_names);
+  profile->SetRawMultiInfo(NAME_FULL, full_names);
   return true;
 }
 
 bool AddAutofillProfileEmailsToProfile(sql::Connection* db,
                                        AutofillProfile* profile) {
   sql::Statement s(db->GetUniqueStatement(
       "SELECT guid, email "
       "FROM autofill_profile_emails "
       "WHERE guid=?"));
   s.BindString(0, profile->guid());
@@ skipping 29 matching lines @@
     DCHECK_EQ(profile->guid(), s.ColumnString(0));
     numbers.push_back(s.ColumnString16(1));
   }
   if (!s.Succeeded())
     return false;
 
   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, numbers);
   return true;
 }
 
+// Obsolete version of AddAutofillProfileNames needed for
+// MigrateToVersion33ProfilesBasedOnFirstName() and
+// MigrateToVersion37MergeAndCullOlderProfiles().
+bool AddAutofillProfileNamesForVersion3x(
+    const AutofillProfile& profile,
+    sql::Connection* db) {
+  std::vector<base::string16> first_names;
+  profile.GetRawMultiInfo(NAME_FIRST, &first_names);
+  std::vector<base::string16> middle_names;
+  profile.GetRawMultiInfo(NAME_MIDDLE, &middle_names);
+  std::vector<base::string16> last_names;
+  profile.GetRawMultiInfo(NAME_LAST, &last_names);
+  DCHECK_EQ(first_names.size(), middle_names.size());
+  DCHECK_EQ(first_names.size(), last_names.size());
+
+  for (size_t i = 0; i < first_names.size(); ++i) {
+    // Add the new name.
+    sql::Statement s;
+    s.Assign(db->GetUniqueStatement(
+        "INSERT INTO autofill_profile_names"
+        " (guid, first_name, middle_name, last_name) "
+        "VALUES (?,?,?,?)"));
+    s.BindString(0, profile.guid());
+    s.BindString16(1, first_names[i]);
+    s.BindString16(2, middle_names[i]);
+    s.BindString16(3, last_names[i]);
+
+    if (!s.Run())
+      return false;
+  }
+  return true;
+}
+
 bool AddAutofillProfileNames(const AutofillProfile& profile,
                              sql::Connection* db) {
   std::vector<base::string16> first_names;
   profile.GetRawMultiInfo(NAME_FIRST, &first_names);
   std::vector<base::string16> middle_names;
   profile.GetRawMultiInfo(NAME_MIDDLE, &middle_names);
   std::vector<base::string16> last_names;
   profile.GetRawMultiInfo(NAME_LAST, &last_names);
+  std::vector<base::string16> full_names;
+  profile.GetRawMultiInfo(NAME_FULL, &full_names);
   DCHECK_EQ(first_names.size(), middle_names.size());
-  DCHECK_EQ(middle_names.size(), last_names.size());
+  DCHECK_EQ(first_names.size(), last_names.size());
+  DCHECK_EQ(first_names.size(), full_names.size());
 
   for (size_t i = 0; i < first_names.size(); ++i) {
     // Add the new name.
-    sql::Statement s(db->GetUniqueStatement(
-      "INSERT INTO autofill_profile_names"
-      " (guid, first_name, middle_name, last_name) "
-      "VALUES (?,?,?,?)"));
+    sql::Statement s;
+    s.Assign(db->GetUniqueStatement(
+        "INSERT INTO autofill_profile_names"
+        " (guid, first_name, middle_name, last_name, full_name) "
+        "VALUES (?,?,?,?,?)"));

[Scott Hess - ex-Googler, 2014/06/16 21:55:54]

Get this all the way back to the default constructor, rather than Assign().

[Evan Stade, 2014/06/16 23:06:05]

Done.

     s.BindString(0, profile.guid());
     s.BindString16(1, first_names[i]);
     s.BindString16(2, middle_names[i]);
     s.BindString16(3, last_names[i]);
+    s.BindString16(4, full_names[i]);
 
     if (!s.Run())
       return false;
   }
   return true;
 }
 
 bool AddAutofillProfileEmails(const AutofillProfile& profile,
                               sql::Connection* db) {
   std::vector<base::string16> emails;
@@ skipping 164 matching lines @@
       return MigrateToVersion51AddOriginColumn();
     case 54:
       *update_compatible_version = true;
       return MigrateToVersion54AddI18nFieldsAndRemoveDeprecatedFields();
     case 55:
       *update_compatible_version = true;
       return MigrateToVersion55MergeAutofillDatesTable();
     case 56:
       *update_compatible_version = true;
       return MigrateToVersion56AddProfileLanguageCodeForFormatting();
+    case 57:
+      *update_compatible_version = true;
+      return MigrateToVersion57AddFullNameField();
   }
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, Time::Now());
 }
 
@@ skipping 825 matching lines @@
   }
   return true;
 }
 
 bool AutofillTable::InitProfileNamesTable() {
   if (!db_->DoesTableExist("autofill_profile_names")) {
     if (!db_->Execute("CREATE TABLE autofill_profile_names ( "
                       "guid VARCHAR, "
                       "first_name VARCHAR, "
                       "middle_name VARCHAR, "
-                      "last_name VARCHAR)")) {
+                      "last_name VARCHAR, "
+                      "full_name VARCHAR)")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitProfileEmailsTable() {
   if (!db_->DoesTableExist("autofill_profile_emails")) {
     if (!db_->Execute("CREATE TABLE autofill_profile_emails ( "
@@ skipping 552 matching lines @@
       s_insert.BindString16(index++, profile.GetRawInfo(ADDRESS_HOME_CITY));
       s_insert.BindString16(index++, profile.GetRawInfo(ADDRESS_HOME_STATE));
       s_insert.BindString16(index++, profile.GetRawInfo(ADDRESS_HOME_ZIP));
       s_insert.BindString16(index++, profile.GetRawInfo(ADDRESS_HOME_COUNTRY));
       s_insert.BindInt64(index++, date_modified);
 
       if (!s_insert.Run())
         return false;
 
       // Add the other bits: names, emails, and phone numbers.
-      if (!AddAutofillProfilePieces(profile, db_))
+      if (!AddAutofillProfileNamesForVersion3x(profile, db_) ||
+          !AddAutofillProfileEmails(profile, db_) ||
+          !AddAutofillProfilePhones(profile, db_)) {
         return false;
+      }
     }  // endwhile
     if (!s.Succeeded())
       return false;
 
     if (!db_->Execute("DROP TABLE autofill_profiles"))
       return false;
 
     if (!db_->Execute(
         "ALTER TABLE autofill_profiles_temp RENAME TO autofill_profiles")) {
       return false;
@@ skipping 118 matching lines @@
     profile->SetRawInfo(ADDRESS_HOME_ZIP, s.ColumnString16(index++));
     // Intentionally skip column 7, which stores the localized country name.
     index++;
     profile->SetRawInfo(ADDRESS_HOME_COUNTRY, s.ColumnString16(index++));
     // Intentionally skip column 9, which stores the profile's modification
     // date.
     index++;
     profile->set_origin(s.ColumnString(index++));
 
     // Get associated name info.
-    AddAutofillProfileNamesToProfile(db_, profile.get());
+    AddAutofillProfileNamesToProfileForVersion37(db_, profile.get());
 
     // Get associated email info.
     AddAutofillProfileEmailsToProfile(db_, profile.get());
 
     // Get associated phone info.
     AddAutofillProfilePhonesToProfile(db_, profile.get());
 
     if (PersonalDataManager::IsValidLearnableProfile(*profile, app_locale_)) {
       std::vector<AutofillProfile> merged_profiles;
       std::string merged_guid = PersonalDataManager::MergeProfile(
@@ skipping 47 matching lines @@
     s.BindString16(index++, GetInfo(*iter, ADDRESS_HOME_CITY));
     s.BindString16(index++, GetInfo(*iter, ADDRESS_HOME_STATE));
     s.BindString16(index++, GetInfo(*iter, ADDRESS_HOME_ZIP));
     s.BindString16(index++, base::string16());  // This column is deprecated.
     s.BindString16(index++, GetInfo(*iter, ADDRESS_HOME_COUNTRY));
     s.BindInt64(index++, date_item->second);
 
     if (!s.Run())
       return false;
 
-    if (!AddAutofillProfilePieces(*iter, db_))
+    if (!AddAutofillProfileNamesForVersion3x(*iter, db_) ||
+        !AddAutofillProfileEmails(*iter, db_) ||
+        !AddAutofillProfilePhones(*iter, db_)) {
       return false;
+    }
   }
 
   return true;
 }
 
 bool AutofillTable::MigrateToVersion51AddOriginColumn() {
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
 
@@ skipping 177 matching lines @@
 
 
   return transaction.Commit();
 }
 
 bool AutofillTable::MigrateToVersion56AddProfileLanguageCodeForFormatting() {
   return db_->Execute("ALTER TABLE autofill_profiles "
                       "ADD COLUMN language_code VARCHAR");
 }
 
+bool AutofillTable::MigrateToVersion57AddFullNameField() {
+  return db_->Execute("ALTER TABLE autofill_profile_names "
+                      "ADD COLUMN full_name VARCHAR");
+}
+
 }  // namespace autofill