sync: Remove SyncSourceInfo

The SyncSourceInfo was a struct that contained a GetUpdatesSource and a
ModelTypeInvalidationMap.  Both of these types are in the process of
being deprecated.  The SyncSourceInfo itself was used only for debugging
(about:sync), tests (mostly sync_scheduler_unittest.cc) and maintaining
compatibility with some old function signatures.

Removing the SyncSourceInfo allow us to remove dependencies on
ModelTypeInvalidationMap, which is a step towards enabling invalidation
"trickles" support.

BUG=233437

Review URL: https://chromiumcodereview.appspot.com/19982002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@215446 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 153 insertions, 266 deletions

diff --git a/sync/engine/sync_scheduler_unittest.cc b/sync/engine/sync_scheduler_unittest.cc
index a09079a..f76e1c5 100644
--- a/sync/engine/sync_scheduler_unittest.cc
+++ b/sync/engine/sync_scheduler_unittest.cc
@@ -11,7 +11,6 @@
 #include "sync/engine/backoff_delay_provider.h"
 #include "sync/engine/sync_scheduler_impl.h"
 #include "sync/engine/syncer.h"
-#include "sync/internal_api/public/base/model_type_invalidation_map_test_util.h"
 #include "sync/sessions/test_util.h"
 #include "sync/test/callback_counter.h"
 #include "sync/test/engine/fake_model_worker.h"
@@ -26,10 +25,8 @@ using base::TimeTicks;
 using testing::_;
 using testing::AtLeast;
 using testing::DoAll;
-using testing::Eq;
 using testing::Invoke;
 using testing::Mock;
-using testing::Not;
 using testing::Return;
 using testing::WithArg;
 using testing::WithArgs;
