sync: Report GetUpdate triggers to the server

sync/engine/sync_scheduler_unittest.cc

 // Copyright (c) 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 "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 69 matching lines @@
 }
 
 ModelSafeRoutingInfo TypesToRoutingInfo(ModelTypeSet types) {
   ModelSafeRoutingInfo routes;
   for (ModelTypeSet::Iterator iter = types.First(); iter.Good(); iter.Inc()) {
     routes[iter.Get()] = GROUP_PASSIVE;
   }
   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 {
  public:
   SyncSchedulerTest()
       : weak_ptr_factory_(this),
         context_(NULL),
         syncer_(NULL),
         delay_(NULL) {}
 
@@ skipping 89 matching lines @@
   void StopSyncScheduler() {
     scheduler()->RequestStop(base::Bind(&SyncSchedulerTest::DoQuitLoopNow,
                              weak_ptr_factory_.GetWeakPtr()));
     RunLoop();
   }
 
   bool RunAndGetBackoff() {
     ModelTypeSet nudge_types(BOOKMARKS);
     StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-    scheduler()->ScheduleNudgeAsync(
-        zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
+    scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
     RunLoop();
 
     return scheduler()->IsBackingOff();
   }
 
   void UseMockDelayProvider() {
     delay_ = new MockDelayProvider();
     scheduler_->delay_provider_.reset(delay_);
   }
 
-  // Compare a ModelTypeSet to a ModelTypeInvalidationMap, ignoring
-  // state values.
-  bool CompareModelTypeSetToModelTypeInvalidationMap(
-      ModelTypeSet lhs,
-      const ModelTypeInvalidationMap& rhs) {
-    size_t count = 0;
-    for (ModelTypeInvalidationMap::const_iterator i = rhs.begin();
-         i != rhs.end(); ++i, ++count) {
-      if (!lhs.Has(i->first))
-        return false;
-    }
-    if (lhs.Size() != count)
-      return false;
-    return true;
-  }
-
   SyncSessionContext* context() { return context_.get(); }
 
  private:
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
   base::WeakPtrFactory<SyncSchedulerTest> weak_ptr_factory_;
   base::MessageLoop message_loop_;
   TestDirectorySetterUpper dir_maker_;
@@ skipping 46 matching lines @@
   SyncShareRecords records;
   ModelTypeSet model_types(BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
-      records.snapshots[0].source().types));
+  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;
   model_types.Remove(BOOKMARKS);
   model_types.Put(AUTOFILL);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
-      records2.snapshots[0].source().types));
+  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;
   const ModelTypeSet model_types(BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
       model_types,
       TypesToRoutingInfo(model_types),
       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(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
-      records.snapshots[0].source().types));
+  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.
 TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
   SyncShareRecords records;
@@ skipping 15 matching lines @@
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
   ASSERT_FALSE(scheduler()->ScheduleConfiguration(params));
   ASSERT_EQ(0, counter.times_called());
 
   ASSERT_EQ(1U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   ASSERT_EQ(1, counter.times_called());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
-      records.snapshots[1].source().types));
+  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
 // nudge are executed.
 TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
   const ModelTypeSet model_types(BOOKMARKS);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
@@ skipping 16 matching lines @@
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
       model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
   ASSERT_FALSE(scheduler()->ScheduleConfiguration(params));
   ASSERT_EQ(0, counter.times_called());
   ASSERT_EQ(1U, records.snapshots.size());
 
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
+  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());
   ASSERT_EQ(0, counter.times_called());
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[1].source().updates_source);
 
   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.
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   ASSERT_EQ(4U, records.snapshots.size());
 
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
-      records.snapshots[2].source().types));
+  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
+          model_types,
+          records.snapshots[2].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[2].source().updates_source);
 
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
-      records.snapshots[3].source().types));
+  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;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   const ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3(THEMES);
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
-  scheduler()->ScheduleNudgeAsync(
-      delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(delay, types1, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(
-      Union(types1, types2), r.snapshots[0].source().types));
+  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
+          Union(types1, types2),
+          r.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             r.snapshots[0].source().updates_source);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   SyncShareRecords r2;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r2))));
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), types3, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(types3,
-      r2.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
+  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;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3;
 
   // Create a huge time delay.
   TimeDelta delay = TimeDelta::FromDays(1);
 
-  scheduler()->ScheduleNudgeAsync(
-      delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
-
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_UNKNOWN, types2, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(delay, types1, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
 
   TimeTicks min_time = TimeTicks::Now();
   TimeTicks max_time = TimeTicks::Now() + delay;
 
   RunLoop();
 
   // Make sure the sync has happened.
   ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(
-      Union(types1, types2), r.snapshots[0].source().types));
+  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
+          Union(types1, types2),
+          r.snapshots[0].source().types));
 
   // Make sure the sync happened at the right time.
   EXPECT_GE(r.times[0], min_time);
   EXPECT_LE(r.times[0], max_time);
 }
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, NudgeWithStates) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   SyncShareRecords records;
   const ModelTypeSet types(BOOKMARKS);
   ModelTypeInvalidationMap invalidation_map =
       ModelTypeSetToInvalidationMap(types, "test");
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
-  scheduler()->ScheduleNudgeWithStatesAsync(
-      zero(), NUDGE_SOURCE_LOCAL, invalidation_map, FROM_HERE);
+  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::LOCAL,
+  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;
   invalidation_map.erase(BOOKMARKS);
   invalidation_map[AUTOFILL].payload = "test2";
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
-  scheduler()->ScheduleNudgeWithStatesAsync(
-      zero(), NUDGE_SOURCE_LOCAL, invalidation_map, FROM_HERE);
+  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::LOCAL,
+  EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
             records2.snapshots[0].source().updates_source);
 }
 
