Make autofill's Address store country using the country code so that app locale isn't needed for th…

chrome/browser/webdata/autofill_profile_syncable_service.cc

 // Copyright (c) 2012 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 "chrome/browser/webdata/autofill_profile_syncable_service.h"
 
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/utf_string_conversions.h"
+#include "components/autofill/browser/autofill_country.h"
 #include "components/autofill/browser/autofill_profile.h"
 #include "components/autofill/browser/form_group.h"
 #include "components/webdata/autofill/autofill_table.h"
 #include "components/webdata/autofill/autofill_webdata_service.h"
 #include "components/webdata/common/web_database.h"
 #include "content/public/browser/browser_thread.h"
 #include "sync/api/sync_error.h"
 #include "sync/api/sync_error_factory.h"
 #include "sync/protocol/sync.pb.h"
 
@@ skipping 13 matching lines @@
   // with something else.
   static int user_data_key = 0;
   return reinterpret_cast<void*>(&user_data_key);
 }
 
 }  // namespace
 
 const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
 
 AutofillProfileSyncableService::AutofillProfileSyncableService(
-    AutofillWebDataService* web_data_service)
+    AutofillWebDataService* web_data_service,
+    const std::string& app_locale)
     : web_data_service_(web_data_service),
+      app_locale_(app_locale),
       ALLOW_THIS_IN_INITIALIZER_LIST(scoped_observer_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(web_data_service_);
 
   scoped_observer_.Add(web_data_service_);
 }
 
 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 // static
 void AutofillProfileSyncableService::CreateForWebDataService(
-    AutofillWebDataService* web_data_service) {
+    AutofillWebDataService* web_data_service,
+    const std::string& app_locale) {
   web_data_service->GetDBUserData()->SetUserData(
-      UserDataKey(), new AutofillProfileSyncableService(web_data_service));
+      UserDataKey(),
+      new AutofillProfileSyncableService(web_data_service, app_locale));
 }
 
 // static
 AutofillProfileSyncableService*
 AutofillProfileSyncableService::FromWebDataService(
     AutofillWebDataService* web_data_service) {
   return static_cast<AutofillProfileSyncableService*>(
       web_data_service->GetDBUserData()->GetUserData(UserDataKey()));
 }
 
@@ skipping 220 matching lines @@
     if (!GetAutofillTable()->UpdateAutofillProfileMulti(
         *bundle.profiles_to_update[i]))
       success = false;
   }
   return success;
 }
 
 // static
 bool AutofillProfileSyncableService::OverwriteProfileWithServerData(
     const sync_pb::AutofillProfileSpecifics& specifics,
-    AutofillProfile* profile) {
+    AutofillProfile* profile,
+    const std::string& app_locale) {
   bool diff = false;
   diff = UpdateMultivaluedField(NAME_FIRST,
                                 specifics.name_first(), profile) || diff;
   diff = UpdateMultivaluedField(NAME_MIDDLE,
                                 specifics.name_middle(), profile) || diff;
   diff = UpdateMultivaluedField(NAME_LAST,
                                 specifics.name_last(), profile) || diff;
   diff = UpdateField(ADDRESS_HOME_LINE1,
                      specifics.address_home_line1(), profile) || diff;
   diff = UpdateField(ADDRESS_HOME_LINE2,
                      specifics.address_home_line2(), profile) || diff;
   diff = UpdateField(ADDRESS_HOME_CITY,
                      specifics.address_home_city(), profile) || diff;
   diff = UpdateField(ADDRESS_HOME_STATE,
                      specifics.address_home_state(), profile) || diff;
-  diff = UpdateField(ADDRESS_HOME_COUNTRY,
-                     specifics.address_home_country(), profile) || diff;
+  string16 country_name_or_code =
+      ASCIIToUTF16(specifics.address_home_country());
+  std::string country_code = AutofillCountry::GetCountryCode(
+      country_name_or_code, app_locale);
+  diff = UpdateField(ADDRESS_HOME_COUNTRY, country_code, profile) || diff;
   diff = UpdateField(ADDRESS_HOME_ZIP,
                      specifics.address_home_zip(), profile) || diff;
   diff = UpdateMultivaluedField(EMAIL_ADDRESS,
                                 specifics.email_address(), profile) || diff;
   diff = UpdateField(COMPANY_NAME, specifics.company_name(), profile) || diff;
   diff = UpdateMultivaluedField(PHONE_HOME_WHOLE_NUMBER,
                                 specifics.phone_home_whole_number(),
                                 profile) || diff;
   return diff;
 }
@@ skipping 78 matching lines @@
   DCHECK_EQ(syncer::AUTOFILL_PROFILE, data.GetDataType());
 
   const sync_pb::EntitySpecifics& specifics = data.GetSpecifics();
   const sync_pb::AutofillProfileSpecifics& autofill_specifics(
       specifics.autofill_profile());
 
   GUIDToProfileMap::iterator it = profile_map->find(
         autofill_specifics.guid());
   if (it != profile_map->end()) {
     // Some profile that already present is synced.
-    if (OverwriteProfileWithServerData(autofill_specifics, it->second))
+    if (OverwriteProfileWithServerData(
+            autofill_specifics, it->second, app_locale_)) {
       bundle->profiles_to_update.push_back(it->second);
+    }
   } else {
     // New profile synced.
     AutofillProfile* new_profile(
         new AutofillProfile(autofill_specifics.guid()));
-    OverwriteProfileWithServerData(autofill_specifics, new_profile);
+    OverwriteProfileWithServerData(
+        autofill_specifics, new_profile, app_locale_);
 
     // Check if profile appears under a different guid.
     for (GUIDToProfileMap::iterator i = profile_map->begin();
          i != profile_map->end(); ++i) {
       if (i->second->Compare(*new_profile) == 0) {
         bundle->profiles_to_delete.push_back(i->second->guid());
         DVLOG(2) << "[AUTOFILL SYNC]"
                  << "Found in sync db but with a different guid: "
                  << UTF16ToUTF8(i->second->GetRawInfo(NAME_FIRST))
                  << UTF16ToUTF8(i->second->GetRawInfo(NAME_LAST))
@@ skipping 121 matching lines @@
   return (merge_into->Compare(merge_from) != 0);
 }
 
 AutofillTable* AutofillProfileSyncableService::GetAutofillTable() const {
   return AutofillTable::FromWebDatabase(web_data_service_->GetDatabase());
 }
 
 AutofillProfileSyncableService::DataBundle::DataBundle() {}
 
 AutofillProfileSyncableService::DataBundle::~DataBundle() {}