[Autofill] Style cleanup: Move AutofillProfileSyncableService into the autofill namespace.

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/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_country.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/form_group.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/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"
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
-using autofill::AutofillCountry;
-using autofill::ServerFieldType;
-using autofill::AutofillProfile;
-using autofill::AutofillProfileChange;
-using autofill::AutofillTable;
-using autofill::AutofillWebDataService;
 using content::BrowserThread;
 
+namespace autofill {
+
 namespace {
 
 std::string LimitData(const std::string& data) {
   std::string sanitized_value(data);
   if (sanitized_value.length() > AutofillTable::kMaxDataLength)
     sanitized_value.resize(AutofillTable::kMaxDataLength);
   return sanitized_value;
 }
 
 void* UserDataKey() {
   // Use the address of a static that COMDAT folding won't ever fold
   // 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(
-    autofill::AutofillWebDataBackend* webdata_backend,
+    AutofillWebDataBackend* webdata_backend,
     const std::string& app_locale)
     : webdata_backend_(webdata_backend),
       app_locale_(app_locale),
       scoped_observer_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::DB));
   DCHECK(webdata_backend_);
 
   scoped_observer_.Add(webdata_backend_);
 }
 
 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
   DCHECK(CalledOnValidThread());
 }
 
 // static
 void AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
     AutofillWebDataService* web_data_service,
-    autofill::AutofillWebDataBackend* webdata_backend,
+    AutofillWebDataBackend* webdata_backend,
     const std::string& app_locale) {
   web_data_service->GetDBUserData()->SetUserData(
       UserDataKey(),
       new AutofillProfileSyncableService(webdata_backend, app_locale));
 }
 
 // static
 AutofillProfileSyncableService*
 AutofillProfileSyncableService::FromWebDataService(
     AutofillWebDataService* web_data_service) {
@@ skipping 28 matching lines @@
   }
 
   if (DLOG_IS_ON(INFO)) {
     DVLOG(2) << "[AUTOFILL MIGRATION]"
              << "Printing profiles from web db";
 
     for (ScopedVector<AutofillProfile>::const_iterator ix =
          profiles_.begin(); ix != profiles_.end(); ++ix) {
       AutofillProfile* p = *ix;
       DVLOG(2) << "[AUTOFILL MIGRATION]  "
-               << p->GetRawInfo(autofill::NAME_FIRST)
-               << p->GetRawInfo(autofill::NAME_LAST)
+               << UTF16ToUTF8(p->GetRawInfo(NAME_FIRST))
+               << UTF16ToUTF8(p->GetRawInfo(NAME_LAST))
                << p->guid();
     }
   }
 
   sync_processor_ = sync_processor.Pass();
 
   GUIDToProfileMap remaining_profiles;
   CreateGUIDToProfileMap(profiles_.get(), &remaining_profiles);
 
   DataBundle bundle;