@@ -37,7 +34,6 @@ using testing::WithArgs;
 namespace syncer {
 using sessions::SyncSession;
 using sessions::SyncSessionContext;
-using sessions::SyncSessionSnapshot;
 using sync_pb::GetUpdatesCallerInfo;
 
 class MockSyncer : public Syncer {
@@ -45,15 +41,14 @@ class MockSyncer : public Syncer {
   MOCK_METHOD3(NormalSyncShare, bool(ModelTypeSet,
                                      const sessions::NudgeTracker&,
                                      sessions::SyncSession*));
-  MOCK_METHOD2(ConfigureSyncShare, bool(ModelTypeSet, sessions::SyncSession*));
+  MOCK_METHOD3(ConfigureSyncShare,
+               bool(ModelTypeSet,
+                    sync_pb::GetUpdatesCallerInfo::GetUpdatesSource,
+                    SyncSession*));
   MOCK_METHOD2(PollSyncShare, bool(ModelTypeSet, sessions::SyncSession*));
 };
 
-// Used when tests want to record syncing activity to examine later.
-struct SyncShareRecords {
-  std::vector<TimeTicks> times;
-  std::vector<SyncSessionSnapshot> snapshots;
-};
+typedef std::vector<TimeTicks> SyncShareTimes;
 
 void QuitLoopNow() {
   // We use QuitNow() instead of Quit() as the latter may get stalled
@@ -90,22 +85,6 @@ ModelSafeRoutingInfo TypesToRoutingInfo(ModelTypeSet types) {
   return routes;
 }
 
-// Compare a ModelTypeSet to a ModelTypeInvalidationMap, ignoring
-// state values.
-testing::AssertionResult ModelTypeSetMatchesInvalidationMap(
-    ModelTypeSet lhs, const ModelTypeInvalidationMap& rhs) {
-  ModelTypeSet rhs_set = ModelTypeInvalidationMapToSet(rhs);
-
-  if (!rhs_set.Equals(rhs_set)) {
-    return testing::AssertionFailure()
-        << "ModelTypeSet: " << ModelTypeSetToString(lhs)
-        << " does not match ModelTypeInvalidationMap: "
-        << ModelTypeSetToString(rhs_set);
-  } else {
-    return testing::AssertionSuccess();
-  }
-}
-
 // Convenient to use in tests wishing to analyze SyncShare calls over time.
 static const size_t kMinNumSamples = 5;
 class SyncSchedulerTest : public testing::Test {
@@ -124,7 +103,7 @@ class SyncSchedulerTest : public testing::Test {
 
   virtual void SetUp() {
     dir_maker_.SetUp();
-    syncer_ = new MockSyncer();
+    syncer_ = new testing::StrictMock<MockSyncer>();
     delay_ = NULL;
     extensions_activity_ = new ExtensionsActivity();
 
@@ -180,16 +159,13 @@ class SyncSchedulerTest : public testing::Test {
     dir_maker_.TearDown();
   }
 
-  void AnalyzePollRun(const SyncShareRecords& records, size_t min_num_samples,
+  void AnalyzePollRun(const SyncShareTimes& times, size_t min_num_samples,
       const TimeTicks& optimal_start, const TimeDelta& poll_interval) {
-    const std::vector<TimeTicks>& data(records.times);
-    EXPECT_GE(data.size(), min_num_samples);
-    for (size_t i = 0; i < data.size(); i++) {
+    EXPECT_GE(times.size(), min_num_samples);
+    for (size_t i = 0; i < times.size(); i++) {
       SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
       TimeTicks optimal_next_sync = optimal_start + poll_interval * i;
-      EXPECT_GE(data[i], optimal_next_sync);
-      EXPECT_EQ(GetUpdatesCallerInfo::PERIODIC,
-                records.snapshots[i].source().updates_source);
+      EXPECT_GE(times[i], optimal_next_sync);
     }
   }
 
@@ -249,22 +225,21 @@ class SyncSchedulerTest : public testing::Test {
   ModelSafeRoutingInfo routing_info_;
 };
 
-void RecordSyncShareImpl(SyncSession* s, SyncShareRecords* record) {
-  record->times.push_back(TimeTicks::Now());
-  record->snapshots.push_back(s->TakeSnapshot());
+void RecordSyncShareImpl(SyncShareTimes* times) {
+  times->push_back(TimeTicks::Now());
 }
 
-ACTION_P(RecordSyncShare, record) {
-  RecordSyncShareImpl(arg0, record);
+ACTION_P(RecordSyncShare, times) {
+  RecordSyncShareImpl(times);
   if (base::MessageLoop::current()->is_running())
     QuitLoopNow();
   return true;
 }
 
-ACTION_P2(RecordSyncShareMultiple, record, quit_after) {
-  RecordSyncShareImpl(arg0, record);
-  EXPECT_LE(record->times.size(), quit_after);
-  if (record->times.size() >= quit_after &&
+ACTION_P2(RecordSyncShareMultiple, times, quit_after) {
+  RecordSyncShareImpl(times);
+  EXPECT_LE(times->size(), quit_after);
+  if (times->size() >= quit_after &&
       base::MessageLoop::current()->is_running()) {
     QuitLoopNow();
   }
@@ -284,12 +259,12 @@ ACTION(QuitLoopNowAction) {
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, Nudge) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   ModelTypeSet model_types(BOOKMARKS);
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&records))))
+                      RecordSyncShare(&times)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -297,42 +272,28 @@ TEST_F(SyncSchedulerTest, Nudge) {
   scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
   RunLoop();
 
-  ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          model_types,
-          records.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records.snapshots[0].source().updates_source);
-
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
-  SyncShareRecords records2;
+  SyncShareTimes times2;
   model_types.Remove(BOOKMARKS);
   model_types.Put(AUTOFILL);
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&records2))));
+                      RecordSyncShare(&times2)));
   scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
   RunLoop();
-
-  ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          model_types,
-          records2.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records2.snapshots[0].source().updates_source);
 }
 
 // Make sure a regular config command is scheduled fine in the absence of any
 // errors.
 TEST_F(SyncSchedulerTest, Config) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   const ModelTypeSet model_types(BOOKMARKS);
 
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
-                      WithArg<1>(RecordSyncShare(&records))));
+                      RecordSyncShare(&times)));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
@@ -344,13 +305,6 @@ TEST_F(SyncSchedulerTest, Config) {
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
   ASSERT_TRUE(scheduler()->ScheduleConfiguration(params));
   ASSERT_EQ(1, counter.times_called());
-
-  ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          model_types,
-          records.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[0].source().updates_source);
 }
 
 // Simulate a failure and make sure the config request is retried.
@@ -358,18 +312,15 @@ TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
-  SyncShareRecords records;
+  SyncShareTimes times;
   const ModelTypeSet model_types(BOOKMARKS);
 
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
-                      WithArg<1>(RecordSyncShare(&records))))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
-                      WithArg<1>(RecordSyncShare(&records))));
-
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
-  ASSERT_EQ(0U, records.snapshots.size());
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
+                      RecordSyncShare(&times)));
+
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
@@ -379,16 +330,14 @@ TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   ASSERT_FALSE(scheduler()->ScheduleConfiguration(params));
   ASSERT_EQ(0, counter.times_called());
 
