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 73 matching lines @@
   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->BindInt64(index++, Time::Now().ToTimeT());
   s->BindString(index++, profile.origin());
+  s->BindString(index++, profile.language_code());
 }
 
 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++));
   // Intentionally skip column 9, which stores the profile's modification date.
   index++;
   profile->set_origin(s.ColumnString(index++));
+  profile->set_language_code(s.ColumnString(index++));
 
   return profile.Pass();
 }
 
 void BindCreditCardToStatement(const CreditCard& credit_card,
                                sql::Statement* s) {
   DCHECK(base::IsValidGUID(credit_card.guid()));
   int index = 0;
   s->BindString(index++, credit_card.guid());
 
@@ skipping 310 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, date_modified, origin,"
+      " language_code)"
+      "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, date_modified, origin,"
+      " language_code "
       "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 36 matching lines @@
   // pending modifications to process.
   if (!IsAutofillProfilesTrashEmpty())
     return true;
 
   AutofillProfile* tmp_profile = NULL;
   if (!GetAutofillProfile(profile.guid(), &tmp_profile))
     return false;
 
   // 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())
+  if (*old_profile == profile)
     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=? "
+      "    date_modified=?, origin=?, language_code=? "
       "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)")) {
       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() {
+  return db_->Execute("ALTER TABLE autofill_profiles "
+                      "ADD COLUMN language_code VARCHAR");
+}
+
 }  // namespace autofill