Home | History | Annotate | Download | only in webdata 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
      6 
      7 #include "base/guid.h"
      8 #include "base/location.h"
      9 #include "base/logging.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "components/autofill/core/browser/autofill_country.h"
     12 #include "components/autofill/core/browser/autofill_profile.h"
     13 #include "components/autofill/core/browser/form_group.h"
     14 #include "components/autofill/core/browser/webdata/autofill_table.h"
     15 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
     16 #include "components/webdata/common/web_database.h"
     17 #include "sync/api/sync_error.h"
     18 #include "sync/api/sync_error_factory.h"
     19 #include "sync/protocol/sync.pb.h"
     20 
     21 using base::ASCIIToUTF16;
     22 using base::UTF8ToUTF16;
     23 using base::UTF16ToUTF8;
     24 
     25 namespace autofill {
     26 
     27 namespace {
     28 
     29 std::string LimitData(const std::string& data) {
     30   std::string sanitized_value(data);
     31   if (sanitized_value.length() > AutofillTable::kMaxDataLength)
     32     sanitized_value.resize(AutofillTable::kMaxDataLength);
     33   return sanitized_value;
     34 }
     35 
     36 void* UserDataKey() {
     37   // Use the address of a static that COMDAT folding won't ever fold
     38   // with something else.
     39   static int user_data_key = 0;
     40   return reinterpret_cast<void*>(&user_data_key);
     41 }
     42 
     43 }  // namespace
     44 
     45 const char kAutofillProfileTag[] = "google_chrome_autofill_profiles";
     46 
     47 AutofillProfileSyncableService::AutofillProfileSyncableService(
     48     AutofillWebDataBackend* webdata_backend,
     49     const std::string& app_locale)
     50     : webdata_backend_(webdata_backend),
     51       app_locale_(app_locale),
     52       scoped_observer_(this) {
     53   DCHECK(webdata_backend_);
     54 
     55   scoped_observer_.Add(webdata_backend_);
     56 }
     57 
     58 AutofillProfileSyncableService::~AutofillProfileSyncableService() {
     59   DCHECK(CalledOnValidThread());
     60 }
     61 
     62 // static
     63 void AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
     64     AutofillWebDataService* web_data_service,
     65     AutofillWebDataBackend* webdata_backend,
     66     const std::string& app_locale) {
     67   web_data_service->GetDBUserData()->SetUserData(
     68       UserDataKey(),
     69       new AutofillProfileSyncableService(webdata_backend, app_locale));
     70 }
     71 
     72 // static
     73 AutofillProfileSyncableService*
     74 AutofillProfileSyncableService::FromWebDataService(
     75     AutofillWebDataService* web_data_service) {
     76   return static_cast<AutofillProfileSyncableService*>(
     77       web_data_service->GetDBUserData()->GetUserData(UserDataKey()));
     78 }
     79 
     80 AutofillProfileSyncableService::AutofillProfileSyncableService()
     81     : webdata_backend_(NULL),
     82       scoped_observer_(this) {
     83 }
     84 
     85 syncer::SyncMergeResult
     86 AutofillProfileSyncableService::MergeDataAndStartSyncing(
     87     syncer::ModelType type,
     88     const syncer::SyncDataList& initial_sync_data,
     89     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     90     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
     91   DCHECK(CalledOnValidThread());
     92   DCHECK(!sync_processor_.get());
     93   DCHECK(sync_processor.get());
     94   DCHECK(sync_error_factory.get());
     95   DVLOG(1) << "Associating Autofill: MergeDataAndStartSyncing";
     96 
     97   syncer::SyncMergeResult merge_result(type);
     98   sync_error_factory_ = sync_error_factory.Pass();
     99   if (!LoadAutofillData(&profiles_.get())) {
    100     merge_result.set_error(sync_error_factory_->CreateAndUploadError(
    101         FROM_HERE, "Could not get the autofill data from WebDatabase."));
    102     return merge_result;
    103   }
    104 
    105   if (DLOG_IS_ON(INFO)) {
    106     DVLOG(2) << "[AUTOFILL MIGRATION]"
    107              << "Printing profiles from web db";
    108 
    109     for (ScopedVector<AutofillProfile>::const_iterator ix =
    110          profiles_.begin(); ix != profiles_.end(); ++ix) {
    111       AutofillProfile* p = *ix;
    112       DVLOG(2) << "[AUTOFILL MIGRATION]  "
    113                << UTF16ToUTF8(p->GetRawInfo(NAME_FIRST))
    114                << UTF16ToUTF8(p->GetRawInfo(NAME_LAST))
    115                << p->guid();
    116     }
    117   }
    118 
    119   sync_processor_ = sync_processor.Pass();
    120 
    121   GUIDToProfileMap remaining_profiles;
    122   CreateGUIDToProfileMap(profiles_.get(), &remaining_profiles);
    123 
    124   DataBundle bundle;
    125   // Go through and check for all the profiles that sync already knows about.
    126   for (syncer::SyncDataList::const_iterator sync_iter =
    127            initial_sync_data.begin();
    128        sync_iter != initial_sync_data.end();
    129        ++sync_iter) {
    130     GUIDToProfileMap::iterator it =
    131         CreateOrUpdateProfile(*sync_iter, &remaining_profiles, &bundle);
    132     // |it| points to created/updated profile. Add it to the |profiles_map_| and
    133     // then remove it from |remaining_profiles|. After this loop is completed
    134     // |remaining_profiles| will have only those profiles that are not in the
    135     // sync.
    136     profiles_map_[it->first] = it->second;
    137     remaining_profiles.erase(it);
    138   }
    139 
    140   // Check for similar unmatched profiles - they are created independently on
    141   // two systems, so merge them.
    142   for (GUIDToProfileMap::iterator it = bundle.candidates_to_merge.begin();
    143        it != bundle.candidates_to_merge.end(); ++it) {
    144     GUIDToProfileMap::iterator profile_to_merge =
    145         remaining_profiles.find(it->first);
    146     if (profile_to_merge != remaining_profiles.end()) {
    147       bundle.profiles_to_delete.push_back(profile_to_merge->second->guid());
    148       if (MergeProfile(*(profile_to_merge->second), it->second, app_locale_))
    149         bundle.profiles_to_sync_back.push_back(it->second);
    150       DVLOG(2) << "[AUTOFILL SYNC]"
    151                << "Found similar profile in sync db but with a different guid: "
    152                << UTF16ToUTF8(it->second->GetRawInfo(NAME_FIRST))
    153                << UTF16ToUTF8(it->second->GetRawInfo(NAME_LAST))
    154                << "New guid " << it->second->guid()
    155                << ". Profile to be deleted "
    156                << profile_to_merge->second->guid();
    157       remaining_profiles.erase(profile_to_merge);
    158     }
    159   }
    160 
    161   if (!SaveChangesToWebData(bundle)) {
    162     merge_result.set_error(sync_error_factory_->CreateAndUploadError(
    163         FROM_HERE,
    164         "Failed to update webdata."));
    165     return merge_result;
    166   }
    167 
    168   syncer::SyncChangeList new_changes;
    169   for (GUIDToProfileMap::iterator i = remaining_profiles.begin();
    170        i != remaining_profiles.end(); ++i) {
    171     new_changes.push_back(
    172         syncer::SyncChange(FROM_HERE,
    173                            syncer::SyncChange::ACTION_ADD,
    174                            CreateData(*(i->second))));
    175     profiles_map_[i->first] = i->second;
    176   }
    177 
    178   for (size_t i = 0; i < bundle.profiles_to_sync_back.size(); ++i) {
    179     new_changes.push_back(
    180         syncer::SyncChange(FROM_HERE,
    181                            syncer::SyncChange::ACTION_UPDATE,
    182                            CreateData(*(bundle.profiles_to_sync_back[i]))));
    183   }
    184 
    185   if (!new_changes.empty()) {
    186     merge_result.set_error(
    187         sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes));
    188   }
    189 
    190   if (webdata_backend_)
    191     webdata_backend_->NotifyOfMultipleAutofillChanges();
    192 
    193   return merge_result;
    194 }
    195 
    196 void AutofillProfileSyncableService::StopSyncing(syncer::ModelType type) {
    197   DCHECK(CalledOnValidThread());
    198   DCHECK_EQ(type, syncer::AUTOFILL_PROFILE);
    199 
    200   sync_processor_.reset();
    201   sync_error_factory_.reset();
    202   profiles_.clear();
    203   profiles_map_.clear();
    204 }
    205 
    206 syncer::SyncDataList AutofillProfileSyncableService::GetAllSyncData(
    207     syncer::ModelType type) const {
    208   DCHECK(CalledOnValidThread());
    209   DCHECK(sync_processor_.get());
    210   DCHECK_EQ(type, syncer::AUTOFILL_PROFILE);
    211 
    212   syncer::SyncDataList current_data;
    213 
    214   for (GUIDToProfileMap::const_iterator i = profiles_map_.begin();
    215        i != profiles_map_.end(); ++i) {
    216     current_data.push_back(CreateData(*(i->second)));
    217   }
    218   return current_data;
    219 }
    220 
    221 syncer::SyncError AutofillProfileSyncableService::ProcessSyncChanges(
    222     const tracked_objects::Location& from_here,
    223     const syncer::SyncChangeList& change_list) {
    224   DCHECK(CalledOnValidThread());
    225   if (!sync_processor_.get()) {
    226     syncer::SyncError error(FROM_HERE,
    227                             syncer::SyncError::DATATYPE_ERROR,
    228                             "Models not yet associated.",
    229                             syncer::AUTOFILL_PROFILE);
    230     return error;
    231   }
    232 
    233   DataBundle bundle;
    234 
    235   for (syncer::SyncChangeList::const_iterator i = change_list.begin();
    236        i != change_list.end(); ++i) {
    237     DCHECK(i->IsValid());
    238     switch (i->change_type()) {
    239       case syncer::SyncChange::ACTION_ADD:
    240       case syncer::SyncChange::ACTION_UPDATE:
    241         CreateOrUpdateProfile(i->sync_data(), &profiles_map_, &bundle);
    242         break;
    243       case syncer::SyncChange::ACTION_DELETE: {
    244         std::string guid = i->sync_data().GetSpecifics().
    245              autofill_profile().guid();
    246         bundle.profiles_to_delete.push_back(guid);
    247         profiles_map_.erase(guid);
    248       } break;
    249       default:
    250         NOTREACHED() << "Unexpected sync change state.";
    251         return sync_error_factory_->CreateAndUploadError(
    252               FROM_HERE,
    253               "ProcessSyncChanges failed on ChangeType " +
    254                   syncer::SyncChange::ChangeTypeToString(i->change_type()));
    255     }
    256   }
    257 
    258   if (!SaveChangesToWebData(bundle)) {
    259     return sync_error_factory_->CreateAndUploadError(
    260         FROM_HERE,
    261         "Failed to update webdata.");
    262   }
    263 
    264   if (webdata_backend_)
    265     webdata_backend_->NotifyOfMultipleAutofillChanges();
    266 
    267   return syncer::SyncError();
    268 }
    269 
    270 void AutofillProfileSyncableService::AutofillProfileChanged(
    271     const AutofillProfileChange& change) {
    272   // Check if sync is on. If we receive notification prior to the sync being set
    273   // up we are going to process all when MergeData..() is called. If we receive
    274   // notification after the sync exited, it will be sinced next time Chrome
    275   // starts.
    276   if (sync_processor_.get()) {
    277     ActOnChange(change);
    278   } else if (!flare_.is_null()) {
    279     flare_.Run(syncer::AUTOFILL_PROFILE);
    280     flare_.Reset();
    281   }
    282 }
    283 
    284 bool AutofillProfileSyncableService::LoadAutofillData(
    285     std::vector<AutofillProfile*>* profiles) {
    286   return GetAutofillTable()->GetAutofillProfiles(profiles);
    287 }
    288 
    289 bool AutofillProfileSyncableService::SaveChangesToWebData(
    290     const DataBundle& bundle) {
    291   DCHECK(CalledOnValidThread());
    292 
    293   AutofillTable* autofill_table = GetAutofillTable();
    294 
    295   bool success = true;
    296   for (size_t i = 0; i< bundle.profiles_to_delete.size(); ++i) {
    297     if (!autofill_table->RemoveAutofillProfile(bundle.profiles_to_delete[i]))
    298       success = false;
    299   }
    300 
    301   for (size_t i = 0; i < bundle.profiles_to_add.size(); i++) {
    302     if (!autofill_table->AddAutofillProfile(*bundle.profiles_to_add[i]))
    303       success = false;
    304   }
    305 
    306   for (size_t i = 0; i < bundle.profiles_to_update.size(); i++) {
    307     if (!autofill_table->UpdateAutofillProfile(*bundle.profiles_to_update[i]))
    308       success = false;
    309   }
    310   return success;
    311 }
    312 
    313 // static
    314 bool AutofillProfileSyncableService::OverwriteProfileWithServerData(
    315     const sync_pb::AutofillProfileSpecifics& specifics,
    316     AutofillProfile* profile,
    317     const std::string& app_locale) {
    318   bool diff = false;
    319   if (specifics.has_origin() && profile->origin() != specifics.origin()) {
    320     bool was_verified = profile->IsVerified();
    321     profile->set_origin(specifics.origin());
    322     diff = true;
    323 
    324     // Verified profiles should never be overwritten by unverified ones.
    325     DCHECK(!was_verified || profile->IsVerified());
    326   }
    327 
    328   // Update all multivalued fields: names, emails, and phones.
    329   diff = UpdateMultivaluedField(NAME_FIRST,
    330                                 specifics.name_first(), profile) || diff;
    331   diff = UpdateMultivaluedField(NAME_MIDDLE,
    332                                 specifics.name_middle(), profile) || diff;
    333   diff = UpdateMultivaluedField(NAME_LAST,
    334                                 specifics.name_last(), profile) || diff;
    335   // Older versions don't have a separate full name; don't overwrite full name
    336   // in this case.
    337   if (specifics.name_full().size() > 0) {
    338     diff = UpdateMultivaluedField(NAME_FULL,
    339                                   specifics.name_full(), profile) || diff;
    340   }
    341   diff = UpdateMultivaluedField(EMAIL_ADDRESS,
    342                                 specifics.email_address(), profile) || diff;
    343   diff = UpdateMultivaluedField(PHONE_HOME_WHOLE_NUMBER,
    344                                 specifics.phone_home_whole_number(),
    345                                 profile) || diff;
    346 
    347   // Update all simple single-valued address fields.
    348   diff = UpdateField(COMPANY_NAME, specifics.company_name(), profile) || diff;
    349   diff = UpdateField(ADDRESS_HOME_CITY,
    350                      specifics.address_home_city(), profile) || diff;
    351   diff = UpdateField(ADDRESS_HOME_STATE,
    352                      specifics.address_home_state(), profile) || diff;
    353   diff = UpdateField(ADDRESS_HOME_ZIP,
    354                      specifics.address_home_zip(), profile) || diff;
    355   diff = UpdateField(ADDRESS_HOME_SORTING_CODE,
    356                      specifics.address_home_sorting_code(), profile) || diff;
    357   diff = UpdateField(ADDRESS_HOME_DEPENDENT_LOCALITY,
    358                      specifics.address_home_dependent_locality(),
    359                      profile) || diff;
    360 
    361   // Update the country field, which can contain either a country code (if set
    362   // by a newer version of Chrome), or a country name (if set by an older
    363   // version of Chrome).
    364   base::string16 country_name_or_code =
    365       ASCIIToUTF16(specifics.address_home_country());
    366   std::string country_code =
    367       AutofillCountry::GetCountryCode(country_name_or_code, app_locale);
    368   diff = UpdateField(ADDRESS_HOME_COUNTRY, country_code, profile) || diff;
    369 
    370   // Update the street address.  In newer versions of Chrome (M34+), this data
    371   // is stored in the |address_home_street_address| field.  In older versions,
    372   // this data is stored separated out by address line.
    373   if (specifics.has_address_home_street_address()) {
    374     diff = UpdateField(ADDRESS_HOME_STREET_ADDRESS,
    375                        specifics.address_home_street_address(),
    376                        profile) || diff;
    377   } else {
    378     diff = UpdateField(ADDRESS_HOME_LINE1,
    379                        specifics.address_home_line1(), profile) || diff;
    380     diff = UpdateField(ADDRESS_HOME_LINE2,
    381                        specifics.address_home_line2(), profile) || diff;
    382   }
    383 
    384   // Update the BCP 47 language code that can be used to format the address for
    385   // display.
    386   if (specifics.has_address_home_language_code() &&
    387       specifics.address_home_language_code() != profile->language_code()) {
    388     profile->set_language_code(specifics.address_home_language_code());
    389     diff = true;
    390   }
    391 
    392   return diff;
    393 }
    394 
    395 // static
    396 void AutofillProfileSyncableService::WriteAutofillProfile(
    397     const AutofillProfile& profile,
    398     sync_pb::EntitySpecifics* profile_specifics) {
    399   sync_pb::AutofillProfileSpecifics* specifics =
    400       profile_specifics->mutable_autofill_profile();
    401 
    402   DCHECK(base::IsValidGUID(profile.guid()));
    403 
    404   // Reset all multi-valued fields in the protobuf.
    405   specifics->clear_name_first();
    406   specifics->clear_name_middle();
    407   specifics->clear_name_last();
    408   specifics->clear_name_full();
    409   specifics->clear_email_address();
    410   specifics->clear_phone_home_whole_number();
    411 
    412   specifics->set_guid(profile.guid());
    413   specifics->set_origin(profile.origin());
    414 
    415   std::vector<base::string16> values;
    416   profile.GetRawMultiInfo(NAME_FIRST, &values);
    417   for (size_t i = 0; i < values.size(); ++i) {
    418     specifics->add_name_first(LimitData(UTF16ToUTF8(values[i])));
    419   }
    420 
    421   profile.GetRawMultiInfo(NAME_MIDDLE, &values);
    422   for (size_t i = 0; i < values.size(); ++i) {
    423     specifics->add_name_middle(LimitData(UTF16ToUTF8(values[i])));
    424   }
    425 
    426   profile.GetRawMultiInfo(NAME_LAST, &values);
    427   for (size_t i = 0; i < values.size(); ++i) {
    428     specifics->add_name_last(LimitData(UTF16ToUTF8(values[i])));
    429   }
    430 
    431   profile.GetRawMultiInfo(NAME_FULL, &values);
    432   for (size_t i = 0; i < values.size(); ++i) {
    433     specifics->add_name_full(LimitData(UTF16ToUTF8(values[i])));
    434   }
    435 
    436   specifics->set_address_home_line1(
    437       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE1))));
    438   specifics->set_address_home_line2(
    439       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_LINE2))));
    440   specifics->set_address_home_city(
    441       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_CITY))));
    442   specifics->set_address_home_state(
    443       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STATE))));
    444   specifics->set_address_home_zip(
    445       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_ZIP))));
    446   specifics->set_address_home_country(
    447       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))));
    448   specifics->set_address_home_street_address(
    449       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS))));
    450   specifics->set_address_home_sorting_code(
    451       LimitData(UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE))));
    452   specifics->set_address_home_dependent_locality(
    453       LimitData(
    454           UTF16ToUTF8(profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY))));
    455   specifics->set_address_home_language_code(LimitData(profile.language_code()));
    456 
    457   profile.GetRawMultiInfo(EMAIL_ADDRESS, &values);
    458   for (size_t i = 0; i < values.size(); ++i) {
    459     specifics->add_email_address(LimitData(UTF16ToUTF8(values[i])));
    460   }
    461 
    462   specifics->set_company_name(
    463       LimitData(UTF16ToUTF8(profile.GetRawInfo(COMPANY_NAME))));
    464 
    465   profile.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
    466   for (size_t i = 0; i < values.size(); ++i) {
    467     specifics->add_phone_home_whole_number(LimitData(UTF16ToUTF8(values[i])));
    468   }
    469 }
    470 
    471 void AutofillProfileSyncableService::CreateGUIDToProfileMap(
    472     const std::vector<AutofillProfile*>& profiles,
    473     GUIDToProfileMap* profile_map) {
    474   DCHECK(profile_map);
    475   profile_map->clear();
    476   for (size_t i = 0; i < profiles.size(); ++i)
    477     (*profile_map)[profiles[i]->guid()] = profiles[i];
    478 }
    479 
    480 AutofillProfileSyncableService::GUIDToProfileMap::iterator
    481 AutofillProfileSyncableService::CreateOrUpdateProfile(
    482     const syncer::SyncData& data,
    483     GUIDToProfileMap* profile_map,
    484     DataBundle* bundle) {
    485   DCHECK(profile_map);
    486   DCHECK(bundle);
    487 
    488   DCHECK_EQ(syncer::AUTOFILL_PROFILE, data.GetDataType());
    489 
    490   const sync_pb::EntitySpecifics& specifics = data.GetSpecifics();
    491   const sync_pb::AutofillProfileSpecifics& autofill_specifics(
    492       specifics.autofill_profile());
    493 
    494   GUIDToProfileMap::iterator existing_profile = profile_map->find(
    495         autofill_specifics.guid());
    496   if (existing_profile != profile_map->end()) {
    497     // The synced profile already exists locally.  It might need to be updated.
    498     if (OverwriteProfileWithServerData(
    499             autofill_specifics, existing_profile->second, app_locale_)) {
    500       bundle->profiles_to_update.push_back(existing_profile->second);
    501     }
    502     return existing_profile;
    503   }
    504 
    505 
    506   // New profile synced.
    507   AutofillProfile* new_profile = new AutofillProfile(
    508       autofill_specifics.guid(), autofill_specifics.origin());
    509   OverwriteProfileWithServerData(autofill_specifics, new_profile, app_locale_);
    510 
    511   // Check if profile appears under a different guid. Compares only profile
    512   // contents. (Ignores origin and language code in comparison.)
    513   //
    514   // Unverified profiles should never overwrite verified ones.
    515   for (GUIDToProfileMap::iterator it = profile_map->begin();
    516        it != profile_map->end(); ++it) {
    517     AutofillProfile* local_profile = it->second;
    518     if (local_profile->Compare(*new_profile) == 0) {
    519       // Ensure that a verified profile can never revert back to an unverified
    520       // one.
    521       if (local_profile->IsVerified() && !new_profile->IsVerified()) {
    522         new_profile->set_origin(local_profile->origin());
    523         bundle->profiles_to_sync_back.push_back(new_profile);
    524       }
    525 
    526       bundle->profiles_to_delete.push_back(local_profile->guid());
    527       DVLOG(2) << "[AUTOFILL SYNC]"
    528                << "Found in sync db but with a different guid: "
    529                << UTF16ToUTF8(local_profile->GetRawInfo(NAME_FIRST))
    530                << UTF16ToUTF8(local_profile->GetRawInfo(NAME_LAST))
    531                << "New guid " << new_profile->guid()
    532                << ". Profile to be deleted " << local_profile->guid();
    533       profile_map->erase(it);
    534       break;
    535     } else if (!local_profile->IsVerified() &&
    536                !new_profile->IsVerified() &&
    537                !local_profile->PrimaryValue().empty() &&
    538                local_profile->PrimaryValue() == new_profile->PrimaryValue()) {
    539       // Add it to candidates for merge - if there is no profile with this
    540       // guid we will merge them.
    541       bundle->candidates_to_merge.insert(
    542           std::make_pair(local_profile->guid(), new_profile));
    543     }
    544   }
    545   profiles_.push_back(new_profile);
    546   bundle->profiles_to_add.push_back(new_profile);
    547   return profile_map->insert(std::make_pair(new_profile->guid(),
    548                                             new_profile)).first;
    549 }
    550 
    551 void AutofillProfileSyncableService::ActOnChange(
    552      const AutofillProfileChange& change) {
    553   DCHECK((change.type() == AutofillProfileChange::REMOVE &&
    554           !change.profile()) ||
    555          (change.type() != AutofillProfileChange::REMOVE && change.profile()));
    556   DCHECK(sync_processor_.get());
    557   syncer::SyncChangeList new_changes;
    558   DataBundle bundle;
    559   switch (change.type()) {
    560     case AutofillProfileChange::ADD:
    561       new_changes.push_back(
    562           syncer::SyncChange(FROM_HERE,
    563                              syncer::SyncChange::ACTION_ADD,
    564                              CreateData(*(change.profile()))));
    565       DCHECK(profiles_map_.find(change.profile()->guid()) ==
    566              profiles_map_.end());
    567       profiles_.push_back(new AutofillProfile(*(change.profile())));
    568       profiles_map_[change.profile()->guid()] = profiles_.get().back();
    569       break;
    570     case AutofillProfileChange::UPDATE: {
    571       GUIDToProfileMap::iterator it = profiles_map_.find(
    572           change.profile()->guid());
    573       DCHECK(it != profiles_map_.end());
    574       *(it->second) = *(change.profile());
    575       new_changes.push_back(
    576           syncer::SyncChange(FROM_HERE,
    577                              syncer::SyncChange::ACTION_UPDATE,
    578                              CreateData(*(change.profile()))));
    579       break;
    580     }
    581     case AutofillProfileChange::REMOVE: {
    582       AutofillProfile empty_profile(change.key(), std::string());
    583       new_changes.push_back(
    584           syncer::SyncChange(FROM_HERE,
    585                              syncer::SyncChange::ACTION_DELETE,
    586                              CreateData(empty_profile)));
    587       profiles_map_.erase(change.key());
    588       break;
    589     }
    590     default:
    591       NOTREACHED();
    592   }
    593   syncer::SyncError error =
    594       sync_processor_->ProcessSyncChanges(FROM_HERE, new_changes);
    595   if (error.IsSet()) {
    596     // TODO(isherman): Investigating http://crbug.com/121592
    597     VLOG(1) << "[AUTOFILL SYNC] "
    598             << "Failed processing change:\n"
    599             << "  Error: " << error.message() << "\n"
    600             << "  Guid: " << change.key();
    601   }
    602 }
    603 
    604 syncer::SyncData AutofillProfileSyncableService::CreateData(
    605     const AutofillProfile& profile) {
    606   sync_pb::EntitySpecifics specifics;
    607   WriteAutofillProfile(profile, &specifics);
    608   return
    609       syncer::SyncData::CreateLocalData(
    610           profile.guid(), profile.guid(), specifics);
    611 }
    612 
    613 bool AutofillProfileSyncableService::UpdateField(
    614     ServerFieldType field_type,
    615     const std::string& new_value,
    616     AutofillProfile* autofill_profile) {
    617   if (UTF16ToUTF8(autofill_profile->GetRawInfo(field_type)) == new_value)
    618     return false;
    619   autofill_profile->SetRawInfo(field_type, UTF8ToUTF16(new_value));
    620   return true;
    621 }
    622 
    623 bool AutofillProfileSyncableService::UpdateMultivaluedField(
    624     ServerFieldType field_type,
    625     const ::google::protobuf::RepeatedPtrField<std::string>& new_values,
    626     AutofillProfile* autofill_profile) {
    627   std::vector<base::string16> values;
    628   autofill_profile->GetRawMultiInfo(field_type, &values);
    629   bool changed = false;
    630   if (static_cast<size_t>(new_values.size()) != values.size()) {
    631     values.clear();
    632     values.resize(static_cast<size_t>(new_values.size()));
    633     changed = true;
    634   }
    635   for (size_t i = 0; i < values.size(); ++i) {
    636     base::string16 synced_value(
    637         UTF8ToUTF16(new_values.Get(static_cast<int>(i))));
    638     if (values[i] != synced_value) {
    639       values[i] = synced_value;
    640       changed = true;
    641     }
    642   }
    643   if (changed)
    644     autofill_profile->SetRawMultiInfo(field_type, values);
    645   return changed;
    646 }
    647 
    648 bool AutofillProfileSyncableService::MergeProfile(
    649     const AutofillProfile& merge_from,
    650     AutofillProfile* merge_into,
    651     const std::string& app_locale) {
    652   // Overwrites all single values and adds to mutli-values. Does not overwrite
    653   // GUID.
    654   merge_into->OverwriteWithOrAddTo(merge_from, app_locale);
    655   return !merge_into->EqualsSansGuid(merge_from);
    656 }
    657 
    658 AutofillTable* AutofillProfileSyncableService::GetAutofillTable() const {
    659   return AutofillTable::FromWebDatabase(webdata_backend_->GetDatabase());
    660 }
    661 
    662 void AutofillProfileSyncableService::InjectStartSyncFlare(
    663     const syncer::SyncableService::StartSyncFlare& flare) {
    664   flare_ = flare;
    665 }
    666 
    667 AutofillProfileSyncableService::DataBundle::DataBundle() {}
    668 
    669 AutofillProfileSyncableService::DataBundle::~DataBundle() {}
    670 
    671 }  // namespace autofill
    672