-// Test that nudges are coalesced.
-TEST_F(SyncSchedulerTest, NudgeWithStatesCoalescing) {
-  StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-
-  SyncShareRecords r;
-  EXPECT_CALL(*syncer(), SyncShare(_,_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
-                      WithArg<0>(RecordSyncShare(&r))));
-  ModelTypeInvalidationMap types1, types2, types3;
-  types1[BOOKMARKS].payload = "test1";
-  types2[AUTOFILL].payload = "test2";
-  types3[THEMES].payload = "test3";
-  TimeDelta delay = zero();
-  TimeTicks optimal_time = TimeTicks::Now() + delay;
-  scheduler()->ScheduleNudgeWithStatesAsync(
-      delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
-  scheduler()->ScheduleNudgeWithStatesAsync(
-      zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
-  RunLoop();
-
-  ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_GE(r.times[0], optimal_time);
-  ModelTypeInvalidationMap coalesced_types;
-  CoalesceStates(types1, &coalesced_types);
-  CoalesceStates(types2, &coalesced_types);
-  EXPECT_THAT(coalesced_types, Eq(r.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
-            r.snapshots[0].source().updates_source);
-
-  Mock::VerifyAndClearExpectations(syncer());
-
-  SyncShareRecords r2;
-  EXPECT_CALL(*syncer(), SyncShare(_,_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
-                      WithArg<0>(RecordSyncShare(&r2))));
-  scheduler()->ScheduleNudgeWithStatesAsync(
-      zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
-  RunLoop();
-
-  ASSERT_EQ(1U, r2.snapshots.size());
-  EXPECT_THAT(types3, Eq(r2.snapshots[0].source().types));
-  EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
-            r2.snapshots[0].source().updates_source);
-}
-
 // Test that polling works as expected.
 TEST_F(SyncSchedulerTest, Polling) {
   SyncShareRecords records;
   TimeDelta poll_interval(TimeDelta::FromMilliseconds(30));
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(AtLeast(kMinNumSamples))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
            WithArg<0>(RecordSyncShareMultiple(&records, kMinNumSamples))));
 
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
 
@@ skipping 68 matching lines @@
                   sessions::test_util::SimulateSessionsCommitDelayUpdate(
                       delay2)),
               Invoke(sessions::test_util::SimulateSuccess),
               QuitLoopNowAction()));
 
   EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
   const ModelTypeSet model_types(BOOKMARKS);
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
   RunLoop();
 
   EXPECT_EQ(delay2, scheduler()->GetSessionsCommitDelay());
   StopSyncScheduler();
 }
 
 // Test that no syncing occurs when throttled.
 TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
   const ModelTypeSet types(BOOKMARKS);
   TimeDelta poll(TimeDelta::FromMilliseconds(5));
   TimeDelta throttle(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(
           WithArg<0>(sessions::test_util::SimulateThrottled(throttle)),
           Return(true)))
       .WillRepeatedly(AddFailureAndQuitLoopNow());
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleNudgeAsync(
-      TimeDelta::FromMicroseconds(1), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(
+      TimeDelta::FromMicroseconds(1), types, FROM_HERE);
   PumpLoop();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
       types,
       TypesToRoutingInfo(types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
@@ skipping 38 matching lines @@
       .WillOnce(DoAll(
           WithArg<0>(sessions::test_util::SimulateThrottled(throttle1)),
           Return(true)))
       .RetiresOnSaturation();
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       QuitLoopNowAction()));
 
   const ModelTypeSet types(BOOKMARKS);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
 
   PumpLoop();
   EXPECT_TRUE(scheduler()->IsSyncingCurrentlySilenced());
   RunLoop();
   EXPECT_FALSE(scheduler()->IsSyncingCurrentlySilenced());
 
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpiresFromConfigure) {
@@ skipping 37 matching lines @@
   SyncShareRecords records;
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
   const ModelTypeSet nudge_types(AUTOFILL);
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
 
   const ModelTypeSet config_types(BOOKMARKS);
 
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
       config_types,
       TypesToRoutingInfo(config_types),
       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(CompareModelTypeSetToModelTypeInvalidationMap(config_types,
-      records.snapshots[0].source().types));
+  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
+          config_types,
+          records.snapshots[0].source().types));
 
   // 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;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
 
   // 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(CompareModelTypeSetToModelTypeInvalidationMap(nudge_types,