-  ASSERT_EQ(1U, records.snapshots.size());
+  Mock::VerifyAndClearExpectations(syncer());
+
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
+                      RecordSyncShare(&times)));
   RunLoop();
 
-  ASSERT_EQ(2U, records.snapshots.size());
   ASSERT_EQ(1, counter.times_called());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          model_types,
-          records.snapshots[1].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[1].source().updates_source);
 }
 
 // Issue a nudge when the config has failed. Make sure both the config and
@@ -398,23 +347,14 @@ TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(50)));
-  SyncShareRecords records;
-
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
-                      WithArg<1>(RecordSyncShare(&records))))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
-                      WithArg<1>(RecordSyncShare(&records))))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
-                      WithArg<1>(RecordSyncShare(&records))));
-
-  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&records))));
+  SyncShareTimes times;
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
-  ASSERT_EQ(0U, records.snapshots.size());
+  // Request a configure and make sure it fails.
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
+                      RecordSyncShare(&times)));
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
@@ -423,50 +363,41 @@ TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
   ASSERT_FALSE(scheduler()->ScheduleConfiguration(params));
   ASSERT_EQ(0, counter.times_called());
-  ASSERT_EQ(1U, records.snapshots.size());
+  Mock::VerifyAndClearExpectations(syncer());
 
+  // Ask for a nudge while dealing with repeated configure failure.
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
+                      RecordSyncShare(&times)));
   scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
   RunLoop();
   // Note that we're not RunLoop()ing for the NUDGE we just scheduled, but
   // for the first retry attempt from the config job (after
   // waiting ~+/- 50ms).
-  ASSERT_EQ(2U, records.snapshots.size());
+  Mock::VerifyAndClearExpectations(syncer());
   ASSERT_EQ(0, counter.times_called());
-  EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[1].source().updates_source);
 
+  // Let the next configure retry succeed.
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
+                      RecordSyncShare(&times)));
   RunLoop();
-  // This is the 3rd attempt, which we've set up to SimulateSuccess.
-  ASSERT_EQ(3U, records.snapshots.size());
-  ASSERT_EQ(1, counter.times_called());
 
   // Now change the mode so nudge can execute.
+  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
+                      RecordSyncShare(&times)));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-
-  ASSERT_EQ(4U, records.snapshots.size());
-
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          model_types,
-          records.snapshots[2].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
-            records.snapshots[2].source().updates_source);
-
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          model_types,
-          records.snapshots[3].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records.snapshots[3].source().updates_source);
-
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  SyncShareRecords r;
+  SyncShareTimes times;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&r))));
+                      RecordSyncShare(&times)));
   const ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3(THEMES);
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
@@ -474,39 +405,27 @@ TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
   RunLoop();
 
-  ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_GE(r.times[0], optimal_time);
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          Union(types1, types2),
-          r.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0].source().updates_source);
+  ASSERT_EQ(1U, times.size());
+  EXPECT_GE(times[0], optimal_time);
 
   Mock::VerifyAndClearExpectations(syncer());
 
-  SyncShareRecords r2;
+  SyncShareTimes times2;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&r2))));
+                      RecordSyncShare(&times2)));
   scheduler()->ScheduleLocalNudge(zero(), types3, FROM_HERE);
   RunLoop();
-
-  ASSERT_EQ(1U, r2.snapshots.size());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          types3,
-          r2.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r2.snapshots[0].source().updates_source);
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  SyncShareRecords r;
+  SyncShareTimes times;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&r))));
+                      RecordSyncShare(&times)));
   ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3;
 
   // Create a huge time delay.
@@ -519,64 +438,50 @@ TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
   TimeTicks max_time = TimeTicks::Now() + delay;
 
   RunLoop();