@@ skipping 17 matching lines @@
   for (GUIDToProfileMap::iterator it = bundle.candidates_to_merge.begin();
        it != bundle.candidates_to_merge.end(); ++it) {
     GUIDToProfileMap::iterator profile_to_merge =
         remaining_profiles.find(it->first);
     if (profile_to_merge != remaining_profiles.end()) {
       bundle.profiles_to_delete.push_back(profile_to_merge->second->guid());
       if (MergeProfile(*(profile_to_merge->second), it->second, app_locale_))
         bundle.profiles_to_sync_back.push_back(it->second);
       DVLOG(2) << "[AUTOFILL SYNC]"
                << "Found similar profile in sync db but with a different guid: "
-               << UTF16ToUTF8(it->second->GetRawInfo(autofill::NAME_FIRST))
-               << UTF16ToUTF8(it->second->GetRawInfo(autofill::NAME_LAST))
+               << UTF16ToUTF8(it->second->GetRawInfo(NAME_FIRST))
+               << UTF16ToUTF8(it->second->GetRawInfo(NAME_LAST))
                << "New guid " << it->second->guid()
                << ". Profile to be deleted "
                << profile_to_merge->second->guid();
       remaining_profiles.erase(profile_to_merge);
     }
   }
 
   if (!SaveChangesToWebData(bundle)) {
     merge_result.set_error(sync_error_factory_->CreateAndUploadError(
         FROM_HERE,
@@ skipping 119 matching lines @@
 
 bool AutofillProfileSyncableService::LoadAutofillData(
     std::vector<AutofillProfile*>* profiles) {
   return GetAutofillTable()->GetAutofillProfiles(profiles);
 }
 
 bool AutofillProfileSyncableService::SaveChangesToWebData(
     const DataBundle& bundle) {
   DCHECK(CalledOnValidThread());
 
-  autofill::AutofillTable* autofill_table = GetAutofillTable();
+  AutofillTable* autofill_table = GetAutofillTable();
 
   bool success = true;
   for (size_t i = 0; i< bundle.profiles_to_delete.size(); ++i) {
     if (!autofill_table->RemoveAutofillProfile(bundle.profiles_to_delete[i]))
       success = false;
   }
 
   for (size_t i = 0; i < bundle.profiles_to_add.size(); i++) {
     if (!autofill_table->AddAutofillProfile(*bundle.profiles_to_add[i]))
       success = false;
@@ skipping 14 matching lines @@
   bool diff = false;
   if (profile->origin() != specifics.origin()) {
     bool was_verified = profile->IsVerified();
     profile->set_origin(specifics.origin());
     diff = true;
 
     // Verified profiles should never be overwritten by unverified ones.
     DCHECK(!was_verified || profile->IsVerified());
   }
 
-  diff = UpdateMultivaluedField(autofill::NAME_FIRST,
+  // Update all multivalued fields: names, emails, and phones.
+  diff = UpdateMultivaluedField(NAME_FIRST,
                                 specifics.name_first(), profile) || diff;
-  diff = UpdateMultivaluedField(autofill::NAME_MIDDLE,
+  diff = UpdateMultivaluedField(NAME_MIDDLE,
                                 specifics.name_middle(), profile) || diff;
-  diff = UpdateMultivaluedField(autofill::NAME_LAST,
+  diff = UpdateMultivaluedField(NAME_LAST,
                                 specifics.name_last(), profile) || diff;
-  diff = UpdateField(autofill::ADDRESS_HOME_LINE1,
+  diff = UpdateMultivaluedField(EMAIL_ADDRESS,
+                                specifics.email_address(), profile) || diff;
+  diff = UpdateMultivaluedField(PHONE_HOME_WHOLE_NUMBER,
+                                specifics.phone_home_whole_number(),
+                                profile) || diff;
+
+  // Update all simple single-valued address fields.
+  diff = UpdateField(COMPANY_NAME, specifics.company_name(), profile) || diff;
+  diff = UpdateField(ADDRESS_HOME_LINE1,
                      specifics.address_home_line1(), profile) || diff;
-  diff = UpdateField(autofill::ADDRESS_HOME_LINE2,
+  diff = UpdateField(ADDRESS_HOME_LINE2,
                      specifics.address_home_line2(), profile) || diff;
-  diff = UpdateField(autofill::ADDRESS_HOME_CITY,
+  diff = UpdateField(ADDRESS_HOME_CITY,
                      specifics.address_home_city(), profile) || diff;
-  diff = UpdateField(autofill::ADDRESS_HOME_STATE,
+  diff = UpdateField(ADDRESS_HOME_STATE,
                      specifics.address_home_state(), profile) || diff;
+  diff = UpdateField(ADDRESS_HOME_ZIP,
+                     specifics.address_home_zip(), profile) || diff;
+
+  // Update the country field, which can contain either a country code (if set
+  // by a newer version of Chrome), or a country name (if set by an older
+  // version of Chrome).
   base::string16 country_name_or_code =
       ASCIIToUTF16(specifics.address_home_country());
-  std::string country_code = AutofillCountry::GetCountryCode(
-      country_name_or_code, app_locale);
-  diff = UpdateField(
-      autofill::ADDRESS_HOME_COUNTRY, country_code, profile) || diff;
-  diff = UpdateField(autofill::ADDRESS_HOME_ZIP,
-                     specifics.address_home_zip(), profile) || diff;
-  diff = UpdateMultivaluedField(autofill::EMAIL_ADDRESS,
-                                specifics.email_address(), profile) || diff;
-  diff = UpdateField(
-      autofill::COMPANY_NAME, specifics.company_name(), profile) || diff;
-  diff = UpdateMultivaluedField(autofill::PHONE_HOME_WHOLE_NUMBER,
-                                specifics.phone_home_whole_number(),
-                                profile) || diff;
+  std::string country_code =
+      AutofillCountry::GetCountryCode(country_name_or_code, app_locale);
+  diff = UpdateField(ADDRESS_HOME_COUNTRY, country_code, profile) || diff;
+
   return diff;
 }
 
 // static
 void AutofillProfileSyncableService::WriteAutofillProfile(
     const AutofillProfile& profile,
     sync_pb::EntitySpecifics* profile_specifics) {
   sync_pb::AutofillProfileSpecifics* specifics =
       profile_specifics->mutable_autofill_profile();
 
   DCHECK(base::IsValidGUID(profile.guid()));
 
   // Reset all multi-valued fields in the protobuf.
   specifics->clear_name_first();
   specifics->clear_name_middle();
   specifics->clear_name_last();
   specifics->clear_email_address();
   specifics->clear_phone_home_whole_number();
 
   specifics->set_guid(profile.guid());
   specifics->set_origin(profile.origin());
 
   std::vector<base::string16> values;
-  profile.GetRawMultiInfo(autofill::NAME_FIRST, &values);
+  profile.GetRawMultiInfo(NAME_FIRST, &values);
   for (size_t i = 0; i < values.size(); ++i) {
     specifics->add_name_first(LimitData(UTF16ToUTF8(values[i])));
   }
 
-  profile.GetRawMultiInfo(autofill::NAME_MIDDLE, &values);
+  profile.GetRawMultiInfo(NAME_MIDDLE, &values);
   for (size_t i = 0; i < values.size(); ++i) {
     specifics->add_name_middle(LimitData(UTF16ToUTF8(values[i])));
   }
 
-  profile.GetRawMultiInfo(autofill::NAME_LAST, &values);
+  profile.GetRawMultiInfo(NAME_LAST, &values);
   for (size_t i = 0; i < values.size(); ++i) {
     specifics->add_name_last(LimitData(UTF16ToUTF8(values[i])));
   }
 
   specifics->set_address_home_line1(
-      LimitData(UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_LINE1))));
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE1))));
   specifics->set_address_home_line2(
-      LimitData(UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_LINE2))));
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE2))));
   specifics->set_address_home_city(
-      LimitData(UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_CITY))));
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY))));
   specifics->set_address_home_state(
-      LimitData(UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_STATE))));
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE))));
+  specifics->set_address_home_zip(
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP))));
   specifics->set_address_home_country(
-      LimitData(
-          UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_COUNTRY))));
-  specifics->set_address_home_zip(
-      LimitData(UTF16ToUTF8(profile.GetRawInfo(autofill::ADDRESS_HOME_ZIP))));
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))));
 
