Store the language code for the address in autofill profile.

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 71 matching lines @@
   s->BindString(index++, profile.guid());
 
   s->BindString16(index++, GetInfo(profile, COMPANY_NAME));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_STREET_ADDRESS));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_DEPENDENT_LOCALITY));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_CITY));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_STATE));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_ZIP));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_SORTING_CODE));
   s->BindString16(index++, GetInfo(profile, ADDRESS_HOME_COUNTRY));
+  s->BindString(index++, profile.language_code());
   s->BindInt64(index++, Time::Now().ToTimeT());
   s->BindString(index++, profile.origin());
 }
 
 scoped_ptr<AutofillProfile> AutofillProfileFromStatement(
     const sql::Statement& s) {
   scoped_ptr<AutofillProfile> profile(new AutofillProfile);
   int index = 0;
   profile->set_guid(s.ColumnString(index++));
   DCHECK(base::IsValidGUID(profile->guid()));
 
   profile->SetRawInfo(COMPANY_NAME, s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
                       s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_CITY, s.ColumnString16(index++));
   profile->SetRawInfo(ADDRESS_HOME_STATE, s.ColumnString16(index++));
   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++));
+  profile->set_language_code(s.ColumnString(index++));
   // Intentionally skip column 9, which stores the profile's modification date.
   index++;
   profile->set_origin(s.ColumnString(index++));
 
   return profile.Pass();
 }
 
 void BindCreditCardToStatement(const CreditCard& credit_card,
                                sql::Statement* s) {
   DCHECK(base::IsValidGUID(credit_card.guid()));
@@ skipping 313 matching lines @@
       // Combine migrations 50 and 51.  The migration code from version 49 to 50
       // worked correctly for users with existing 'origin' columns, but failed
       // to create these columns for new users.
       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();
   }
   return true;
 }
 
 bool AutofillTable::AddFormFieldValues(
     const std::vector<FormFieldData>& elements,
     std::vector<AutofillChange>* changes) {
   return AddFormFieldValuesTime(elements, changes, Time::Now());
 }
 
