Replace gmock's deprecated SetArgumentPointee with SetArgPointee.

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 72 matching lines @@
 using syncer::syncable::CREATE;
 using syncer::syncable::GET_TYPE_ROOT;
 using syncer::syncable::MutableEntry;
 using syncer::syncable::UNITTEST;
 using syncer::syncable::WriterTag;
 using syncer::syncable::WriteTransaction;
 using testing::_;
 using testing::DoAll;
 using testing::ElementsAre;
 using testing::Not;
-using testing::SetArgumentPointee;
+using testing::SetArgPointee;
 using testing::Return;
 
 namespace browser_sync {
 
 namespace {
 
 void RegisterAutofillPrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(autofill::prefs::kAutofillEnabled, true);
   registry->RegisterBooleanPref(autofill::prefs::kAutofillWalletImportEnabled,
                                 true);
@@ skipping 731 matching lines @@
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(0U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeEntriesEmptySync) {
   std::vector<AutofillEntry> entries;
   entries.push_back(MakeAutofillEntry("foo", "bar", 1));
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
-      .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
+      .WillOnce(DoAll(SetArgPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   ASSERT_EQ(1U, sync_entries.size());
   EXPECT_EQ(entries[0], sync_entries[0]);
@@ skipping 26 matching lines @@
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeWithDuplicatesEmptySync) {
   // There is buggy autofill code that allows duplicate name/value
   // pairs to exist in the database with separate pair_ids.
   std::vector<AutofillEntry> entries;
   entries.push_back(MakeAutofillEntry("foo", "bar", 1));
   entries.push_back(MakeAutofillEntry("dup", "", 2));
   entries.push_back(MakeAutofillEntry("dup", "", 3));
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
-      .WillOnce(DoAll(SetArgumentPointee<0>(entries), Return(true)));
+      .WillOnce(DoAll(SetArgPointee<0>(entries), Return(true)));
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
   EXPECT_CALL(personal_data_manager(), Refresh());
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(2U, sync_entries.size());
 }
 
 TEST_F(ProfileSyncServiceAutofillTest, HasNativeHasSyncNoMerge) {
   AutofillEntry native_entry(MakeAutofillEntry("native", "entry", 1));
   AutofillEntry sync_entry(MakeAutofillEntry("sync", "entry", 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)));
+      .WillOnce(DoAll(SetArgPointee<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(sync_entry)))
       .WillOnce(Return(true));
 
   EXPECT_CALL(personal_data_manager(), Refresh());
@@ skipping 21 matching lines @@
   AutofillEntry native_entry0(MakeAutofillEntry("native", kEntry, 1));
   AutofillEntry native_entry1(MakeAutofillEntry("native", entry, 1));
   AutofillEntry sync_entry0(MakeAutofillEntry("sync", kEntry, 2));
   AutofillEntry sync_entry1(MakeAutofillEntry("sync", entry, 2));
 
   std::vector<AutofillEntry> native_entries;
   native_entries.push_back(native_entry0);
   native_entries.push_back(native_entry1);
 
   EXPECT_CALL(autofill_table(), GetAllAutofillEntries(_))
-      .WillOnce(DoAll(SetArgumentPointee<0>(native_entries), Return(true)));
+      .WillOnce(DoAll(SetArgPointee<0>(native_entries), Return(true)));
 
   std::vector<AutofillEntry> sync_entries;
   sync_entries.push_back(sync_entry0);
   sync_entries.push_back(sync_entry1);
 
   AddAutofillHelper<AutofillEntry> add_autofill(this, sync_entries);
 
   // Expecting that sync_entry0 and sync_entry1 will be written in an autofill
   // table and a value in sync_entry1 won't lose null terminating symbol.
   EXPECT_CALL(autofill_table(),
@@ skipping 22 matching lines @@
 }
 
 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)));
+      .WillOnce(DoAll(SetArgPointee<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);
@@ skipping 349 matching lines @@
       .WillOnce(Return(true));
   EXPECT_CALL(personal_data_manager(), Refresh());
   SetIdleChangeProcessorExpectations();
   CreateRootHelper create_root(this, AUTOFILL);
   StartSyncService(create_root.callback(), false, AUTOFILL);
   ASSERT_TRUE(create_root.success());
 
   AutofillEntry added_entry(MakeAutofillEntry("added", "entry", 1));
 
   EXPECT_CALL(autofill_table(), GetAutofillTimestamps(_, _, _, _))
-      .WillOnce(DoAll(SetArgumentPointee<2>(added_entry.date_created()),
-                      SetArgumentPointee<3>(added_entry.date_last_used()),
+      .WillOnce(DoAll(SetArgPointee<2>(added_entry.date_created()),
+                      SetArgPointee<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(
@@ skipping 26 matching lines @@
   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)));
+      .WillOnce(DoAll(SetArgPointee<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()),
+      .WillOnce(DoAll(SetArgPointee<2>(updated_entry.date_created()),
+                      SetArgPointee<3>(updated_entry.date_last_used()),
                       Return(true)));
 
   AutofillChangeList changes;
   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_EQ(1U, new_sync_entries.size());
   EXPECT_EQ(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)));
+      .WillOnce(DoAll(SetArgPointee<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()));
   web_data_service()->OnAutofillEntriesChanged(changes);
 
@@ skipping 94 matching lines @@
   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();
   }
 }
 
 }  // namespace browser_sync