[Sync] Merge //components/browser_sync into one directory.

components/browser_sync/profile_sync_service_autofill_unittest.cc

 // Copyright 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
@@ skipping 20 matching lines @@
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/webdata/autocomplete_syncable_service.h"
 #include "components/autofill/core/browser/webdata/autofill_change.h"
 #include "components/autofill/core/browser/webdata/autofill_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_entry.h"
 #include "components/autofill/core/browser/webdata/autofill_profile_data_type_controller.h"
 #include "components/autofill/core/browser/webdata/autofill_profile_syncable_service.h"
 #include "components/autofill/core/browser/webdata/autofill_table.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/autofill/core/common/autofill_pref_names.h"
-#include "components/browser_sync/browser/abstract_profile_sync_service_test.h"
-#include "components/browser_sync/browser/profile_sync_service.h"
-#include "components/browser_sync/browser/test_profile_sync_service.h"
+#include "components/browser_sync/abstract_profile_sync_service_test.h"
+#include "components/browser_sync/profile_sync_service.h"
+#include "components/browser_sync/test_profile_sync_service.h"
 #include "components/sync/base/model_type.h"
 #include "components/sync/core/data_type_debug_info_listener.h"
 #include "components/sync/core/read_node.h"
 #include "components/sync/core/read_transaction.h"
 #include "components/sync/core/write_node.h"
 #include "components/sync/core/write_transaction.h"
 #include "components/sync/driver/data_type_controller.h"
 #include "components/sync/driver/data_type_manager_impl.h"
 #include "components/sync/driver/sync_api_component_factory_mock.h"
 #include "components/sync/protocol/autofill_specifics.pb.h"
@@ skipping 91 matching lines @@
   MOCK_METHOD1(GetAllAutofillEntries,
                bool(std::vector<AutofillEntry>* entries));  // NOLINT
   MOCK_METHOD4(GetAutofillTimestamps,
                bool(const base::string16& name,  // NOLINT
                     const base::string16& value,
                     Time* date_created,
                     Time* date_last_used));
   MOCK_METHOD1(UpdateAutofillEntries,
                bool(const std::vector<AutofillEntry>&));  // NOLINT
   MOCK_METHOD1(GetAutofillProfiles,
-               bool(std::vector<AutofillProfile*>*));  // NOLINT
-  MOCK_METHOD1(UpdateAutofillProfile,
-               bool(const AutofillProfile&));  // NOLINT
-  MOCK_METHOD1(AddAutofillProfile,
-               bool(const AutofillProfile&));  // NOLINT
-  MOCK_METHOD1(RemoveAutofillProfile,
-               bool(const std::string&));  // NOLINT
+               bool(std::vector<AutofillProfile*>*));                 // NOLINT
+  MOCK_METHOD1(UpdateAutofillProfile, bool(const AutofillProfile&));  // NOLINT
+  MOCK_METHOD1(AddAutofillProfile, bool(const AutofillProfile&));     // NOLINT
+  MOCK_METHOD1(RemoveAutofillProfile, bool(const std::string&));      // NOLINT
 };
 
 MATCHER_P(MatchProfiles, profile, "") {
   return (profile.Compare(arg) == 0);
 }
 
 class WebDatabaseFake : public WebDatabase {
  public:
   explicit WebDatabaseFake(AutofillTable* autofill_table) {
     AddTable(autofill_table);
@@ skipping 30 matching lines @@
 
  private:
   WebDatabase* web_database_;
   base::Closure on_changed_;
   base::Callback<void(syncer::ModelType)> on_sync_started_;
   const scoped_refptr<base::SequencedTaskRunner> ui_thread_;
 };
 
 class ProfileSyncServiceAutofillTest;
 
-template<class AutofillProfile>
+template <class AutofillProfile>
 syncer::ModelType GetModelType() {
   return syncer::UNSPECIFIED;
 }
 
-template<>
+template <>
 syncer::ModelType GetModelType<AutofillEntry>() {
   return AUTOFILL;
 }
 
-template<>
+template <>
 syncer::ModelType GetModelType<AutofillProfile>() {
   return AUTOFILL_PROFILE;
 }
 
 class TokenWebDataServiceFake : public TokenWebData {
  public:
   TokenWebDataServiceFake(
       const scoped_refptr<base::SingleThreadTaskRunner>& ui_thread,
       const scoped_refptr<base::SingleThreadTaskRunner>& db_thread)
       : TokenWebData(ui_thread, db_thread) {}
@@ skipping 26 matching lines @@
       : AutofillWebDataService(ui_thread, db_thread),
         web_database_(NULL),
         autocomplete_syncable_service_(NULL),
         autofill_profile_syncable_service_(NULL),
         syncable_service_created_or_destroyed_(
             base::WaitableEvent::ResetPolicy::AUTOMATIC,
             base::WaitableEvent::InitialState::NOT_SIGNALED),
         db_thread_(db_thread),
         ui_thread_(ui_thread) {}
 
-  void SetDatabase(WebDatabase* web_database) {
-    web_database_ = web_database;
-  }
+  void SetDatabase(WebDatabase* web_database) { web_database_ = web_database; }
 
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
-    const base::Closure& on_changed_callback = base::Bind(
-        &WebDataServiceFake::NotifyAutofillMultipleChangedOnUIThread,
-        AsWeakPtr());
+    const base::Closure& on_changed_callback =
+        base::Bind(&WebDataServiceFake::NotifyAutofillMultipleChangedOnUIThread,
+                   AsWeakPtr());
     const base::Callback<void(syncer::ModelType)> on_sync_started_callback =
         base::Bind(&WebDataServiceFake::NotifySyncStartedOnUIThread,
                    AsWeakPtr());
 
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&WebDataServiceFake::CreateSyncableService,
                                     base::Unretained(this), on_changed_callback,
                                     on_sync_started_callback));
     syncable_service_created_or_destroyed_.Wait();
   }