-  profile.GetRawMultiInfo(autofill::EMAIL_ADDRESS, &values);
+  profile.GetRawMultiInfo(EMAIL_ADDRESS, &values);
   for (size_t i = 0; i < values.size(); ++i) {
     specifics->add_email_address(LimitData(UTF16ToUTF8(values[i])));
   }
 
   specifics->set_company_name(
-      LimitData(UTF16ToUTF8(profile.GetRawInfo(autofill::COMPANY_NAME))));
+      LimitData(UTF16ToUTF8(profile.GetRawInfo(COMPANY_NAME))));
 
-  profile.GetRawMultiInfo(autofill::PHONE_HOME_WHOLE_NUMBER, &values);
+  profile.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
   for (size_t i = 0; i < values.size(); ++i) {
     specifics->add_phone_home_whole_number(LimitData(UTF16ToUTF8(values[i])));
   }
 }
 
 void AutofillProfileSyncableService::CreateGUIDToProfileMap(
     const std::vector<AutofillProfile*>& profiles,
     GUIDToProfileMap* profile_map) {
   DCHECK(profile_map);
   profile_map->clear();
@@ skipping 41 matching lines @@
       // Ensure that a verified profile can never revert back to an unverified
       // one.
       if (local_profile->IsVerified() && !new_profile->IsVerified()) {
         new_profile->set_origin(local_profile->origin());
         bundle->profiles_to_sync_back.push_back(new_profile);
       }
 
       bundle->profiles_to_delete.push_back(local_profile->guid());
       DVLOG(2) << "[AUTOFILL SYNC]"
                << "Found in sync db but with a different guid: "
-               << UTF16ToUTF8(local_profile->GetRawInfo(autofill::NAME_FIRST))
-               << UTF16ToUTF8(local_profile->GetRawInfo(autofill::NAME_LAST))
+               << UTF16ToUTF8(local_profile->GetRawInfo(NAME_FIRST))
+               << UTF16ToUTF8(local_profile->GetRawInfo(NAME_LAST))
                << "New guid " << new_profile->guid()
                << ". Profile to be deleted " << local_profile->guid();
       profile_map->erase(it);
       break;
     } else if (!local_profile->IsVerified() &&
                !new_profile->IsVerified() &&
                !local_profile->PrimaryValue().empty() &&
                local_profile->PrimaryValue() == new_profile->PrimaryValue()) {
       // Add it to candidates for merge - if there is no profile with this
       // guid we will merge them.
@@ skipping 118 matching lines @@
 }
 
 void AutofillProfileSyncableService::InjectStartSyncFlare(
     const syncer::SyncableService::StartSyncFlare& flare) {
   flare_ = flare;
 }
 
 AutofillProfileSyncableService::DataBundle::DataBundle() {}
 
 AutofillProfileSyncableService::DataBundle::~DataBundle() {}
+
+}  // namespace autofill