-
-  // Make sure the sync has happened.
-  ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          Union(types1, types2),
-          r.snapshots[0].source().types));
+  Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure the sync happened at the right time.
-  EXPECT_GE(r.times[0], min_time);
-  EXPECT_LE(r.times[0], max_time);
+  ASSERT_EQ(1U, times.size());
+  EXPECT_GE(times[0], min_time);
+  EXPECT_LE(times[0], max_time);
 }
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, NudgeWithStates) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  SyncShareRecords records;
+  SyncShareTimes times;
   const ModelTypeSet types(BOOKMARKS);
   ModelTypeInvalidationMap invalidation_map =
       ModelTypeSetToInvalidationMap(types, "test");
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&records))))
+                      RecordSyncShare(&times)))
       .RetiresOnSaturation();
   scheduler()->ScheduleInvalidationNudge(zero(), invalidation_map, FROM_HERE);
   RunLoop();
 
-  ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_THAT(invalidation_map, Eq(records.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
-            records.snapshots[0].source().updates_source);
-
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
-  SyncShareRecords records2;
+  SyncShareTimes times2;
   invalidation_map.erase(BOOKMARKS);
   invalidation_map[AUTOFILL].payload = "test2";
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&records2))));
+                      RecordSyncShare(&times2)));
   scheduler()->ScheduleInvalidationNudge(zero(), invalidation_map, FROM_HERE);
   RunLoop();
-
-  ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_THAT(invalidation_map, Eq(records2.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
-            records2.snapshots[0].source().updates_source);
 }
 
 // Test that polling works as expected.
 TEST_F(SyncSchedulerTest, Polling) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll_interval(TimeDelta::FromMilliseconds(30));
   EXPECT_CALL(*syncer(), PollSyncShare(_,_)).Times(AtLeast(kMinNumSamples))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           WithArg<1>(RecordSyncShareMultiple(&records, kMinNumSamples))));
+           RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
 
@@ -587,16 +492,16 @@ TEST_F(SyncSchedulerTest, Polling) {
   RunLoop();
 
   StopSyncScheduler();
-  AnalyzePollRun(records, kMinNumSamples, optimal_start, poll_interval);
+  AnalyzePollRun(times, kMinNumSamples, optimal_start, poll_interval);
 }
 
 // Test that the short poll interval is used.
 TEST_F(SyncSchedulerTest, PollNotificationsDisabled) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll_interval(TimeDelta::FromMilliseconds(30));
   EXPECT_CALL(*syncer(), PollSyncShare(_,_)).Times(AtLeast(kMinNumSamples))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           WithArg<1>(RecordSyncShareMultiple(&records, kMinNumSamples))));
+           RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   scheduler()->OnReceivedShortPollIntervalUpdate(poll_interval);
   scheduler()->SetNotificationsEnabled(false);
@@ -608,12 +513,12 @@ TEST_F(SyncSchedulerTest, PollNotificationsDisabled) {
   RunLoop();
 
   StopSyncScheduler();
-  AnalyzePollRun(records, kMinNumSamples, optimal_start, poll_interval);
+  AnalyzePollRun(times, kMinNumSamples, optimal_start, poll_interval);
 }
 
 // Test that polling intervals are updated when needed.
 TEST_F(SyncSchedulerTest, PollIntervalUpdate) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll1(TimeDelta::FromMilliseconds(120));
   TimeDelta poll2(TimeDelta::FromMilliseconds(30));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll1);
@@ -625,7 +530,7 @@ TEST_F(SyncSchedulerTest, PollIntervalUpdate) {
       .WillRepeatedly(
           DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
                 WithArg<1>(
-                    RecordSyncShareMultiple(&records, kMinNumSamples))));
+                    RecordSyncShareMultiple(&times, kMinNumSamples))));
 
   TimeTicks optimal_start = TimeTicks::Now() + poll1 + poll2;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -634,12 +539,12 @@ TEST_F(SyncSchedulerTest, PollIntervalUpdate) {
   RunLoop();
 
   StopSyncScheduler();
-  AnalyzePollRun(records, kMinNumSamples, optimal_start, poll2);
+  AnalyzePollRun(times, kMinNumSamples, optimal_start, poll2);
 }
 
 // Test that the sessions commit delay is updated when needed.
 TEST_F(SyncSchedulerTest, SessionsCommitDelay) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta delay1(TimeDelta::FromMilliseconds(120));
   TimeDelta delay2(TimeDelta::FromMilliseconds(30));
   scheduler()->OnReceivedSessionsCommitDelay(delay1);
@@ -672,9 +577,9 @@ TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
   TimeDelta throttle(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(
-          WithArg<1>(sessions::test_util::SimulateThrottled(throttle)),
+          WithArg<2>(sessions::test_util::SimulateThrottled(throttle)),
           Return(true)))
       .WillRepeatedly(AddFailureAndQuitLoopNow());
 