@@ skipping 10 matching lines @@
   bool IsDatabaseLoaded() override { return true; }
 
   WebDatabase* GetDatabase() override { return web_database_; }
 
   void OnAutofillEntriesChanged(const AutofillChangeList& changes) {
     WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                         base::WaitableEvent::InitialState::NOT_SIGNALED);
 
     base::Closure notify_cb =
         base::Bind(&AutocompleteSyncableService::AutofillEntriesChanged,
-                   base::Unretained(autocomplete_syncable_service_),
-                   changes);
+                   base::Unretained(autocomplete_syncable_service_), changes);
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
   void OnAutofillProfileChanged(const AutofillProfileChange& changes) {
     WaitableEvent event(base::WaitableEvent::ResetPolicy::MANUAL,
                         base::WaitableEvent::InitialState::NOT_SIGNALED);
 
-    base::Closure notify_cb =
-        base::Bind(&AutocompleteSyncableService::AutofillProfileChanged,
-                   base::Unretained(autofill_profile_syncable_service_),
-                   changes);
+    base::Closure notify_cb = base::Bind(
+        &AutocompleteSyncableService::AutofillProfileChanged,
+        base::Unretained(autofill_profile_syncable_service_), changes);
     db_thread_->PostTask(FROM_HERE,
                          base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
  private:
   ~WebDataServiceFake() override {}
 
   void CreateSyncableService(
       const base::Closure& on_changed_callback,
@@ skipping 30 matching lines @@
 
   WaitableEvent syncable_service_created_or_destroyed_;
 
   const scoped_refptr<base::SingleThreadTaskRunner> db_thread_;
   const scoped_refptr<base::SingleThreadTaskRunner> ui_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(WebDataServiceFake);
 };
 
 ACTION_P(ReturnNewDataTypeManagerWithDebugListener, debug_listener) {
-  return new sync_driver::DataTypeManagerImpl(
-      debug_listener,
-      arg1,
-      arg2,
-      arg3,
-      arg4);
+  return new sync_driver::DataTypeManagerImpl(debug_listener, arg1, arg2, arg3,
+                                              arg4);
 }
 
 class MockPersonalDataManager : public PersonalDataManager {
  public:
   MockPersonalDataManager() : PersonalDataManager("en-US") {}
   MOCK_CONST_METHOD0(IsDataLoaded, bool());
   MOCK_METHOD0(LoadProfiles, void());
   MOCK_METHOD0(LoadCreditCards, void());
   MOCK_METHOD0(Refresh, void());
 };
 
-template <class T> class AddAutofillHelper;
+template <class T>
+class AddAutofillHelper;
 
 class ProfileSyncServiceAutofillTest
     : public AbstractProfileSyncServiceTest,
       public syncer::DataTypeDebugInfoListener {
  public:
   // DataTypeDebugInfoListener implementation.
-  void OnDataTypeConfigureComplete(const std::vector<
-      syncer::DataTypeConfigurationStats>& configuration_stats) override {
+  void OnDataTypeConfigureComplete(
+      const std::vector<syncer::DataTypeConfigurationStats>&
+          configuration_stats) override {
     ASSERT_EQ(1u, configuration_stats.size());
     association_stats_ = configuration_stats[0].association_stats;
   }
 
  protected:
   ProfileSyncServiceAutofillTest() : debug_ptr_factory_(this) {
     autofill::CountryNames::SetLocaleString("en-US");
     RegisterAutofillPrefs(
         profile_sync_service_bundle()->pref_service()->registry());
 
@@ skipping 85 matching lines @@
     base::RunLoop().Run();
 
     // It's possible this test triggered an unrecoverable error, in which case
     // we can't get the sync count.
     if (sync_service()->IsSyncActive()) {
       EXPECT_EQ(GetSyncCount(type),
                 association_stats_.num_sync_items_after_association);
     }
     EXPECT_EQ(association_stats_.num_sync_items_after_association,
               association_stats_.num_sync_items_before_association +
-              association_stats_.num_sync_items_added -
-              association_stats_.num_sync_items_deleted);
+                  association_stats_.num_sync_items_added -
+                  association_stats_.num_sync_items_deleted);
   }
 
   bool AddAutofillSyncNode(const AutofillEntry& entry) {
     syncer::WriteTransaction trans(FROM_HERE, sync_service()->GetUserShare());
     syncer::WriteNode node(&trans);
     std::string tag = AutocompleteSyncableService::KeyToTag(
         base::UTF16ToUTF8(entry.key().name()),
         base::UTF16ToUTF8(entry.key().value()));
     syncer::WriteNode::InitUniqueByCreationResult result =
         node.InitUniqueByCreation(AUTOFILL, tag);
@@ skipping 36 matching lines @@
         return false;
 
       const sync_pb::AutofillSpecifics& autofill(
           child_node.GetEntitySpecifics().autofill());
       if (autofill.has_value()) {
         AutofillKey key(base::UTF8ToUTF16(autofill.name()),
                         base::UTF8ToUTF16(autofill.value()));
         std::vector<Time> timestamps;
         int timestamps_count = autofill.usage_timestamp_size();
         for (int i = 0; i < timestamps_count; ++i) {
-          timestamps.push_back(Time::FromInternalValue(
-              autofill.usage_timestamp(i)));
+          timestamps.push_back(
+              Time::FromInternalValue(autofill.usage_timestamp(i)));
         }
         entries->push_back(
             AutofillEntry(key, timestamps.front(), timestamps.back()));
       } else if (autofill.has_profile()) {
         AutofillProfile p;
         p.set_guid(autofill.profile().guid());
         AutofillProfileSyncableService::OverwriteProfileWithServerData(
             autofill.profile(), &p);
         profiles->push_back(p);
       }
@@ skipping 11 matching lines @@
     }
 
     int64_t child_id = autofill_root.GetFirstChildId();
     while (child_id != syncer::kInvalidId) {
       syncer::ReadNode child_node(&trans);
       if (child_node.InitByIdLookup(child_id) != BaseNode::INIT_OK)
         return false;
 
       const sync_pb::AutofillProfileSpecifics& autofill(
           child_node.GetEntitySpecifics().autofill_profile());
-        AutofillProfile p;
-        p.set_guid(autofill.guid());
-        AutofillProfileSyncableService::OverwriteProfileWithServerData(autofill,
-                                                                       &p);
-        profiles->push_back(p);
+      AutofillProfile p;
+      p.set_guid(autofill.guid());
+      AutofillProfileSyncableService::OverwriteProfileWithServerData(autofill,
+                                                                     &p);
+      profiles->push_back(p);
       child_id = child_node.GetSuccessorId();
     }
     return true;
   }
 
   void SetIdleChangeProcessorExpectations() {
     EXPECT_CALL(autofill_table_, RemoveFormElement(_, _)).Times(0);
     EXPECT_CALL(autofill_table_, GetAutofillTimestamps(_, _, _, _)).Times(0);
 
     // Only permit UpdateAutofillEntries() to be called with an empty list.
@@ skipping 56 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ProfileSyncServiceAutofillTest);
 };
 
 template <class T>
 class AddAutofillHelper {
  public:
   AddAutofillHelper(ProfileSyncServiceAutofillTest* test,
                     const std::vector<T>& entries)
       : callback_(base::Bind(&AddAutofillHelper::AddAutofillCallback,
-                             base::Unretained(this), test, entries)),
-        success_(false) {
-  }
+                             base::Unretained(this),
+                             test,
+                             entries)),
+        success_(false) {}
 
   const base::Closure& callback() const { return callback_; }
   bool success() { return success_; }
 
  private:
   void AddAutofillCallback(ProfileSyncServiceAutofillTest* test,
                            const std::vector<T>& entries) {
     if (!test->CreateRoot(GetModelType<T>()))
       return;
 
     for (size_t i = 0; i < entries.size(); ++i) {
       if (!test->AddAutofillSyncNode(entries[i]))
         return;
     }
     success_ = true;
   }
 
   base::Closure callback_;
   bool success_;
 };
 
 // Overload write transaction to use custom NotifyTransactionComplete