-      records2.snapshots[0].source().types));
+  EXPECT_TRUE(ModelTypeSetMatchesInvalidationMap(
+          nudge_types,
+          records2.snapshots[0].source().types));
   PumpLoop();
 }
 
 class BackoffTriggersSyncSchedulerTest : public SyncSchedulerTest {
   virtual void SetUp() {
     SyncSchedulerTest::SetUp();
     UseMockDelayProvider();
     EXPECT_CALL(*delay(), GetDelay(_))
         .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
   }
@@ skipping 74 matching lines @@
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                             RecordSyncShareMultiple(&r, 1U)));
   EXPECT_CALL(*delay(), GetDelay(_)).
       WillRepeatedly(Return(TimeDelta::FromDays(1)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   // This nudge should fail and put us into backoff.  Thanks to our mock
   // GetDelay() setup above, this will be a long backoff.
-  scheduler()->ScheduleNudgeAsync(zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
   RunLoop();
 
   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);
 
   // Try (and fail) to schedule a nudge.
-  scheduler()->ScheduleNudgeAsync(
+  scheduler()->ScheduleLocalNudge(
       base::TimeDelta::FromMilliseconds(1),
-      NUDGE_SOURCE_LOCAL,
       types,
       FROM_HERE);
 
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
 
   ASSERT_EQ(1U, r.snapshots.size());
 
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
@@ skipping 31 matching lines @@
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(third)).WillOnce(Return(fourth))
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(fourth)).WillOnce(Return(fifth))
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(fifth)).WillOnce(Return(sixth));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   // Run again with a nudge.
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(BOOKMARKS), FROM_HERE);
+  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);
 }
 
 // Test that things go back to normal once a retry makes forward progress.
@@ skipping 10 matching lines @@
                       RecordSyncShareMultiple(&r, kMinNumSamples)))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                             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.
-  scheduler()->ScheduleNudgeAsync(zero(), NUDGE_SOURCE_LOCAL,
-                                  ModelTypeSet(BOOKMARKS), FROM_HERE);
+  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.
   TimeTicks optimal_job_time = optimal_start;
   EXPECT_GE(r.times[0], optimal_job_time);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
@@ skipping 40 matching lines @@
 }
 
 // Test that appropriate syncer steps are requested for each job type.
 TEST_F(SyncSchedulerTest, SyncerSteps) {
   // Nudges.
   EXPECT_CALL(*syncer(), SyncShare(_, SYNCER_BEGIN, SYNCER_END))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       Return(true)));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Configuration.
   EXPECT_CALL(*syncer(), SyncShare(_, DOWNLOAD_UPDATES, APPLY_UPDATES))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
@@ skipping 37 matching lines @@
 TEST_F(SyncSchedulerTest, StartWhenNotConnected) {
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConnectionFailure),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                     Return(true)));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
   // Should save the nudge for until after the server is reachable.
   base::MessageLoop::current()->RunUntilIdle();
 
   scheduler()->OnConnectionStatusChange();
   connection()->SetServerReachable();
   connection()->UpdateConnectionStatus();
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 TEST_F(SyncSchedulerTest, ServerConnectionChangeDuringBackoff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(0)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConnectionFailure),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                     Return(true)));
 
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
 
   PumpLoop();  // Run the nudge, that will fail and schedule a quick retry.
   ASSERT_TRUE(scheduler()->IsBackingOff());
 
   // Before we run the scheduled canary, trigger a server connection change.
   scheduler()->OnConnectionStatusChange();
   connection()->SetServerReachable();
   connection()->UpdateConnectionStatus();
   base::MessageLoop::current()->RunUntilIdle();
 }
@@ skipping 11 matching lines @@
   connection()->UpdateConnectionStatus();
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConnectionFailure),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                     QuitLoopNowAction()));
 
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
 
   PumpLoop();  // Run the nudge, that will fail and schedule a quick retry.
   ASSERT_TRUE(scheduler()->IsBackingOff());
 
   // Before we run the scheduled canary, trigger a server connection change.
   scheduler()->OnConnectionStatusChange();
   connection()->SetServerReachable();
   connection()->UpdateConnectionStatus();
-  scheduler()->ScheduleNudgeAsync(
-      zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(BOOKMARKS), FROM_HERE);
-  base::MessageLoop::current()->RunUntilIdle();
+  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  MessageLoop::current()->RunUntilIdle();
 }
 
 // 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(), SyncShare(_, DOWNLOAD_UPDATES, APPLY_UPDATES))
       .WillRepeatedly(DoAll(
               Invoke(sessions::test_util::SimulateConnectionFailure),
               Return(true)));
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
 
   ModelTypeSet model_types(BOOKMARKS);
   CallbackCounter counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
       model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&counter)));
   scheduler()->ScheduleConfiguration(params);
 
   scheduler()->OnConnectionStatusChange();
   scheduler()->OnConnectionStatusChange();
 
   PumpLoop();  // Run the nudge, that will fail and schedule a quick retry.
 }
 
 }  // namespace syncer