@@ -697,7 +602,7 @@ TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpiresFromPoll) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   TimeDelta throttle1(TimeDelta::FromMilliseconds(150));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
@@ -710,7 +615,7 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromPoll) {
       .RetiresOnSaturation();
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           WithArg<1>(RecordSyncShareMultiple(&records, kMinNumSamples))));
+           RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   TimeTicks optimal_start = TimeTicks::Now() + poll + throttle1;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -719,11 +624,11 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromPoll) {
   RunLoop();
 
   StopSyncScheduler();
-  AnalyzePollRun(records, kMinNumSamples, optimal_start, poll);
+  AnalyzePollRun(times, kMinNumSamples, optimal_start, poll);
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpiresFromNudge) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromMilliseconds(150));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
@@ -751,18 +656,18 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromNudge) {
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpiresFromConfigure) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromMilliseconds(150));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   ::testing::InSequence seq;
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(
-          WithArg<1>(sessions::test_util::SimulateThrottled(throttle1)),
+          WithArg<2>(sessions::test_util::SimulateThrottled(throttle1)),
           Return(true)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       QuitLoopNowAction()));
 
@@ -821,7 +726,7 @@ TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(zero()));
 
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
@@ -837,14 +742,10 @@ TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
                   throttled_types, throttle1)),
           Return(true)))
       .RetiresOnSaturation();
-  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
-      .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                            WithArg<2>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   scheduler()->ScheduleLocalNudge(zero(), throttled_types, FROM_HERE);
   PumpLoop();
-  EXPECT_EQ(0U, records.snapshots.size());
   EXPECT_TRUE(GetThrottledTypes().HasAll(throttled_types));
 
   // Ignore invalidations for throttled types.
@@ -852,17 +753,20 @@ TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
       ModelTypeSetToInvalidationMap(throttled_types, "test");
   scheduler()->ScheduleInvalidationNudge(zero(), invalidation_map, FROM_HERE);
   PumpLoop();
-  EXPECT_EQ(0U, records.snapshots.size());
 
   // Ignore refresh requests for throttled types.
   scheduler()->ScheduleLocalRefreshRequest(zero(), throttled_types, FROM_HERE);
   PumpLoop();
-  EXPECT_EQ(0U, records.snapshots.size());
+
+  Mock::VerifyAndClearExpectations(syncer());
 
   // Local nudges for non-throttled types will trigger a sync.
+  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
+      .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
+                            RecordSyncShare(&times)));
   scheduler()->ScheduleLocalNudge(zero(), unthrottled_types, FROM_HERE);
   RunLoop();
-  EXPECT_EQ(1U, records.snapshots.size());
+  Mock::VerifyAndClearExpectations(syncer());
 
   StopSyncScheduler();
 }
@@ -870,12 +774,8 @@ TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
 // Test nudges / polls don't run in config mode and config tasks do.
 TEST_F(SyncSchedulerTest, ConfigurationMode) {
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
-  SyncShareRecords records;
+  SyncShareTimes times;
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
-                      WithArg<1>(RecordSyncShare(&records))))
-      .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
@@ -885,6 +785,10 @@ TEST_F(SyncSchedulerTest, ConfigurationMode) {
 
   const ModelTypeSet config_types(BOOKMARKS);
 
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
+                      RecordSyncShare(&times)))
+      .RetiresOnSaturation();
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
@@ -893,32 +797,20 @@ TEST_F(SyncSchedulerTest, ConfigurationMode) {
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
   ASSERT_TRUE(scheduler()->ScheduleConfiguration(params));
   ASSERT_EQ(1, counter.times_called());
-
-  ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          config_types,
-          records.snapshots[0].source().types));
+  Mock::VerifyAndClearExpectations(syncer());
 
   // Switch to NORMAL_MODE to ensure NUDGES were properly saved and run.
-  // SyncSchedulerWhiteboxTest also provides coverage for this, but much
-  // more targeted ('whitebox' style).
   scheduler()->OnReceivedLongPollIntervalUpdate(TimeDelta::FromDays(1));
-  SyncShareRecords records2;
+  SyncShareTimes times2;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
-                      WithArg<2>(RecordSyncShare(&records2))));
+                      RecordSyncShare(&times2)));
 
   // TODO(tim): Figure out how to remove this dangerous need to reset
   // routing info between mode switches.
   context()->set_routing_info(routing_info());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            records2.snapshots[0].source().updates_source);