-class WriteTransactionTest: public WriteTransaction {
+class WriteTransactionTest : public WriteTransaction {
  public:
   WriteTransactionTest(const tracked_objects::Location& from_here,
                        WriterTag writer,
                        syncer::syncable::Directory* directory,
                        WaitableEvent* wait_for_syncapi)
       : WriteTransaction(from_here, writer, directory),
         wait_for_syncapi_(wait_for_syncapi) {}
 
   void NotifyTransactionComplete(syncer::ModelTypeSet types) override {
     // This is where we differ. Force a thread change here, giving another
@@ skipping 75 matching lines @@
   void CreateNewEntry(const AutofillEntry& entry) {
     entry_ = entry;
     ASSERT_FALSE(db_thread_->RunsTasksOnCurrentThread());
     if (!db_thread_->PostTask(FROM_HERE,
                               base::Bind(&FakeServerUpdater::Update, this))) {
       NOTREACHED() << "Failed to post task to the db thread.";
       return;
     }
   }
 
-  void WaitForUpdateCompletion() {
-    is_finished_.Wait();
-  }
+  void WaitForUpdateCompletion() { is_finished_.Wait(); }
 
  private:
   friend class base::RefCountedThreadSafe<FakeServerUpdater>;
-  ~FakeServerUpdater() { }
+  ~FakeServerUpdater() {}
 
   AutofillEntry entry_;
   TestProfileSyncService* service_;
   WaitableEvent* const wait_for_start_;
   WaitableEvent* const wait_for_syncapi_;
   WaitableEvent is_finished_;
   syncer::syncable::Id parent_id_;
   scoped_refptr<base::SequencedTaskRunner> db_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeServerUpdater);
@@ skipping 40 matching lines @@
   ASSERT_EQ(1U, entries.size());
   EXPECT_TRUE(entries[0] == sync_entries[0]);
   EXPECT_EQ(0U, sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasProfileEmptySync) {
   std::vector<AutofillProfile*> profiles;
   std::vector<AutofillProfile> expected_profiles;
   // Owned by GetAutofillProfiles caller.
   AutofillProfile* profile0 = new AutofillProfile;
-  autofill::test::SetProfileInfoWithGuid(profile0,
-      "54B3F9AA-335E-4F71-A27D-719C41564230", "Billing",
-      "Mitchell", "Morrison",
-      "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
-      "91601", "US", "12345678910");
+  autofill::test::SetProfileInfoWithGuid(
+      profile0, "54B3F9AA-335E-4F71-A27D-719C41564230", "Billing", "Mitchell",
+      "Morrison", "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5",
+      "Hollywood", "CA", "91601", "US", "12345678910");
   profiles.push_back(profile0);
   expected_profiles.push_back(*profile0);
   EXPECT_CALL(autofill_table(), GetAutofillProfiles(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(profiles), Return(true)));
   EXPECT_CALL(personal_data_manager(), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL_PROFILE);
   StartSyncService(create_root.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillProfile> sync_profiles;
@@ skipping 43 matching lines @@
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, AUTOFILL);
   ASSERT_TRUE(add_autofill.success());
 
   std::set<AutofillEntry> expected_entries;
   expected_entries.insert(native_entry);
   expected_entries.insert(sync_entry);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
-                                           &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
   std::set<AutofillEntry> new_sync_entries_set(new_sync_entries.begin(),
                                                new_sync_entries.end());
 
   EXPECT_TRUE(expected_entries == new_sync_entries_set);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeEntry) {
   AutofillEntry native_entry(MakeAutofillEntry("merge", "entry", 1));
   AutofillEntry sync_entry(MakeAutofillEntry("merge", "entry", 2));
   AutofillEntry merged_entry(MakeAutofillEntry("merge", "entry", 1, 2));
 
   std::vector<AutofillEntry> native_entries;
   native_entries.push_back(native_entry);
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
 
   std::vector<AutofillEntry> sync_entries;
   sync_entries.push_back(sync_entry);
   AddAutofillHelper<AutofillEntry> add_autofill(this, sync_entries);
 
   EXPECT_CALL(autofill_table(),
               UpdateAutofillEntries(ElementsAre(merged_entry)))
       .WillOnce(Return(true));
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, AUTOFILL);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
-                                           &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(merged_entry == new_sync_entries[0]);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncMergeProfile) {
   AutofillProfile sync_profile;
-  autofill::test::SetProfileInfoWithGuid(&sync_profile,
-      "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing",
-      "Mitchell", "Morrison",
-      "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
-      "91601", "US", "12345678910");
+  autofill::test::SetProfileInfoWithGuid(
+      &sync_profile, "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing",
+      "Mitchell", "Morrison", "johnwayne@me.xyz", "Fox", "123 Zoo St.",
+      "unit 5", "Hollywood", "CA", "91601", "US", "12345678910");
 
   AutofillProfile* native_profile = new AutofillProfile;
-  autofill::test::SetProfileInfoWithGuid(native_profile,
-      "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing", "Alicia", "Saenz",
-      "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
-      "32801", "US", "19482937549");
+  autofill::test::SetProfileInfoWithGuid(
+      native_profile, "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing",
+      "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5",
+      "Orlando", "FL", "32801", "US", "19482937549");
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
   EXPECT_CALL(autofill_table(), GetAutofillProfiles(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
 
   EXPECT_CALL(autofill_table(),
               UpdateAutofillProfile(MatchProfiles(sync_profile)))
       .WillOnce(Return(true));
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
-      &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillProfilesFromSyncDBUnderProfileNode(&new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, sync_profile.Compare(new_sync_profiles[0]));
 }
 
 // Tests that a sync with a new native profile that matches a more recent new
 // sync profile but with less information results in the native profile being
 // deleted and replaced by the sync profile with merged usage stats.
 TEST_F(
     ProfileSyncServiceAutofillTest,
     HasNativeHasSyncMergeSimilarProfileCombine_SyncHasMoreInfoAndMoreRecent) {
@@ skipping 215 matching lines @@
   // The two profiles should be kept.
   ASSERT_EQ(2U, new_sync_profiles.size());
 }
 
 // Tests that a new native profile that is the same as a new sync profile except
 // with different GUIDs results in the native profile being deleted and replaced
 // by the sync profile.
 TEST_F(ProfileSyncServiceAutofillTest, MergeProfileWithDifferentGuid) {
   AutofillProfile sync_profile;
 
-  autofill::test::SetProfileInfoWithGuid(&sync_profile,
-      "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing",
-      "Mitchell", "Morrison",
-      "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
-      "91601", "US", "12345678910");
+  autofill::test::SetProfileInfoWithGuid(
+      &sync_profile, "23355099-1170-4B71-8ED4-144470CC9EBE", "Billing",
+      "Mitchell", "Morrison", "johnwayne@me.xyz", "Fox", "123 Zoo St.",
+      "unit 5", "Hollywood", "CA", "91601", "US", "12345678910");
   sync_profile.set_use_count(20);
   sync_profile.set_use_date(base::Time::FromTimeT(1234));
 
   std::string native_guid = "EDC609ED-7EEE-4F27-B00C-423242A9C44B";
   AutofillProfile* native_profile = new AutofillProfile;
-  autofill::test::SetProfileInfoWithGuid(native_profile,
-      native_guid.c_str(), "Billing",
-      "Mitchell", "Morrison",
+  autofill::test::SetProfileInfoWithGuid(
+      native_profile, native_guid.c_str(), "Billing", "Mitchell", "Morrison",
       "johnwayne@me.xyz", "Fox", "123 Zoo St.", "unit 5", "Hollywood", "CA",
       "91601", "US", "12345678910");
   native_profile->set_use_count(5);
   native_profile->set_use_date(base::Time::FromTimeT(4321));
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
   EXPECT_CALL(autofill_table(), GetAutofillProfiles(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
 
   EXPECT_CALL(autofill_table(), AddAutofillProfile(_)).WillOnce(Return(true));
   EXPECT_CALL(autofill_table(), RemoveAutofillProfile(native_guid))
       .WillOnce(Return(true));
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
-      &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillProfilesFromSyncDBUnderProfileNode(&new_sync_profiles));
   // Check that the profiles were merged.
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, sync_profile.Compare(new_sync_profiles[0]));
   // Check that the sync guid was kept.
   EXPECT_EQ(sync_profile.guid(), new_sync_profiles[0].guid());
   // Check that the sync profile use count was kept.
   EXPECT_EQ(20U, new_sync_profiles[0].use_count());
   // Check that the sync profile use date was kept.
   EXPECT_EQ(base::Time::FromTimeT(1234), new_sync_profiles[0].use_date());
 }
@@ skipping 14 matching lines @@
                       SetArgumentPointee<3>(added_entry.date_last_used()),
                       Return(true)));
 
   AutofillChangeList changes;
   changes.push_back(AutofillChange(AutofillChange::ADD, added_entry.key()));
 
   web_data_service()->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
-                                           &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(added_entry == new_sync_entries[0]);
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeAddProfile) {
   EXPECT_CALL(autofill_table(), GetAutofillProfiles(_)).WillOnce(Return(true));
   EXPECT_CALL(personal_data_manager(), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL_PROFILE);
   StartSyncService(create_root.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(create_root.success());
 
   AutofillProfile added_profile;
-  autofill::test::SetProfileInfoWithGuid(&added_profile,
-      "D6ADA912-D374-4C0A-917D-F5C8EBE43011", "Josephine", "Alicia", "Saenz",
-      "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
-      "32801", "US", "19482937549");
+  autofill::test::SetProfileInfoWithGuid(
+      &added_profile, "D6ADA912-D374-4C0A-917D-F5C8EBE43011", "Josephine",
+      "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5",
+      "Orlando", "FL", "32801", "US", "19482937549");
 
-  AutofillProfileChange change(
-      AutofillProfileChange::ADD, added_profile.guid(), &added_profile);
+  AutofillProfileChange change(AutofillProfileChange::ADD, added_profile.guid(),
+                               &added_profile);
   web_data_service()->OnAutofillProfileChanged(change);
 
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
-      &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillProfilesFromSyncDBUnderProfileNode(&new_sync_profiles));
   ASSERT_EQ(1U, new_sync_profiles.size());
   EXPECT_EQ(0, added_profile.Compare(new_sync_profiles[0]));
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeUpdateEntry) {
   AutofillEntry original_entry(MakeAutofillEntry("my", "entry", 1));
   std::vector<AutofillEntry> original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(personal_data_manager(), Refresh());
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry updated_entry(MakeAutofillEntry("my", "entry", 1, 2));
 
   EXPECT_CALL(autofill_table(), GetAutofillTimestamps(_, _, _, _))
       .WillOnce(DoAll(SetArgumentPointee<2>(updated_entry.date_created()),
                       SetArgumentPointee<3>(updated_entry.date_last_used()),
                       Return(true)));
 
   AutofillChangeList changes;
-  changes.push_back(AutofillChange(AutofillChange::UPDATE,
-                                   updated_entry.key()));
+  changes.push_back(
+      AutofillChange(AutofillChange::UPDATE, updated_entry.key()));
   web_data_service()->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
-                                           &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
   ASSERT_EQ(1U, new_sync_entries.size());
   EXPECT_TRUE(updated_entry == new_sync_entries[0]);
 }
 
-
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveEntry) {
   AutofillEntry original_entry(MakeAutofillEntry("my", "entry", 1));
   std::vector<AutofillEntry> original_entries;
   original_entries.push_back(original_entry);
 
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(original_entries), Return(true)));
   EXPECT_CALL(personal_data_manager(), Refresh());
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillChangeList changes;
-  changes.push_back(AutofillChange(AutofillChange::REMOVE,
-                                   original_entry.key()));
+  changes.push_back(
+      AutofillChange(AutofillChange::REMOVE, original_entry.key()));
   web_data_service()->OnAutofillEntriesChanged(changes);
 
   std::vector<AutofillEntry> new_sync_entries;
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&new_sync_entries,
-                                           &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillEntriesFromSyncDB(&new_sync_entries, &new_sync_profiles));
   ASSERT_EQ(0U, new_sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ProcessUserChangeRemoveProfile) {
   AutofillProfile sync_profile;
-  autofill::test::SetProfileInfoWithGuid(&sync_profile,
-      "3BA5FA1B-1EC4-4BB3-9B57-EC92BE3C1A09", "Josephine", "Alicia", "Saenz",
-      "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
-      "32801", "US", "19482937549");
+  autofill::test::SetProfileInfoWithGuid(
+      &sync_profile, "3BA5FA1B-1EC4-4BB3-9B57-EC92BE3C1A09", "Josephine",
+      "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5",
+      "Orlando", "FL", "32801", "US", "19482937549");
   AutofillProfile* native_profile = new AutofillProfile;
-  autofill::test::SetProfileInfoWithGuid(native_profile,
-      "3BA5FA1B-1EC4-4BB3-9B57-EC92BE3C1A09", "Josephine", "Alicia", "Saenz",
-      "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5", "Orlando", "FL",
-      "32801", "US", "19482937549");
+  autofill::test::SetProfileInfoWithGuid(
+      native_profile, "3BA5FA1B-1EC4-4BB3-9B57-EC92BE3C1A09", "Josephine",
+      "Alicia", "Saenz", "joewayne@me.xyz", "Fox", "1212 Center.", "Bld. 5",
+      "Orlando", "FL", "32801", "US", "19482937549");
 
   std::vector<AutofillProfile*> native_profiles;
   native_profiles.push_back(native_profile);
   EXPECT_CALL(autofill_table(), GetAutofillProfiles(_))
       .WillOnce(DoAll(SetArgumentPointee<0>(native_profiles), Return(true)));
 
   std::vector<AutofillProfile> sync_profiles;
   sync_profiles.push_back(sync_profile);
   AddAutofillHelper<AutofillProfile> add_autofill(this, sync_profiles);
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(add_autofill.callback(), false, AUTOFILL_PROFILE);
   ASSERT_TRUE(add_autofill.success());
 
-  AutofillProfileChange change(
-      AutofillProfileChange::REMOVE, sync_profile.guid(), NULL);
+  AutofillProfileChange change(AutofillProfileChange::REMOVE,
+                               sync_profile.guid(), NULL);
   web_data_service()->OnAutofillProfileChanged(change);
 
   std::vector<AutofillProfile> new_sync_profiles;
-  ASSERT_TRUE(GetAutofillProfilesFromSyncDBUnderProfileNode(
-      &new_sync_profiles));
+  ASSERT_TRUE(
+      GetAutofillProfilesFromSyncDBUnderProfileNode(&new_sync_profiles));
   ASSERT_EQ(0U, new_sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, ServerChangeRace) {
   // Once for MergeDataAndStartSyncing() and twice for ProcessSyncChanges(), via
   // LoadAutofillData().
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
       .Times(3)
       .WillRepeatedly(Return(true));
   // On the other hand Autofill and Autocomplete are separated now, so
@@ skipping 36 matching lines @@
 
   // Let callbacks posted on UI thread execute.
   base::RunLoop().RunUntilIdle();
 
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
-    DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
-             << ", " << sync_entries[i].key().value();
+    DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name() << ", "
+             << sync_entries[i].key().value();
   }
 }