components/autofill/core/browser/webdata/autofill_profile_syncable_service_unittest.cc

   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 "base/location.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "components/autofill/core/browser/autofill_profile.h"
   9 #include "components/autofill/core/browser/webdata/autofill_change.h"
  10 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
  11 #include "sync/api/sync_error_factory.h"
  12 #include "sync/api/sync_error_factory_mock.h"
  13 #include "sync/protocol/sync.pb.h"
  14 #include "testing/gmock/include/gmock/gmock.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace autofill {
  18
  19 using ::testing::_;
  20 using ::testing::DoAll;
  21 using ::testing::Eq;
  22 using ::testing::Return;
  23 using ::testing::Property;
  24 using base::ASCIIToUTF16;
  25
  26 namespace {
  27
  28 // Some guids for testing.
  29 const char kGuid1[] = "EDC609ED-7EEE-4F27-B00C-423242A9C44B";
  30 const char kGuid2[] = "EDC609ED-7EEE-4F27-B00C-423242A9C44C";
  31 const char kGuid3[] = "EDC609ED-7EEE-4F27-B00C-423242A9C44D";
  32 const char kGuid4[] = "EDC609ED-7EEE-4F27-B00C-423242A9C44E";
  33 const char kHttpOrigin[] = "http://www.example.com/";
  34 const char kHttpsOrigin[] = "https://www.example.com/";
  35 const char kSettingsOrigin[] = "Chrome settings";
  36
  37 class MockAutofillProfileSyncableService
  38     : public AutofillProfileSyncableService {
  39  public:
  40   MockAutofillProfileSyncableService() {}
  41   virtual ~MockAutofillProfileSyncableService() {}
  42
  43   using AutofillProfileSyncableService::DataBundle;
  44   using AutofillProfileSyncableService::set_sync_processor;
  45   using AutofillProfileSyncableService::CreateData;
  46
  47   MOCK_METHOD1(LoadAutofillData, bool(std::vector<AutofillProfile*>*));
  48   MOCK_METHOD1(SaveChangesToWebData,
  49                bool(const AutofillProfileSyncableService::DataBundle&));
  50 };
  51
  52 ACTION_P(CopyData, data) {
  53   arg0->resize(data->size());
  54   std::copy(data->begin(), data->end(), arg0->begin());
  55 }
  56
  57 MATCHER_P(CheckSyncChanges, n_sync_changes_list, "") {
  58   if (arg.size() != n_sync_changes_list.size())
  59     return false;
  60   syncer::SyncChangeList::const_iterator passed, expected;
  61   for (passed = arg.begin(), expected = n_sync_changes_list.begin();
  62        passed != arg.end() && expected != n_sync_changes_list.end();
  63        ++passed, ++expected) {
  64     DCHECK(passed->IsValid());
  65     if (passed->change_type() != expected->change_type())
  66       return false;
  67     if (passed->sync_data().GetSpecifics().SerializeAsString() !=
  68             expected->sync_data().GetSpecifics().SerializeAsString()) {
  69       return false;
  70     }
  71   }
  72   return true;
  73 }
  74
  75 MATCHER_P(DataBundleCheck, n_bundle, "") {
  76   if ((arg.profiles_to_delete.size() != n_bundle.profiles_to_delete.size()) ||
  77       (arg.profiles_to_update.size() != n_bundle.profiles_to_update.size()) ||
  78       (arg.profiles_to_add.size() != n_bundle.profiles_to_add.size()))
  79     return false;
  80   for (size_t i = 0; i < arg.profiles_to_delete.size(); ++i) {
  81     if (arg.profiles_to_delete[i] != n_bundle.profiles_to_delete[i])
  82       return false;
  83   }
  84   for (size_t i = 0; i < arg.profiles_to_update.size(); ++i) {
  85     if (*arg.profiles_to_update[i] != *n_bundle.profiles_to_update[i])
  86       return false;
  87   }
  88   for (size_t i = 0; i < arg.profiles_to_add.size(); ++i) {
  89     if (*arg.profiles_to_add[i] != *n_bundle.profiles_to_add[i])
  90       return false;
  91   }
  92   return true;
  93 }
  94
  95 class MockSyncChangeProcessor : public syncer::SyncChangeProcessor {
  96  public:
  97   MockSyncChangeProcessor() {}
  98   virtual ~MockSyncChangeProcessor() {}
  99
 100   MOCK_METHOD2(ProcessSyncChanges,
 101                syncer::SyncError(const tracked_objects::Location&,
 102                                  const syncer::SyncChangeList&));
 103   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type)
 104       const OVERRIDE { return syncer::SyncDataList(); }
 105 };
 106
 107 class TestSyncChangeProcessor : public syncer::SyncChangeProcessor {
 108  public:
 109   TestSyncChangeProcessor() {}
 110   virtual ~TestSyncChangeProcessor() {}
 111
 112   virtual syncer::SyncError ProcessSyncChanges(
 113       const tracked_objects::Location& location,
 114       const syncer::SyncChangeList& changes) OVERRIDE {
 115     changes_ = changes;
 116     return syncer::SyncError();
 117   }
 118
 119   virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
 120       OVERRIDE {
 121     return syncer::SyncDataList();
 122   }
 123
 124   const syncer::SyncChangeList& changes() { return changes_; }
 125
 126  private:
 127   syncer::SyncChangeList changes_;
 128 };
 129
 130 // Returns a profile with all fields set.  Contains identical data to the data
 131 // returned from ConstructCompleteSyncData().
 132 scoped_ptr<AutofillProfile> ConstructCompleteProfile() {
 133   scoped_ptr<AutofillProfile> profile(
 134       new AutofillProfile(kGuid1, kHttpsOrigin));
 135
 136   std::vector<base::string16> names;
 137   names.push_back(ASCIIToUTF16("John K. Doe, Jr."));
 138   names.push_back(ASCIIToUTF16("Jane Luise Smith MD"));
 139   profile->SetRawMultiInfo(NAME_FULL, names);
 140   names.clear();
 141   names.push_back(ASCIIToUTF16("John"));
 142   names.push_back(ASCIIToUTF16("Jane"));
 143   profile->SetRawMultiInfo(NAME_FIRST, names);
 144   names.clear();
 145   names.push_back(ASCIIToUTF16("K."));
 146   names.push_back(ASCIIToUTF16("Luise"));
 147   profile->SetRawMultiInfo(NAME_MIDDLE, names);
 148   names.clear();
 149   names.push_back(ASCIIToUTF16("Doe"));
 150   names.push_back(ASCIIToUTF16("Smith"));
 151   profile->SetRawMultiInfo(NAME_LAST, names);
 152
 153   std::vector<base::string16> emails;
 154   emails.push_back(ASCIIToUTF16("user@example.com"));
 155   emails.push_back(ASCIIToUTF16("superuser@example.org"));
 156   profile->SetRawMultiInfo(EMAIL_ADDRESS, emails);
 157
 158   std::vector<base::string16> phones;
 159   phones.push_back(ASCIIToUTF16("1.800.555.1234"));
 160   phones.push_back(ASCIIToUTF16("1.866.650.0000"));
 161   profile->SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, phones);
 162
 163   profile->SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
 164                       ASCIIToUTF16("123 Fake St.\n"
 165                                    "Apt. 42"));
 166   EXPECT_EQ(ASCIIToUTF16("123 Fake St."),
 167             profile->GetRawInfo(ADDRESS_HOME_LINE1));
 168   EXPECT_EQ(ASCIIToUTF16("Apt. 42"), profile->GetRawInfo(ADDRESS_HOME_LINE2));
 169
 170   profile->SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Google, Inc."));
 171   profile->SetRawInfo(ADDRESS_HOME_CITY, ASCIIToUTF16("Mountain View"));
 172   profile->SetRawInfo(ADDRESS_HOME_STATE, ASCIIToUTF16("California"));
 173   profile->SetRawInfo(ADDRESS_HOME_ZIP, ASCIIToUTF16("94043"));
 174   profile->SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
 175   profile->SetRawInfo(ADDRESS_HOME_SORTING_CODE, ASCIIToUTF16("CEDEX"));
 176   profile->SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY,
 177                       ASCIIToUTF16("Santa Clara"));
 178   profile->set_language_code("en");
 179   return profile.Pass();
 180 }
 181
 182 // Returns SyncData with all Autofill profile fields set.  Contains identical
 183 // data to the data returned from ConstructCompleteProfile().
 184 syncer::SyncData ConstructCompleteSyncData() {
 185   sync_pb::EntitySpecifics entity_specifics;
 186   sync_pb::AutofillProfileSpecifics* specifics =
 187       entity_specifics.mutable_autofill_profile();
 188
 189   specifics->set_guid(kGuid1);
 190   specifics->set_origin(kHttpsOrigin);
 191
 192   specifics->add_name_first("John");
 193   specifics->add_name_middle("K.");
 194   specifics->add_name_last("Doe");
 195   specifics->add_name_full("John K. Doe, Jr.");
 196
 197   specifics->add_name_first("Jane");
 198   specifics->add_name_middle("Luise");
 199   specifics->add_name_last("Smith");
 200   specifics->add_name_full("Jane Luise Smith MD");
 201
 202   specifics->add_email_address("user@example.com");
 203   specifics->add_email_address("superuser@example.org");
 204
 205   specifics->add_phone_home_whole_number("1.800.555.1234");
 206   specifics->add_phone_home_whole_number("1.866.650.0000");
 207
 208   specifics->set_address_home_line1("123 Fake St.");
 209   specifics->set_address_home_line2("Apt. 42");
 210   specifics->set_address_home_street_address("123 Fake St.\n"
 211                                              "Apt. 42");
 212
 213   specifics->set_company_name("Google, Inc.");
 214   specifics->set_address_home_city("Mountain View");
 215   specifics->set_address_home_state("California");
 216   specifics->set_address_home_zip("94043");
 217   specifics->set_address_home_country("US");
 218   specifics->set_address_home_sorting_code("CEDEX");
 219   specifics->set_address_home_dependent_locality("Santa Clara");
 220   specifics->set_address_home_language_code("en");
 221
 222   return syncer::SyncData::CreateLocalData(kGuid1, kGuid1, entity_specifics);
 223 }
 224
 225 }  // namespace
 226
 227 class AutofillProfileSyncableServiceTest : public testing::Test {
 228  public:
 229   AutofillProfileSyncableServiceTest() {}
 230
 231   virtual void SetUp() OVERRIDE {
 232     sync_processor_.reset(new MockSyncChangeProcessor);
 233   }
 234
 235   // Wrapper around AutofillProfileSyncableService::MergeDataAndStartSyncing()
 236   // that also verifies expectations.
 237   void MergeDataAndStartSyncing(
 238       const std::vector<AutofillProfile*>& profiles_from_web_db,
 239       const syncer::SyncDataList& data_list,
 240       const MockAutofillProfileSyncableService::DataBundle& expected_bundle,
 241       const syncer::SyncChangeList& expected_change_list) {
 242     EXPECT_CALL(autofill_syncable_service_, LoadAutofillData(_))
 243         .Times(1)
 244         .WillOnce(DoAll(CopyData(&profiles_from_web_db), Return(true)));
 245     EXPECT_CALL(autofill_syncable_service_,
 246                 SaveChangesToWebData(DataBundleCheck(expected_bundle)))
 247         .Times(1)
 248         .WillOnce(Return(true));
 249     if (expected_change_list.empty()) {
 250       EXPECT_CALL(*sync_processor_, ProcessSyncChanges(_, _)).Times(0);
 251     } else {
 252       ON_CALL(*sync_processor_, ProcessSyncChanges(_, _))
 253           .WillByDefault(Return(syncer::SyncError()));
 254       EXPECT_CALL(*sync_processor_,
 255                   ProcessSyncChanges(_, CheckSyncChanges(expected_change_list)))
 256           .Times(1)
 257           .WillOnce(Return(syncer::SyncError()));
 258     }
 259
 260     // Takes ownership of sync_processor_.
 261     autofill_syncable_service_.MergeDataAndStartSyncing(
 262         syncer::AUTOFILL_PROFILE, data_list,
 263         sync_processor_.PassAs<syncer::SyncChangeProcessor>(),
 264         scoped_ptr<syncer::SyncErrorFactory>(
 265             new syncer::SyncErrorFactoryMock()));
 266   }
 267
 268  protected:
 269   base::MessageLoop message_loop_;
 270   MockAutofillProfileSyncableService autofill_syncable_service_;
 271   scoped_ptr<MockSyncChangeProcessor> sync_processor_;
 272 };
 273
 274 TEST_F(AutofillProfileSyncableServiceTest, MergeDataAndStartSyncing) {
 275   std::vector<AutofillProfile*> profiles_from_web_db;
 276   std::string guid_present1 = kGuid1;
 277   std::string guid_present2 = kGuid2;
 278   std::string guid_synced1 = kGuid3;
 279   std::string guid_synced2 = kGuid4;
 280   std::string origin_present1 = kHttpOrigin;
 281   std::string origin_present2 = std::string();
 282   std::string origin_synced1 = kHttpsOrigin;
 283   std::string origin_synced2 = kSettingsOrigin;
 284
 285   profiles_from_web_db.push_back(
 286       new AutofillProfile(guid_present1, origin_present1));
 287   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 288   profiles_from_web_db.back()->SetRawInfo(ADDRESS_HOME_LINE1,
 289                                           ASCIIToUTF16("1 1st st"));
 290   profiles_from_web_db.push_back(
 291       new AutofillProfile(guid_present2, origin_present2));
 292   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("Tom"));
 293   profiles_from_web_db.back()->SetRawInfo(ADDRESS_HOME_LINE1,
 294                                           ASCIIToUTF16("2 2nd st"));
 295
 296   syncer::SyncDataList data_list;
 297   AutofillProfile profile1(guid_synced1, origin_synced1);
 298   profile1.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
 299   data_list.push_back(autofill_syncable_service_.CreateData(profile1));
 300   AutofillProfile profile2(guid_synced2, origin_synced2);
 301   profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Harry"));
 302   data_list.push_back(autofill_syncable_service_.CreateData(profile2));
 303   // This one will have the name and origin updated.
 304   AutofillProfile profile3(guid_present2, origin_synced2);
 305   profile3.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Tom Doe"));
 306   data_list.push_back(autofill_syncable_service_.CreateData(profile3));
 307
 308   syncer::SyncChangeList expected_change_list;
 309   expected_change_list.push_back(
 310       syncer::SyncChange(FROM_HERE,
 311                          syncer::SyncChange::ACTION_ADD,
 312                          MockAutofillProfileSyncableService::CreateData(
 313                              *profiles_from_web_db.front())));
 314
 315   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 316   expected_bundle.profiles_to_add.push_back(&profile1);
 317   expected_bundle.profiles_to_add.push_back(&profile2);
 318   expected_bundle.profiles_to_update.push_back(&profile3);
 319
 320   MergeDataAndStartSyncing(
 321       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 322   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 323 }
 324
 325 TEST_F(AutofillProfileSyncableServiceTest, MergeIdenticalProfiles) {
 326   std::vector<AutofillProfile*> profiles_from_web_db;
 327   std::string guid_present1 = kGuid1;
 328   std::string guid_present2 = kGuid2;
 329   std::string guid_synced1 = kGuid3;
 330   std::string guid_synced2 = kGuid4;
 331   std::string origin_present1 = kHttpOrigin;
 332   std::string origin_present2 = kSettingsOrigin;
 333   std::string origin_synced1 = kHttpsOrigin;
 334   std::string origin_synced2 = kHttpsOrigin;
 335
 336   profiles_from_web_db.push_back(
 337       new AutofillProfile(guid_present1, origin_present1));
 338   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 339   profiles_from_web_db.back()->SetRawInfo(ADDRESS_HOME_LINE1,
 340                                           ASCIIToUTF16("1 1st st"));
 341   profiles_from_web_db.push_back(
 342       new AutofillProfile(guid_present2, origin_present2));
 343   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("Tom"));
 344   profiles_from_web_db.back()->SetRawInfo(ADDRESS_HOME_LINE1,
 345                                           ASCIIToUTF16("2 2nd st"));
 346
 347   // The synced profiles are identical to the local ones, except that the guids
 348   // are different.
 349   syncer::SyncDataList data_list;
 350   AutofillProfile profile1(guid_synced1, origin_synced1);
 351   profile1.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 352   profile1.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1 1st st"));
 353   data_list.push_back(autofill_syncable_service_.CreateData(profile1));
 354   AutofillProfile profile2(guid_synced2, origin_synced2);
 355   profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Tom"));
 356   profile2.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("2 2nd st"));
 357   data_list.push_back(autofill_syncable_service_.CreateData(profile2));
 358
 359   AutofillProfile expected_profile(profile2);
 360   expected_profile.set_origin(kSettingsOrigin);
 361   syncer::SyncChangeList expected_change_list;
 362   expected_change_list.push_back(
 363       syncer::SyncChange(FROM_HERE,
 364                          syncer::SyncChange::ACTION_UPDATE,
 365                          MockAutofillProfileSyncableService::CreateData(
 366                              expected_profile)));
 367
 368   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 369   expected_bundle.profiles_to_delete.push_back(guid_present1);
 370   expected_bundle.profiles_to_delete.push_back(guid_present2);
 371   expected_bundle.profiles_to_add.push_back(&profile1);
 372   expected_bundle.profiles_to_add.push_back(&expected_profile);
 373
 374   MergeDataAndStartSyncing(
 375       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 376   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 377 }
 378
 379 TEST_F(AutofillProfileSyncableServiceTest, MergeSimilarProfiles) {
 380   std::vector<AutofillProfile*> profiles_from_web_db;
 381   std::string guid_present1 = kGuid1;
 382   std::string guid_present2 = kGuid2;
 383   std::string guid_synced1 = kGuid3;
 384   std::string guid_synced2 = kGuid4;
 385   std::string origin_present1 = kHttpOrigin;
 386   std::string origin_present2 = kSettingsOrigin;
 387   std::string origin_synced1 = kHttpsOrigin;
 388   std::string origin_synced2 = kHttpsOrigin;
 389
 390   profiles_from_web_db.push_back(
 391       new AutofillProfile(guid_present1, origin_present1));
 392   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 393   profiles_from_web_db.back()->SetRawInfo(ADDRESS_HOME_LINE1,
 394                                           ASCIIToUTF16("1 1st st"));
 395   profiles_from_web_db.push_back(
 396       new AutofillProfile(guid_present2, origin_present2));
 397   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("Tom"));
 398   profiles_from_web_db.back()->SetRawInfo(ADDRESS_HOME_LINE1,
 399                                           ASCIIToUTF16("2 2nd st"));
 400
 401   // The synced profiles are identical to the local ones, except that the guids
 402   // are different.
 403   syncer::SyncDataList data_list;
 404   AutofillProfile profile1(guid_synced1, origin_synced1);
 405   profile1.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 406   profile1.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1 1st st"));
 407   profile1.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Frobbers, Inc."));
 408   data_list.push_back(autofill_syncable_service_.CreateData(profile1));
 409   AutofillProfile profile2(guid_synced2, origin_synced2);
 410   profile2.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Tom"));
 411   profile2.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("2 2nd st"));
 412   profile2.SetRawInfo(COMPANY_NAME, ASCIIToUTF16("Fizzbang, LLC."));
 413   data_list.push_back(autofill_syncable_service_.CreateData(profile2));
 414
 415   // The first profile should have its origin updated.
 416   // The second profile should remain as-is, because an unverified profile
 417   // should never overwrite a verified one.
 418   AutofillProfile expected_profile(profile1);
 419   expected_profile.set_origin(origin_present1);
 420   syncer::SyncChangeList expected_change_list;
 421   expected_change_list.push_back(
 422       syncer::SyncChange(FROM_HERE,
 423                          syncer::SyncChange::ACTION_ADD,
 424                          MockAutofillProfileSyncableService::CreateData(
 425                              *profiles_from_web_db.back())));
 426   expected_change_list.push_back(
 427       syncer::SyncChange(FROM_HERE,
 428                          syncer::SyncChange::ACTION_UPDATE,
 429                          MockAutofillProfileSyncableService::CreateData(
 430                              expected_profile)));
 431
 432   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 433   expected_bundle.profiles_to_delete.push_back(guid_present1);
 434   expected_bundle.profiles_to_add.push_back(&expected_profile);
 435   expected_bundle.profiles_to_add.push_back(&profile2);
 436
 437   MergeDataAndStartSyncing(
 438       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 439   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 440 }
 441
 442 // Ensure that no Sync events are generated to fill in missing origins from Sync
 443 // with explicitly present empty ones.  This ensures that the migration to add
 444 // origins to profiles does not generate lots of needless Sync updates.
 445 TEST_F(AutofillProfileSyncableServiceTest, MergeDataEmptyOrigins) {
 446   std::vector<AutofillProfile*> profiles_from_web_db;
 447
 448   // Create a profile with an empty origin.
 449   AutofillProfile profile(kGuid1, std::string());
 450   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 451   profile.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("1 1st st"));
 452
 453   profiles_from_web_db.push_back(new AutofillProfile(profile));
 454
 455   // Create a Sync profile identical to |profile|, except with no origin set.
 456   sync_pb::EntitySpecifics specifics;
 457   sync_pb::AutofillProfileSpecifics* autofill_specifics =
 458       specifics.mutable_autofill_profile();
 459   autofill_specifics->set_guid(profile.guid());
 460   autofill_specifics->add_name_first("John");
 461   autofill_specifics->add_name_middle(std::string());
 462   autofill_specifics->add_name_last(std::string());
 463   autofill_specifics->add_name_full(std::string());
 464   autofill_specifics->add_email_address(std::string());
 465   autofill_specifics->add_phone_home_whole_number(std::string());
 466   autofill_specifics->set_address_home_line1("1 1st st");
 467   EXPECT_FALSE(autofill_specifics->has_origin());
 468
 469   syncer::SyncDataList data_list;
 470   data_list.push_back(
 471       syncer::SyncData::CreateLocalData(
 472           profile.guid(), profile.guid(), specifics));
 473
 474   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 475   syncer::SyncChangeList expected_change_list;
 476   MergeDataAndStartSyncing(
 477       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 478   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 479 }
 480
 481 TEST_F(AutofillProfileSyncableServiceTest, GetAllSyncData) {
 482   std::vector<AutofillProfile*> profiles_from_web_db;
 483   std::string guid_present1 = kGuid1;
 484   std::string guid_present2 = kGuid2;
 485
 486   profiles_from_web_db.push_back(
 487       new AutofillProfile(guid_present1, kHttpOrigin));
 488   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 489   profiles_from_web_db.push_back(
 490       new AutofillProfile(guid_present2, kHttpsOrigin));
 491   profiles_from_web_db.back()->SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
 492
 493   syncer::SyncChangeList expected_change_list;
 494   expected_change_list.push_back(
 495       syncer::SyncChange(FROM_HERE,
 496                          syncer::SyncChange::ACTION_ADD,
 497                          MockAutofillProfileSyncableService::CreateData(
 498                              *profiles_from_web_db.front())));
 499   expected_change_list.push_back(
 500       syncer::SyncChange(FROM_HERE,
 501                          syncer::SyncChange::ACTION_ADD,
 502                          MockAutofillProfileSyncableService::CreateData(
 503                              *profiles_from_web_db.back())));
 504
 505   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 506   syncer::SyncDataList data_list;
 507   MergeDataAndStartSyncing(
 508       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 509
 510   syncer::SyncDataList data =
 511       autofill_syncable_service_.GetAllSyncData(syncer::AUTOFILL_PROFILE);
 512
 513   ASSERT_EQ(2U, data.size());
 514   EXPECT_EQ(guid_present1, data[0].GetSpecifics().autofill_profile().guid());
 515   EXPECT_EQ(guid_present2, data[1].GetSpecifics().autofill_profile().guid());
 516   EXPECT_EQ(kHttpOrigin, data[0].GetSpecifics().autofill_profile().origin());
 517   EXPECT_EQ(kHttpsOrigin, data[1].GetSpecifics().autofill_profile().origin());
 518
 519   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 520 }
 521
 522 TEST_F(AutofillProfileSyncableServiceTest, ProcessSyncChanges) {
 523   std::vector<AutofillProfile *> profiles_from_web_db;
 524   std::string guid_present = kGuid1;
 525   std::string guid_synced = kGuid2;
 526
 527   syncer::SyncChangeList change_list;
 528   AutofillProfile profile(guid_synced, kHttpOrigin);
 529   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
 530   change_list.push_back(
 531       syncer::SyncChange(
 532           FROM_HERE,
 533           syncer::SyncChange::ACTION_ADD,
 534           MockAutofillProfileSyncableService::CreateData(profile)));
 535   AutofillProfile empty_profile(guid_present, kHttpsOrigin);
 536   change_list.push_back(
 537       syncer::SyncChange(
 538           FROM_HERE,
 539           syncer::SyncChange::ACTION_DELETE,
 540           MockAutofillProfileSyncableService::CreateData(empty_profile)));
 541
 542   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 543   expected_bundle.profiles_to_delete.push_back(guid_present);
 544   expected_bundle.profiles_to_add.push_back(&profile);
 545
 546   EXPECT_CALL(autofill_syncable_service_, SaveChangesToWebData(
 547               DataBundleCheck(expected_bundle)))
 548       .Times(1)
 549       .WillOnce(Return(true));
 550
 551   autofill_syncable_service_.set_sync_processor(sync_processor_.release());
 552   syncer::SyncError error = autofill_syncable_service_.ProcessSyncChanges(
 553       FROM_HERE, change_list);
 554
 555   EXPECT_FALSE(error.IsSet());
 556 }
 557
 558 TEST_F(AutofillProfileSyncableServiceTest, AutofillProfileAdded) {
 559   // Will be owned by the syncable service.  Keep a reference available here for
 560   // verifying test expectations.
 561   TestSyncChangeProcessor* sync_change_processor = new TestSyncChangeProcessor;
 562   autofill_syncable_service_.set_sync_processor(sync_change_processor);
 563
 564   AutofillProfile profile(kGuid1, kHttpsOrigin);
 565   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Jane"));
 566   AutofillProfileChange change(AutofillProfileChange::ADD, kGuid1, &profile);
 567   autofill_syncable_service_.AutofillProfileChanged(change);
 568
 569   ASSERT_EQ(1U, sync_change_processor->changes().size());
 570   syncer::SyncChange result = sync_change_processor->changes()[0];
 571   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, result.change_type());
 572
 573   sync_pb::AutofillProfileSpecifics specifics =
 574       result.sync_data().GetSpecifics().autofill_profile();
 575   EXPECT_EQ(kGuid1, specifics.guid());
 576   EXPECT_EQ(kHttpsOrigin, specifics.origin());
 577   EXPECT_THAT(specifics.name_first(), testing::ElementsAre("Jane"));
 578 }
 579
 580 TEST_F(AutofillProfileSyncableServiceTest, AutofillProfileDeleted) {
 581   // Will be owned by the syncable service.  Keep a reference available here for
 582   // verifying test expectations.
 583   TestSyncChangeProcessor* sync_change_processor = new TestSyncChangeProcessor;
 584   autofill_syncable_service_.set_sync_processor(sync_change_processor);
 585
 586   AutofillProfileChange change(AutofillProfileChange::REMOVE, kGuid2, NULL);
 587   autofill_syncable_service_.AutofillProfileChanged(change);
 588
 589   ASSERT_EQ(1U, sync_change_processor->changes().size());
 590   syncer::SyncChange result = sync_change_processor->changes()[0];
 591   EXPECT_EQ(syncer::SyncChange::ACTION_DELETE, result.change_type());
 592   sync_pb::AutofillProfileSpecifics specifics =
 593       result.sync_data().GetSpecifics().autofill_profile();
 594   EXPECT_EQ(kGuid2, specifics.guid());
 595 }
 596
 597 TEST_F(AutofillProfileSyncableServiceTest, UpdateField) {
 598   AutofillProfile profile(kGuid1, kSettingsOrigin);
 599   std::string company1 = "A Company";
 600   std::string company2 = "Another Company";
 601   profile.SetRawInfo(COMPANY_NAME, ASCIIToUTF16(company1));
 602   EXPECT_FALSE(AutofillProfileSyncableService::UpdateField(
 603       COMPANY_NAME, company1, &profile));
 604   EXPECT_EQ(profile.GetRawInfo(COMPANY_NAME), ASCIIToUTF16(company1));
 605   EXPECT_TRUE(AutofillProfileSyncableService::UpdateField(
 606       COMPANY_NAME, company2, &profile));
 607   EXPECT_EQ(profile.GetRawInfo(COMPANY_NAME), ASCIIToUTF16(company2));
 608   EXPECT_FALSE(AutofillProfileSyncableService::UpdateField(
 609       COMPANY_NAME, company2, &profile));
 610   EXPECT_EQ(profile.GetRawInfo(COMPANY_NAME), ASCIIToUTF16(company2));
 611 }
 612
 613 TEST_F(AutofillProfileSyncableServiceTest, UpdateMultivaluedField) {
 614   AutofillProfile profile(kGuid1, kHttpsOrigin);
 615
 616   std::vector<base::string16> values;
 617   values.push_back(ASCIIToUTF16("1@1.com"));
 618   values.push_back(ASCIIToUTF16("2@1.com"));
 619   profile.SetRawMultiInfo(EMAIL_ADDRESS, values);
 620
 621   ::google::protobuf::RepeatedPtrField<std::string> specifics_fields;
 622   specifics_fields.AddAllocated(new std::string("2@1.com"));
 623   specifics_fields.AddAllocated(new std::string("3@1.com"));
 624
 625   EXPECT_TRUE(AutofillProfileSyncableService::UpdateMultivaluedField(
 626       EMAIL_ADDRESS, specifics_fields, &profile));
 627   profile.GetRawMultiInfo(EMAIL_ADDRESS, &values);
 628   ASSERT_TRUE(values.size() == 2);
 629   EXPECT_EQ(values[0], ASCIIToUTF16("2@1.com"));
 630   EXPECT_EQ(values[1], ASCIIToUTF16("3@1.com"));
 631
 632   EXPECT_FALSE(AutofillProfileSyncableService::UpdateMultivaluedField(
 633       EMAIL_ADDRESS, specifics_fields, &profile));
 634   profile.GetRawMultiInfo(EMAIL_ADDRESS, &values);
 635   ASSERT_EQ(values.size(), 2U);
 636   EXPECT_EQ(values[0], ASCIIToUTF16("2@1.com"));
 637   EXPECT_EQ(values[1], ASCIIToUTF16("3@1.com"));
 638   EXPECT_TRUE(AutofillProfileSyncableService::UpdateMultivaluedField(
 639       EMAIL_ADDRESS, ::google::protobuf::RepeatedPtrField<std::string>(),
 640       &profile));
 641   profile.GetRawMultiInfo(EMAIL_ADDRESS, &values);
 642   ASSERT_EQ(values.size(), 1U);  // Always have at least an empty string.
 643   EXPECT_EQ(values[0], ASCIIToUTF16(""));
 644 }
 645
 646 TEST_F(AutofillProfileSyncableServiceTest, MergeProfile) {
 647   AutofillProfile profile1(kGuid1, kHttpOrigin);
 648   profile1.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("111 First St."));
 649
 650   std::vector<base::string16> values;
 651   values.push_back(ASCIIToUTF16("1@1.com"));
 652   values.push_back(ASCIIToUTF16("2@1.com"));
 653   profile1.SetRawMultiInfo(EMAIL_ADDRESS, values);
 654
 655   AutofillProfile profile2(kGuid2, kHttpsOrigin);
 656   profile2.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("111 First St."));
 657
 658   // |values| now is [ "1@1.com", "2@1.com", "3@1.com" ].
 659   values.push_back(ASCIIToUTF16("3@1.com"));
 660   profile2.SetRawMultiInfo(EMAIL_ADDRESS, values);
 661
 662   values.clear();
 663   values.push_back(ASCIIToUTF16("John"));
 664   profile1.SetRawMultiInfo(NAME_FIRST, values);
 665   values.push_back(ASCIIToUTF16("Jane"));
 666   profile2.SetRawMultiInfo(NAME_FIRST, values);
 667
 668   values.clear();
 669   values.push_back(ASCIIToUTF16("Doe"));
 670   profile1.SetRawMultiInfo(NAME_LAST, values);
 671   values.push_back(ASCIIToUTF16("Other"));
 672   profile2.SetRawMultiInfo(NAME_LAST, values);
 673
 674   values.clear();
 675   values.push_back(ASCIIToUTF16("650234567"));
 676   profile2.SetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, values);
 677
 678   profile1.set_language_code("en");
 679
 680   EXPECT_FALSE(AutofillProfileSyncableService::MergeProfile(profile2,
 681                                                             &profile1,
 682                                                             "en-US"));
 683
 684   profile1.GetRawMultiInfo(NAME_FIRST, &values);
 685   ASSERT_EQ(values.size(), 2U);
 686   EXPECT_EQ(values[0], ASCIIToUTF16("John"));
 687   EXPECT_EQ(values[1], ASCIIToUTF16("Jane"));
 688
 689   profile1.GetRawMultiInfo(NAME_LAST, &values);
 690   ASSERT_EQ(values.size(), 2U);
 691   EXPECT_EQ(values[0], ASCIIToUTF16("Doe"));
 692   EXPECT_EQ(values[1], ASCIIToUTF16("Other"));
 693
 694   profile1.GetRawMultiInfo(EMAIL_ADDRESS, &values);
 695   ASSERT_EQ(values.size(), 3U);
 696   EXPECT_EQ(values[0], ASCIIToUTF16("1@1.com"));
 697   EXPECT_EQ(values[1], ASCIIToUTF16("2@1.com"));
 698   EXPECT_EQ(values[2], ASCIIToUTF16("3@1.com"));
 699
 700   profile1.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
 701   ASSERT_EQ(values.size(), 1U);
 702   EXPECT_EQ(values[0], ASCIIToUTF16("650234567"));
 703
 704   EXPECT_EQ(profile2.origin(), profile1.origin());
 705
 706   AutofillProfile profile3(kGuid3, kHttpOrigin);
 707   profile3.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("111 First St."));
 708
 709   values.clear();
 710   values.push_back(ASCIIToUTF16("Jane"));
 711   profile3.SetRawMultiInfo(NAME_FIRST, values);
 712
 713   values.clear();
 714   values.push_back(ASCIIToUTF16("Doe"));
 715   profile3.SetRawMultiInfo(NAME_LAST, values);
 716
 717   EXPECT_TRUE(AutofillProfileSyncableService::MergeProfile(profile3,
 718                                                            &profile1,
 719                                                             "en-US"));
 720
 721   profile1.GetRawMultiInfo(NAME_FIRST, &values);
 722   ASSERT_EQ(values.size(), 3U);
 723   EXPECT_EQ(values[0], ASCIIToUTF16("John"));
 724   EXPECT_EQ(values[1], ASCIIToUTF16("Jane"));
 725   EXPECT_EQ(values[2], ASCIIToUTF16("Jane"));
 726
 727   profile1.GetRawMultiInfo(NAME_LAST, &values);
 728   ASSERT_EQ(values.size(), 3U);
 729   EXPECT_EQ(values[0], ASCIIToUTF16("Doe"));
 730   EXPECT_EQ(values[1], ASCIIToUTF16("Other"));
 731   EXPECT_EQ(values[2], ASCIIToUTF16("Doe"));
 732
 733   // Middle name should have three entries as well.
 734   profile1.GetRawMultiInfo(NAME_MIDDLE, &values);
 735   ASSERT_EQ(values.size(), 3U);
 736   EXPECT_TRUE(values[0].empty());
 737   EXPECT_TRUE(values[1].empty());
 738   EXPECT_TRUE(values[2].empty());
 739
 740   profile1.GetRawMultiInfo(EMAIL_ADDRESS, &values);
 741   ASSERT_EQ(values.size(), 3U);
 742   EXPECT_EQ(values[0], ASCIIToUTF16("1@1.com"));
 743   EXPECT_EQ(values[1], ASCIIToUTF16("2@1.com"));
 744   EXPECT_EQ(values[2], ASCIIToUTF16("3@1.com"));
 745
 746   profile1.GetRawMultiInfo(PHONE_HOME_WHOLE_NUMBER, &values);
 747   ASSERT_EQ(values.size(), 1U);
 748   EXPECT_EQ(values[0], ASCIIToUTF16("650234567"));
 749 }
 750
 751 // Ensure that all profile fields are able to be synced up from the client to
 752 // the server.
 753 TEST_F(AutofillProfileSyncableServiceTest, SyncAllFieldsToServer) {
 754   std::vector<AutofillProfile*> profiles_from_web_db;
 755
 756   // Create a profile with all fields set.
 757   profiles_from_web_db.push_back(ConstructCompleteProfile().release());
 758
 759   // Set up expectations: No changes to the WebDB, and all fields correctly
 760   // copied to Sync.
 761   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 762   syncer::SyncChangeList expected_change_list;
 763   expected_change_list.push_back(
 764       syncer::SyncChange(FROM_HERE,
 765                          syncer::SyncChange::ACTION_ADD,
 766                          ConstructCompleteSyncData()));
 767
 768   // Verify the expectations.
 769   syncer::SyncDataList data_list;
 770   MergeDataAndStartSyncing(
 771       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 772   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 773 }
 774
 775 // Ensure that all profile fields are able to be synced down from the server to
 776 // the client.
 777 TEST_F(AutofillProfileSyncableServiceTest, SyncAllFieldsToClient) {
 778   // Create a profile with all fields set.
 779   syncer::SyncDataList data_list;
 780   data_list.push_back(ConstructCompleteSyncData());
 781
 782   // Set up expectations: All fields correctly copied to the WebDB, and no
 783   // changes propagated to Sync.
 784   syncer::SyncChangeList expected_change_list;
 785   scoped_ptr<AutofillProfile> expected_profile = ConstructCompleteProfile();
 786   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 787   expected_bundle.profiles_to_add.push_back(expected_profile.get());
 788
 789   // Verify the expectations.
 790   std::vector<AutofillProfile*> profiles_from_web_db;
 791   MergeDataAndStartSyncing(
 792       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 793   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 794 }
 795
 796 // Ensure that the street address field takes precedence over the address line 1
 797 // and line 2 fields, even though these are expected to always be in sync in
 798 // practice.
 799 TEST_F(AutofillProfileSyncableServiceTest,
 800        StreetAddressTakesPrecedenceOverAddressLines) {
 801   // Create a Sync profile with conflicting address data in the street address
 802   // field vs. the address line 1 and address line 2 fields.
 803   sync_pb::EntitySpecifics specifics;
 804   sync_pb::AutofillProfileSpecifics* autofill_specifics =
 805       specifics.mutable_autofill_profile();
 806   autofill_specifics->set_guid(kGuid1);
 807   autofill_specifics->set_origin(kHttpsOrigin);
 808   autofill_specifics->add_name_first(std::string());
 809   autofill_specifics->add_name_middle(std::string());
 810   autofill_specifics->add_name_last(std::string());
 811   autofill_specifics->add_email_address(std::string());
 812   autofill_specifics->add_phone_home_whole_number(std::string());
 813   autofill_specifics->set_address_home_line1("123 Example St.");
 814   autofill_specifics->set_address_home_line2("Apt. 42");
 815   autofill_specifics->set_address_home_street_address("456 El Camino Real\n"
 816                                                       "Suite #1337");
 817
 818   syncer::SyncDataList data_list;
 819   data_list.push_back(
 820       syncer::SyncData::CreateLocalData(kGuid1, kGuid1, specifics));
 821
 822   // Set up expectations: Full street address takes precedence over address
 823   // lines.
 824   syncer::SyncChangeList expected_change_list;
 825   AutofillProfile expected_profile(kGuid1, kHttpsOrigin);
 826   expected_profile.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
 827                               ASCIIToUTF16("456 El Camino Real\n"
 828                                            "Suite #1337"));
 829   EXPECT_EQ(ASCIIToUTF16("456 El Camino Real"),
 830             expected_profile.GetRawInfo(ADDRESS_HOME_LINE1));
 831   EXPECT_EQ(ASCIIToUTF16("Suite #1337"),
 832             expected_profile.GetRawInfo(ADDRESS_HOME_LINE2));
 833   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 834   expected_bundle.profiles_to_add.push_back(&expected_profile);
 835
 836   // Verify the expectations.
 837   std::vector<AutofillProfile*> profiles_from_web_db;
 838   MergeDataAndStartSyncing(
 839       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 840   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 841 }
 842
 843 // Ensure that no Sync events are generated to fill in missing street address
 844 // fields from Sync with explicitly present ones identical to the data stored in
 845 // the line1 and line2 fields.  This ensures that the migration to add the
 846 // street address field to profiles does not generate lots of needless Sync
 847 // updates.
 848 TEST_F(AutofillProfileSyncableServiceTest, MergeDataEmptyStreetAddress) {
 849   std::vector<AutofillProfile*> profiles_from_web_db;
 850
 851   // Create a profile with the street address set.
 852   AutofillProfile profile(kGuid1, kHttpsOrigin);
 853   profile.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
 854                      ASCIIToUTF16("123 Example St.\n"
 855                                   "Apt. 42"));
 856   EXPECT_EQ(ASCIIToUTF16("123 Example St."),
 857             profile.GetRawInfo(ADDRESS_HOME_LINE1));
 858   EXPECT_EQ(ASCIIToUTF16("Apt. 42"), profile.GetRawInfo(ADDRESS_HOME_LINE2));
 859
 860   profiles_from_web_db.push_back(new AutofillProfile(profile));
 861
 862   // Create a Sync profile identical to |profile|, except without street address
 863   // explicitly set.
 864   sync_pb::EntitySpecifics specifics;
 865   sync_pb::AutofillProfileSpecifics* autofill_specifics =
 866       specifics.mutable_autofill_profile();
 867   autofill_specifics->set_guid(profile.guid());
 868   autofill_specifics->set_origin(profile.origin());
 869   autofill_specifics->add_name_first(std::string());
 870   autofill_specifics->add_name_middle(std::string());
 871   autofill_specifics->add_name_last(std::string());
 872   autofill_specifics->add_name_full(std::string());
 873   autofill_specifics->add_email_address(std::string());
 874   autofill_specifics->add_phone_home_whole_number(std::string());
 875   autofill_specifics->set_address_home_line1("123 Example St.");
 876   autofill_specifics->set_address_home_line2("Apt. 42");
 877   EXPECT_FALSE(autofill_specifics->has_address_home_street_address());
 878
 879   syncer::SyncDataList data_list;
 880   data_list.push_back(
 881       syncer::SyncData::CreateLocalData(
 882           profile.guid(), profile.guid(), specifics));
 883
 884   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 885   syncer::SyncChangeList expected_change_list;
 886   MergeDataAndStartSyncing(
 887       profiles_from_web_db, data_list, expected_bundle, expected_change_list);
 888   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 889 }
 890
 891 // Sync data without origin should not overwrite existing origin in local
 892 // autofill profile.
 893 TEST_F(AutofillProfileSyncableServiceTest, EmptySyncPreservesOrigin) {
 894   std::vector<AutofillProfile*> profiles_from_web_db;
 895
 896   // Local autofill profile has an origin.
 897   AutofillProfile profile(kGuid1, kHttpsOrigin);
 898   profiles_from_web_db.push_back(new AutofillProfile(profile));
 899
 900   // Remote data does not have an origin value.
 901   sync_pb::EntitySpecifics specifics;
 902   sync_pb::AutofillProfileSpecifics* autofill_specifics =
 903       specifics.mutable_autofill_profile();
 904   autofill_specifics->set_guid(profile.guid());
 905   autofill_specifics->add_name_first("John");
 906   autofill_specifics->add_name_middle(std::string());
 907   autofill_specifics->add_name_last(std::string());
 908   autofill_specifics->add_name_full(std::string());
 909   autofill_specifics->add_email_address(std::string());
 910   autofill_specifics->add_phone_home_whole_number(std::string());
 911   EXPECT_FALSE(autofill_specifics->has_origin());
 912
 913   syncer::SyncDataList data_list;
 914   data_list.push_back(
 915       syncer::SyncData::CreateLocalData(
 916           profile.guid(), profile.guid(), specifics));
 917
 918   // Expect the local autofill profile to still have an origin after sync.
 919   MockAutofillProfileSyncableService::DataBundle expected_bundle;
 920   AutofillProfile expected_profile(profile.guid(), profile.origin());
 921   expected_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
 922   expected_bundle.profiles_to_update.push_back(&expected_profile);
 923
 924   // Expect no sync events to add origin to the remote data.
 925   syncer::SyncChangeList expected_empty_change_list;
 926
 927   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
 928                            expected_bundle, expected_empty_change_list);
 929   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 930 }
 931
 932 // Missing language code field should not generate sync events.
 933 TEST_F(AutofillProfileSyncableServiceTest, NoLanguageCodeNoSync) {
 934   std::vector<AutofillProfile*> profiles_from_web_db;
 935
 936   // Local autofill profile has an empty language code.
 937   AutofillProfile profile(kGuid1, kHttpsOrigin);
 938   EXPECT_TRUE(profile.language_code().empty());
 939   profiles_from_web_db.push_back(new AutofillProfile(profile));
 940
 941   // Remote data does not have a language code value.
 942   sync_pb::EntitySpecifics specifics;
 943   sync_pb::AutofillProfileSpecifics* autofill_specifics =
 944       specifics.mutable_autofill_profile();
 945   autofill_specifics->set_guid(profile.guid());
 946   autofill_specifics->set_origin(profile.origin());
 947   autofill_specifics->add_name_first(std::string());
 948   autofill_specifics->add_name_middle(std::string());
 949   autofill_specifics->add_name_last(std::string());
 950   autofill_specifics->add_name_full(std::string());
 951   autofill_specifics->add_email_address(std::string());
 952   autofill_specifics->add_phone_home_whole_number(std::string());
 953   EXPECT_FALSE(autofill_specifics->has_address_home_language_code());
 954
 955   syncer::SyncDataList data_list;
 956   data_list.push_back(
 957       syncer::SyncData::CreateLocalData(
 958           profile.guid(), profile.guid(), specifics));
 959
 960   // Expect no changes to local and remote data.
 961   MockAutofillProfileSyncableService::DataBundle expected_empty_bundle;
 962   syncer::SyncChangeList expected_empty_change_list;
 963
 964   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
 965                            expected_empty_bundle, expected_empty_change_list);
 966   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
 967 }
 968
 969 // Empty language code should be overwritten by sync.
 970 TEST_F(AutofillProfileSyncableServiceTest, SyncUpdatesEmptyLanguageCode) {
 971   std::vector<AutofillProfile*> profiles_from_web_db;
 972
 973   // Local autofill profile has an empty language code.
 974   AutofillProfile profile(kGuid1, kHttpsOrigin);
 975   EXPECT_TRUE(profile.language_code().empty());
 976   profiles_from_web_db.push_back(new AutofillProfile(profile));
 977
 978   // Remote data has "en" language code.
 979   sync_pb::EntitySpecifics specifics;
 980   sync_pb::AutofillProfileSpecifics* autofill_specifics =
 981       specifics.mutable_autofill_profile();
 982   autofill_specifics->set_guid(profile.guid());
 983   autofill_specifics->set_origin(profile.origin());
 984   autofill_specifics->add_name_first(std::string());
 985   autofill_specifics->add_name_middle(std::string());
 986   autofill_specifics->add_name_last(std::string());
 987   autofill_specifics->add_name_full(std::string());
 988   autofill_specifics->add_email_address(std::string());
 989   autofill_specifics->add_phone_home_whole_number(std::string());
 990   autofill_specifics->set_address_home_language_code("en");
 991   EXPECT_TRUE(autofill_specifics->has_address_home_language_code());
 992
 993   syncer::SyncDataList data_list;
 994   data_list.push_back(
 995       syncer::SyncData::CreateLocalData(
 996           profile.guid(), profile.guid(), specifics));
 997
 998   // Expect the local autofill profile to have "en" language code after sync.
 999   MockAutofillProfileSyncableService::DataBundle expected_bundle;
1000   AutofillProfile expected_profile(kGuid1, kHttpsOrigin);
1001   expected_profile.set_language_code("en");
1002   expected_bundle.profiles_to_update.push_back(&expected_profile);
1003
1004   // Expect not changes to remote data.
1005   syncer::SyncChangeList expected_empty_change_list;
1006
1007   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
1008                            expected_bundle, expected_empty_change_list);
1009   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
1010 }
1011
1012 // Incorrect language code should be overwritten by sync.
1013 TEST_F(AutofillProfileSyncableServiceTest, SyncUpdatesIncorrectLanguageCode) {
1014   std::vector<AutofillProfile*> profiles_from_web_db;
1015
1016   // Local autofill profile has "de" language code.
1017   AutofillProfile profile(kGuid1, kHttpsOrigin);
1018   profile.set_language_code("de");
1019   profiles_from_web_db.push_back(new AutofillProfile(profile));
1020
1021   // Remote data has "en" language code.
1022   sync_pb::EntitySpecifics specifics;
1023   sync_pb::AutofillProfileSpecifics* autofill_specifics =
1024       specifics.mutable_autofill_profile();
1025   autofill_specifics->set_guid(profile.guid());
1026   autofill_specifics->set_origin(profile.origin());
1027   autofill_specifics->add_name_first(std::string());
1028   autofill_specifics->add_name_middle(std::string());
1029   autofill_specifics->add_name_last(std::string());
1030   autofill_specifics->add_name_full(std::string());
1031   autofill_specifics->add_email_address(std::string());
1032   autofill_specifics->add_phone_home_whole_number(std::string());
1033   autofill_specifics->set_address_home_language_code("en");
1034   EXPECT_TRUE(autofill_specifics->has_address_home_language_code());
1035
1036   syncer::SyncDataList data_list;
1037   data_list.push_back(
1038       syncer::SyncData::CreateLocalData(
1039           profile.guid(), profile.guid(), specifics));
1040
1041   // Expect the local autofill profile to have "en" language code after sync.
1042   MockAutofillProfileSyncableService::DataBundle expected_bundle;
1043   AutofillProfile expected_profile(kGuid1, kHttpsOrigin);
1044   expected_profile.set_language_code("en");
1045   expected_bundle.profiles_to_update.push_back(&expected_profile);
1046
1047   // Expect no changes to remote data.
1048   syncer::SyncChangeList expected_empty_change_list;
1049
1050   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
1051                            expected_bundle, expected_empty_change_list);
1052   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
1053 }
1054
1055 // Sync data without language code should not overwrite existing language code
1056 // in local autofill profile.
1057 TEST_F(AutofillProfileSyncableServiceTest, EmptySyncPreservesLanguageCode) {
1058   std::vector<AutofillProfile*> profiles_from_web_db;
1059
1060   // Local autofill profile has "en" language code.
1061   AutofillProfile profile(kGuid1, kHttpsOrigin);
1062   profile.set_language_code("en");
1063   profiles_from_web_db.push_back(new AutofillProfile(profile));
1064
1065   // Remote data does not have a language code value.
1066   sync_pb::EntitySpecifics specifics;
1067   sync_pb::AutofillProfileSpecifics* autofill_specifics =
1068       specifics.mutable_autofill_profile();
1069   autofill_specifics->set_guid(profile.guid());
1070   autofill_specifics->set_origin(profile.origin());
1071   autofill_specifics->add_name_first("John");
1072   autofill_specifics->add_name_middle(std::string());
1073   autofill_specifics->add_name_last(std::string());
1074   autofill_specifics->add_name_full(std::string());
1075   autofill_specifics->add_email_address(std::string());
1076   autofill_specifics->add_phone_home_whole_number(std::string());
1077   EXPECT_FALSE(autofill_specifics->has_address_home_language_code());
1078
1079   syncer::SyncDataList data_list;
1080   data_list.push_back(
1081       syncer::SyncData::CreateLocalData(
1082           profile.guid(), profile.guid(), specifics));
1083
1084   // Expect local autofill profile to still have "en" language code after sync.
1085   MockAutofillProfileSyncableService::DataBundle expected_bundle;
1086   AutofillProfile expected_profile(profile.guid(), profile.origin());
1087   expected_profile.set_language_code("en");
1088   expected_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
1089   expected_bundle.profiles_to_update.push_back(&expected_profile);
1090
1091   // Expect no changes to remote data.
1092   syncer::SyncChangeList expected_empty_change_list;
1093
1094   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
1095                            expected_bundle, expected_empty_change_list);
1096   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
1097 }
1098
1099 // Language code in autofill profiles should be synced to the server.
1100 TEST_F(AutofillProfileSyncableServiceTest, LanguageCodePropagates) {
1101   TestSyncChangeProcessor* sync_change_processor = new TestSyncChangeProcessor;
1102   autofill_syncable_service_.set_sync_processor(sync_change_processor);
1103
1104   AutofillProfile profile(kGuid1, kHttpsOrigin);
1105   profile.set_language_code("en");
1106   AutofillProfileChange change(AutofillProfileChange::ADD, kGuid1, &profile);
1107   autofill_syncable_service_.AutofillProfileChanged(change);
1108
1109   ASSERT_EQ(1U, sync_change_processor->changes().size());
1110   syncer::SyncChange result = sync_change_processor->changes()[0];
1111   EXPECT_EQ(syncer::SyncChange::ACTION_ADD, result.change_type());
1112
1113   sync_pb::AutofillProfileSpecifics specifics =
1114       result.sync_data().GetSpecifics().autofill_profile();
1115   EXPECT_EQ(kGuid1, specifics.guid());
1116   EXPECT_EQ(kHttpsOrigin, specifics.origin());
1117   EXPECT_EQ("en", specifics.address_home_language_code());
1118 }
1119
1120 // Missing full name field should not generate sync events.
1121 TEST_F(AutofillProfileSyncableServiceTest, NoFullNameNoSync) {
1122   std::vector<AutofillProfile*> profiles_from_web_db;
1123
1124   // Local autofill profile has an empty full name.
1125   AutofillProfile profile(kGuid1, kHttpsOrigin);
1126   profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("John"));
1127   profiles_from_web_db.push_back(new AutofillProfile(profile));
1128
1129   // Remote data does not have a full name.
1130   sync_pb::EntitySpecifics specifics;
1131   sync_pb::AutofillProfileSpecifics* autofill_specifics =
1132       specifics.mutable_autofill_profile();
1133   autofill_specifics->set_guid(profile.guid());
1134   autofill_specifics->set_origin(profile.origin());
1135   autofill_specifics->add_name_first(std::string("John"));
1136   autofill_specifics->add_name_middle(std::string());
1137   autofill_specifics->add_name_last(std::string());
1138   autofill_specifics->add_email_address(std::string());
1139   autofill_specifics->add_phone_home_whole_number(std::string());
1140
1141   syncer::SyncDataList data_list;
1142   data_list.push_back(
1143       syncer::SyncData::CreateLocalData(
1144           profile.guid(), profile.guid(), specifics));
1145
1146   // Expect no changes to local and remote data.
1147   MockAutofillProfileSyncableService::DataBundle expected_empty_bundle;
1148   syncer::SyncChangeList expected_empty_change_list;
1149
1150   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
1151                            expected_empty_bundle, expected_empty_change_list);
1152   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
1153 }
1154
1155 TEST_F(AutofillProfileSyncableServiceTest, EmptySyncPreservesFullName) {
1156   std::vector<AutofillProfile*> profiles_from_web_db;
1157
1158   // Local autofill profile has a full name.
1159   AutofillProfile profile(kGuid1, kHttpsOrigin);
1160   profile.SetInfo(AutofillType(NAME_FULL),
1161                   ASCIIToUTF16("John Jacob Smith, Jr"), "en-US");
1162   profiles_from_web_db.push_back(new AutofillProfile(profile));
1163
1164   // Remote data does not have a full name value.
1165   sync_pb::EntitySpecifics specifics;
1166   sync_pb::AutofillProfileSpecifics* autofill_specifics =
1167       specifics.mutable_autofill_profile();
1168   autofill_specifics->set_guid(profile.guid());
1169   autofill_specifics->set_origin(profile.origin());
1170   autofill_specifics->add_name_first(std::string("John"));
1171   autofill_specifics->add_name_middle(std::string("Jacob"));
1172   autofill_specifics->add_name_last(std::string("Smith"));
1173
1174   syncer::SyncDataList data_list;
1175   data_list.push_back(
1176       syncer::SyncData::CreateLocalData(
1177           profile.guid(), profile.guid(), specifics));
1178
1179   // Expect local autofill profile to still have the same full name after sync.
1180   MockAutofillProfileSyncableService::DataBundle expected_bundle;
1181   AutofillProfile expected_profile(profile.guid(), profile.origin());
1182   expected_profile.SetInfo(AutofillType(NAME_FULL),
1183                            ASCIIToUTF16("John Jacob Smith, Jr"),
1184                            "en-US");
1185   expected_bundle.profiles_to_update.push_back(&expected_profile);
1186
1187   // Expect no changes to remote data.
1188   syncer::SyncChangeList expected_empty_change_list;
1189
1190   MergeDataAndStartSyncing(profiles_from_web_db, data_list,
1191                            expected_bundle, expected_empty_change_list);
1192   autofill_syncable_service_.StopSyncing(syncer::AUTOFILL_PROFILE);
1193 }
1194
1195 }  // namespace autofill