-  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
-          nudge_types,
-          records2.snapshots[0].source().types));
   PumpLoop();
 }
 
@@ -985,7 +877,7 @@ TEST_F(BackoffTriggersSyncSchedulerTest, FailDownloadTwice) {
 // Have the syncer fail to get the encryption key yet succeed in downloading
 // updates. Expect this will leave the scheduler in backoff.
 TEST_F(BackoffTriggersSyncSchedulerTest, FailGetEncryptionKey) {
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(
           Invoke(sessions::test_util::SimulateGetEncryptionKeyFailed),
           Return(true)))
@@ -1009,15 +901,15 @@ TEST_F(BackoffTriggersSyncSchedulerTest, FailGetEncryptionKey) {
 
 // Test that no polls or extraneous nudges occur when in backoff.
 TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
-  SyncShareRecords r;
+  SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromMilliseconds(5));
   const ModelTypeSet types(BOOKMARKS);
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
-      .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
-                            WithArg<2>(RecordSyncShareMultiple(&r, 1U))));
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
+                      RecordSyncShareMultiple(&times, 1U)));
   EXPECT_CALL(*delay(), GetDelay(_)).
       WillRepeatedly(Return(TimeDelta::FromDays(1)));
 
@@ -1028,10 +920,8 @@ TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
   scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
   RunLoop();
 
+  // From this point forward, no SyncShare functions should be invoked.
   Mock::VerifyAndClearExpectations(syncer());
-  ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0].source().updates_source);
 
   // Wait a while (10x poll interval) so a few poll jobs will be attempted.
   PumpLoopFor(poll * 10);
@@ -1045,8 +935,6 @@ TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
 
-  ASSERT_EQ(1U, r.snapshots.size());
-
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
@@ -1063,12 +951,12 @@ TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
 
 // Test that backoff is shaping traffic properly with consecutive errors.
 TEST_F(SyncSchedulerTest, BackoffElevation) {
-  SyncShareRecords r;
+  SyncShareTimes times;
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_)).Times(kMinNumSamples)
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
-          WithArg<2>(RecordSyncShareMultiple(&r, kMinNumSamples))));
+          RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   const TimeDelta first = TimeDelta::FromSeconds(kInitialBackoffRetrySeconds);
   const TimeDelta second = TimeDelta::FromMilliseconds(2);
@@ -1093,80 +981,79 @@ TEST_F(SyncSchedulerTest, BackoffElevation) {
   scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
   RunLoop();
 
-  ASSERT_EQ(kMinNumSamples, r.snapshots.size());
-  EXPECT_GE(r.times[1] - r.times[0], second);
-  EXPECT_GE(r.times[2] - r.times[1], third);
-  EXPECT_GE(r.times[3] - r.times[2], fourth);
-  EXPECT_GE(r.times[4] - r.times[3], fifth);
+  ASSERT_EQ(kMinNumSamples, times.size());
+  EXPECT_GE(times[1] - times[0], second);
+  EXPECT_GE(times[2] - times[1], third);
+  EXPECT_GE(times[3] - times[2], fourth);
+  EXPECT_GE(times[4] - times[3], fifth);
 }
 
 // Test that things go back to normal once a retry makes forward progress.
 TEST_F(SyncSchedulerTest, BackoffRelief) {
-  SyncShareRecords r;
+  SyncShareTimes times;
   const TimeDelta poll(TimeDelta::FromMilliseconds(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   const TimeDelta backoff = TimeDelta::FromMilliseconds(5);
-
-  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
-                      WithArg<2>(RecordSyncShareMultiple(&r, kMinNumSamples))))
-      .WillRepeatedly(DoAll(
-              Invoke(sessions::test_util::SimulateNormalSuccess),
-              WithArg<2>(RecordSyncShareMultiple(&r, kMinNumSamples))));
-  EXPECT_CALL(*syncer(), PollSyncShare(_,_))
-      .WillRepeatedly(DoAll(
-              Invoke(sessions::test_util::SimulatePollSuccess),
-              WithArg<1>(RecordSyncShareMultiple(&r, kMinNumSamples))));
   EXPECT_CALL(*delay(), GetDelay(_)).WillOnce(Return(backoff));
 
   // Optimal start for the post-backoff poll party.
   TimeTicks optimal_start = TimeTicks::Now();
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  // Run again to wait for polling.
+  // Kick off the test with a failed nudge.
+  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
+                      RecordSyncShare(&times)));
   scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
   RunLoop();