@@ skipping 87 matching lines @@
       change_type = AutofillChange::REMOVE;
     } else {
       change_type = AutofillChange::UPDATE;
 
       // For all updated elements, set either date_created or date_last_used so
       // that the range [date_created, date_last_used] no longer overlaps with
       // [delete_begin, delete_end). Update the count by interpolating.
       // Precisely, compute the average amount of time between increments to the
       // count in the original range [date_created, date_last_used]:
       //   avg_delta = (date_last_used_orig - date_created_orig) / (count - 1)
-      // The count can be exressed as
+      // The count can be expressed as
       //   count = 1 + (date_last_used - date_created) / avg_delta
       // Hence, update the count to
       //   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;
@@ skipping 233 matching lines @@
   return s.Run();
 }
 
 bool AutofillTable::AddAutofillProfile(const AutofillProfile& profile) {
   if (IsAutofillGUIDInTrash(profile.guid()))
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "INSERT INTO autofill_profiles"
       "(guid, company_name, street_address, dependent_locality, city, state,"
-      " zipcode, sorting_code, country_code, date_modified, origin)"
-      "VALUES (?,?,?,?,?,?,?,?,?,?,?)"));
+      " zipcode, sorting_code, country_code, language_code, date_modified,"
+      " origin)"
+      "VALUES (?,?,?,?,?,?,?,?,?,?,?,?)"));
   BindAutofillProfileToStatement(profile, &s);
 
   if (!s.Run())
     return false;
 
   return AddAutofillProfilePieces(profile, db_);
 }
 
 bool AutofillTable::GetAutofillProfile(const std::string& guid,
                                        AutofillProfile** profile) {
   DCHECK(base::IsValidGUID(guid));
   DCHECK(profile);
   sql::Statement s(db_->GetUniqueStatement(
       "SELECT guid, company_name, street_address, dependent_locality, city,"
-      " state, zipcode, sorting_code, country_code, date_modified, origin "
+      " state, zipcode, sorting_code, country_code, language_code,"
+      " date_modified, origin "
       "FROM autofill_profiles "
       "WHERE guid=?"));
   s.BindString(0, guid);
 
   if (!s.Step())
     return false;
 
   scoped_ptr<AutofillProfile> p = AutofillProfileFromStatement(s);
 
   // Get associated name info.
@@ skipping 44 matching lines @@
   // Preserve appropriate modification dates by not updating unchanged profiles.
   scoped_ptr<AutofillProfile> old_profile(tmp_profile);
   if (old_profile->Compare(profile) == 0 &&
       old_profile->origin() == profile.origin())
     return true;
 
   sql::Statement s(db_->GetUniqueStatement(
       "UPDATE autofill_profiles "
       "SET guid=?, company_name=?, street_address=?, dependent_locality=?, "
       "    city=?, state=?, zipcode=?, sorting_code=?, country_code=?, "
-      "    date_modified=?, origin=? "
+      "    language_code=?, date_modified=?, origin=? "
       "WHERE guid=?"));
   BindAutofillProfileToStatement(profile, &s);
-  s.BindString(11, profile.guid());
+  s.BindString(12, profile.guid());
 
   bool result = s.Run();
   DCHECK_GT(db_->GetLastChangeCount(), 0);
   if (!result)
     return result;
 
   // Remove the old names, emails, and phone numbers.
   if (!RemoveAutofillProfilePieces(profile.guid(), db_))
     return false;
 
@@ skipping 362 matching lines @@
     if (!db_->Execute("CREATE TABLE autofill_profiles ( "
                       "guid VARCHAR PRIMARY KEY, "
                       "company_name VARCHAR, "
                       "street_address VARCHAR, "
                       "dependent_locality VARCHAR, "
                       "city VARCHAR, "
                       "state VARCHAR, "
                       "zipcode VARCHAR, "
                       "sorting_code VARCHAR, "
                       "country_code VARCHAR, "
+                      "language_code VARCHAR, "

[Scott Hess - ex-Googler, 2014/03/28 19:53:57]

Since ALTER TABLE can only add new columns, I generally prefer to add new
columns when editing CREATE TABLE statements, so that the ordering is the same
regardless of which path the user took to a particular schema version.  I do not
know if webdata has practices in this area, though.

[please use gerrit instead, 2014/03/28 22:00:38]

Changed the statement to append the column instead. That sounds like the right
approach. because it mimics what ALTER TABLE ADD COLUMN does.

FYI, the fields street_address, dependent_locality, and sorting_code were added
in logical ordering:

http://src.chromium.org/viewvc/chrome/trunk/src/components/autofill/core/brow...

                       "date_modified INTEGER NOT NULL DEFAULT 0, "
                       "origin VARCHAR DEFAULT '')")) {
       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitProfileNamesTable() {
@@ skipping 970 matching lines @@
   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() {

[Scott Hess - ex-Googler, 2014/03/28 19:53:57]

AFAICT, this is just manually implementing ALTER TABLE, except that ALTER TABLE
won't trampoline the table data.  Is there something which requires
language_code to not have a default value specified?

[please use gerrit instead, 2014/03/28 22:00:38]

Replaced the manual operations with a single alter table. This approach is much
shorter and more resilient to failure. (It makes fewer assumptions about
existing data.)

+  sql::Transaction transaction(db_);
+  if (!transaction.Begin())
+    return false;
+
+  // Test the existence of the |language_code| column as an indication that a
+  // migration is needed. It is possible that this column already exists because
+  // the table was newly created when migrating from a pre-version-23 database.
+  if (!db_->DoesColumnExist("autofill_profiles", "language_code")) {
+    // Create a temporary copy of the autofill_profiles table in the (newer)
+    // version 56 format.  This table adds a column for |language_code|.
+    if (db_->DoesTableExist("autofill_profiles_temp") ||
+        !db_->Execute("CREATE TABLE autofill_profiles_temp ( "
+                      "guid VARCHAR PRIMARY KEY, "
+                      "company_name VARCHAR, "
+                      "street_address VARCHAR, "
+                      "dependent_locality VARCHAR, "
+                      "city VARCHAR, "
+                      "state VARCHAR, "
+                      "zipcode VARCHAR, "
+                      "sorting_code VARCHAR, "
+                      "country_code VARCHAR, "
+                      "language_code VARCHAR, "
+                      "date_modified INTEGER NOT NULL DEFAULT 0, "
+                      "origin VARCHAR DEFAULT '')")) {
+      return false;
+    }
+
+    // Copy over the data from the autofill_profiles table, initiating the
+    // |language_code| column with an empty string.
+    if (!db_->Execute("INSERT INTO autofill_profiles_temp "
+                      "SELECT guid, company_name, street_address, "
+                      "dependent_locality, city, state, zipcode, sorting_code, "
+                      "country_code, '', date_modified, origin "
+                      "FROM autofill_profiles")) {
+      return false;
+    }
+
+    // Delete the existing (version 55) table and replace it with the contents
+    // of the temporary table.
+    if (!db_->Execute("DROP TABLE autofill_profiles") ||
+        !db_->Execute("ALTER TABLE autofill_profiles_temp "
+                      "RENAME TO autofill_profiles")) {
+      return false;
+    }
+  }
+
+  return transaction.Commit();
+}
+
 }  // namespace autofill