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 363 matching lines @@
                       "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, "
                       "date_modified INTEGER NOT NULL DEFAULT 0, "
-                      "origin VARCHAR DEFAULT '')")) {
+                      "origin VARCHAR DEFAULT '', "
+                      "language_code VARCHAR)")) {

[Ilya Sherman, 2014/03/29 01:24:42]

nit: Please sort this between country_code and date_modified as you have
elsewhere.

[Scott Hess - ex-Googler, 2014/03/31 17:46:38]

It should be at the end to match the ALTER TABLE.  It is not always possible to
exactly match organic series-of-upgrades schema with freshly-created schema, but
reducing the differences generally reduces mistakes.

[please use gerrit instead, 2014/04/02 21:54:52]

Keeping the field at the end to enable using ALTER TABLE in migration. ALTER
TABLE is more succinct, but can can only append columns at the end. 

       NOTREACHED();
       return false;
     }
   }
   return true;
 }
 
 bool AutofillTable::InitProfileNamesTable() {
   if (!db_->DoesTableExist("autofill_profile_names")) {
     if (!db_->Execute("CREATE TABLE autofill_profile_names ( "
@@ skipping 968 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() {
+  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.

[Ilya Sherman, 2014/03/29 01:24:42]

This sort of thing should no longer be needed.  It should be safe to reduce this
entire method to

return db_->Execute("ALTER TABLE ...");

[Scott Hess - ex-Googler, 2014/03/31 17:46:38]

I agree, no reason for a commit if there's only a single thread of control with
a single atomic change.  You do need a commit if someone can race between the
existence check and the alter.

[please use gerrit instead, 2014/04/02 21:54:52]

Since the existence check is no longer necessary (why was it necessary in other
methods, btw?), I've simplified the method to:

return db->Execute("ALTER TABLE ...");

There's no need for a transaction, because it's a single operation.

[Scott Hess - ex-Googler, 2014/04/02 22:20:22]

Unfortunately, Chromium's overall schema version management is kind of broken,
and the existence checks tend to be a wart stemming from that.  The specific
place where you can see failures is where version 1 doesn't have a table,
version 2 adds a table, and version 3 adds a column to that table.  In our
world, if you are currently at version 1, the code will first create a version-3
table, and then attempt to run the v1->v2 and v2->v3 upgrades.  The v2->v3
upgrade will fail because the table already has the column it's attempting to
add.

I have no idea if that is a possibility for this specific case.  But if the
column somehow does exist, it will fail the ALTER and the user will never
progress.  Since checking the existence is the style in this case, you probably
should keep the check.

+  if (!db_->DoesColumnExist("autofill_profiles", "language_code")) {
+    if (!db_->Execute("ALTER TABLE autofill_profiles "
+                      "ADD COLUMN language_code VARCHAR")) {
+      return false;
+    }
+  }
+
+  return transaction.Commit();
+}
+
 }  // namespace autofill