-
-  StopSyncScheduler();
-
-  EXPECT_EQ(kMinNumSamples, r.times.size());
-
-  // The first nudge ran as soon as possible.  It failed.
+  Mock::VerifyAndClearExpectations(syncer());
   TimeTicks optimal_job_time = optimal_start;
-  EXPECT_GE(r.times[0], optimal_job_time);
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0].source().updates_source);
+  ASSERT_EQ(1U, times.size());
+  EXPECT_GE(times[0], optimal_job_time);
 
-  // It was followed by a successful retry nudge shortly afterward.
+  // The retry succeeds.
+  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
+      .WillOnce(DoAll(
+              Invoke(sessions::test_util::SimulateNormalSuccess),
+              RecordSyncShare(&times)));
+  RunLoop();
+  Mock::VerifyAndClearExpectations(syncer());
   optimal_job_time = optimal_job_time + backoff;
-  EXPECT_GE(r.times[1], optimal_job_time);
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[1].source().updates_source);
-  // After that, we went back to polling.
-  for (size_t i = 2; i < r.snapshots.size(); i++) {
+  ASSERT_EQ(2U, times.size());
+  EXPECT_GE(times[1], optimal_job_time);
+
+  // Now let the Poll timer do its thing.
+  EXPECT_CALL(*syncer(), PollSyncShare(_,_))
+      .WillRepeatedly(DoAll(
+              Invoke(sessions::test_util::SimulatePollSuccess),
+              RecordSyncShareMultiple(&times, kMinNumSamples)));
+  RunLoop();
+  Mock::VerifyAndClearExpectations(syncer());
+  ASSERT_EQ(kMinNumSamples, times.size());
+  for (size_t i = 2; i < times.size(); i++) {
     optimal_job_time = optimal_job_time + poll;
     SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
-    EXPECT_GE(r.times[i], optimal_job_time);
-    EXPECT_EQ(GetUpdatesCallerInfo::PERIODIC,
-              r.snapshots[i].source().updates_source);
+    EXPECT_GE(times[i], optimal_job_time);
   }
+
+  StopSyncScheduler();
 }
 
 // Test that poll failures are ignored.  They should have no effect on
 // subsequent poll attempts, nor should they trigger a backoff/retry.
 TEST_F(SyncSchedulerTest, TransientPollFailure) {
-  SyncShareRecords r;
+  SyncShareTimes times;
   const TimeDelta poll_interval(TimeDelta::FromMilliseconds(1));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
   UseMockDelayProvider(); // Will cause test failure if backoff is initiated.
 
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollFailed),
-                      WithArg<1>(RecordSyncShare(&r))))
+                      RecordSyncShare(&times)))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-                      WithArg<1>(RecordSyncShare(&r))));
+                      RecordSyncShare(&times)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
@@ -1264,7 +1151,7 @@ TEST_F(SyncSchedulerTest, ConnectionChangeCanaryPreemptedByNudge) {
 // Tests that we don't crash trying to run two canaries at once if we receive
 // extra connection status change notifications.  See crbug.com/190085.
 TEST_F(SyncSchedulerTest, DoubleCanaryInConfigure) {
-  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_))
+  EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillRepeatedly(DoAll(
               Invoke(sessions::test_util::SimulateConfigureConnectionFailure),
               Return(true)));
@@ -1288,14 +1175,14 @@ TEST_F(SyncSchedulerTest, DoubleCanaryInConfigure) {
 }
 
 TEST_F(SyncSchedulerTest, PollFromCanaryAfterAuthError) {
-  SyncShareRecords records;
+  SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           WithArg<1>(RecordSyncShareMultiple(&records, kMinNumSamples))));
+           RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   connection()->SetServerStatus(HttpResponse::SYNC_AUTH_ERROR);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -1308,7 +1195,7 @@ TEST_F(SyncSchedulerTest, PollFromCanaryAfterAuthError) {
   // poll once more
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-                      WithArg<1>(RecordSyncShare(&records))));
+                      RecordSyncShare(&times)));
   scheduler()->OnCredentialsUpdated();
   connection()->SetServerStatus(HttpResponse::SERVER_CONNECTION_OK);
   StopSyncScheduler();