[Sync] Add support for server controlled nudge delays

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/message_loop.h"
 #include "base/test/test_timeouts.h"
@@ skipping 109 matching lines @@
     MOCK_METHOD1(GetDelay, TimeDelta(const TimeDelta&));
   };
 
   virtual void SetUp() {
     dir_maker_.SetUp();
     syncer_ = new testing::StrictMock<MockSyncer>();
     delay_ = NULL;
     extensions_activity_ = new ExtensionsActivity();
 
     routing_info_[BOOKMARKS] = GROUP_UI;
-    routing_info_[AUTOFILL] = GROUP_DB;
+    routing_info_[TYPED_URLS] = GROUP_DB;
     routing_info_[THEMES] = GROUP_UI;
     routing_info_[NIGORI] = GROUP_PASSIVE;
 
     workers_.clear();
     workers_.push_back(make_scoped_refptr(new FakeModelWorker(GROUP_UI)));
     workers_.push_back(make_scoped_refptr(new FakeModelWorker(GROUP_DB)));
     workers_.push_back(make_scoped_refptr(new FakeModelWorker(GROUP_PASSIVE)));
 
     connection_.reset(new MockConnectionManager(directory(),
                                                 &cancelation_signal_));
@@ skipping 11 matching lines @@
             false,  // force enable pre-commit GU avoidance
             "fake_invalidator_client_id"));
     context_->SetRoutingInfo(routing_info_);
     context_->set_notifications_enabled(true);
     context_->set_account_name("Test");
     scheduler_.reset(
         new SyncSchedulerImpl("TestSyncScheduler",
             BackoffDelayProvider::FromDefaults(),
             context(),
             syncer_));
+    scheduler_->SetDefaultNudgeDelay(default_delay().InMilliseconds());
+    std::map<ModelType, int> delay_map;
+    // Override the bookmarks value since so many tests rely on it.
+    delay_map[BOOKMARKS] = default_delay().InMilliseconds();
+    scheduler_->OnReceivedCustomNudgeDelays(delay_map);
   }
 
   SyncSchedulerImpl* scheduler() { return scheduler_.get(); }
   const ModelSafeRoutingInfo& routing_info() { return routing_info_; }
   MockSyncer* syncer() { return syncer_; }
   MockDelayProvider* delay() { return delay_; }
   MockConnectionManager* connection() { return connection_.get(); }
-  TimeDelta zero() { return TimeDelta::FromSeconds(0); }
+  TimeDelta default_delay() { return TimeDelta::FromSeconds(0); }
   TimeDelta timeout() {
     return TestTimeouts::action_timeout();
   }
 
   virtual void TearDown() {
     PumpLoop();
     scheduler_.reset();
     PumpLoop();
     dir_maker_.TearDown();
   }
@@ skipping 22 matching lines @@
         FROM_HERE,
         base::Bind(&SyncSchedulerTest::DoQuitLoopNow,
                    weak_ptr_factory_.GetWeakPtr()));
     RunLoop();
   }
 
   bool RunAndGetBackoff() {
     ModelTypeSet nudge_types(BOOKMARKS);
     StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-    scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
+    scheduler()->ScheduleLocalNudge(nudge_types, FROM_HERE);
     RunLoop();
 
     return scheduler()->IsBackingOff();
   }
 
   void UseMockDelayProvider() {
     delay_ = new MockDelayProvider();
     scheduler_->delay_provider_.reset(delay_);
   }
 
@@ skipping 77 matching lines @@
   SyncShareTimes times;
   ModelTypeSet model_types(BOOKMARKS);
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(model_types, FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareTimes times2;
   model_types.Remove(BOOKMARKS);
-  model_types.Put(AUTOFILL);
+  model_types.Put(TYPED_URLS);
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(model_types, FROM_HERE);
   RunLoop();
 }
 
 // Make sure a regular config command is scheduled fine in the absence of any
 // errors.
 TEST_F(SyncSchedulerTest, Config) {
   SyncShareTimes times;
   const ModelTypeSet model_types(BOOKMARKS);
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
@@ skipping 119 matching lines @@
   scheduler()->ScheduleConfiguration(params);
   RunLoop();
   ASSERT_EQ(0, ready_counter.times_called());
   ASSERT_EQ(1, retry_counter.times_called());
   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);
+  scheduler()->ScheduleLocalNudge(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).
   Mock::VerifyAndClearExpectations(syncer());
   ASSERT_EQ(0, ready_counter.times_called());
 
   // Let the next configure retry succeed.
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       RecordSyncShare(&times)));
   RunLoop();
 
   // 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);
   PumpLoop();
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   SyncShareTimes times;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)));
-  const ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3(THEMES);
-  TimeDelta delay = zero();
+  const ModelTypeSet types1(BOOKMARKS), types2(TYPED_URLS), types3(THEMES);
+  TimeDelta delay = default_delay();

[rlarocque, 2014/08/20 00:13:31]

Remove |delay|?

[Nicolas Zea, 2014/08/20 22:49:43]

Done.

   TimeTicks optimal_time = TimeTicks::Now() + delay;
-  scheduler()->ScheduleLocalNudge(delay, types1, FROM_HERE);
-  scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types1, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, times.size());
   EXPECT_GE(times[0], optimal_time);
 
   Mock::VerifyAndClearExpectations(syncer());
 
   SyncShareTimes times2;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
-  scheduler()->ScheduleLocalNudge(zero(), types3, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types3, FROM_HERE);
   RunLoop();
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   SyncShareTimes times;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)));
-  ModelTypeSet types1(BOOKMARKS), types2(AUTOFILL), types3;
+  ModelTypeSet types1(BOOKMARKS), types2(TYPED_URLS), types3;
 
   // Create a huge time delay.
   TimeDelta delay = TimeDelta::FromDays(1);
 
-  scheduler()->ScheduleLocalNudge(delay, types1, FROM_HERE);
-  scheduler()->ScheduleLocalNudge(zero(), types2, FROM_HERE);
+  std::map<ModelType, int> delay_map;
+  delay_map[types1.First().Get()] = delay.InMilliseconds();
+  scheduler()->OnReceivedCustomNudgeDelays(delay_map);
+  scheduler()->ScheduleLocalNudge(types1, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types2, FROM_HERE);
 
   TimeTicks min_time = TimeTicks::Now();
   TimeTicks max_time = TimeTicks::Now() + delay;
 
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure the sync happened at the right 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);
 
   SyncShareTimes times1;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times1)))
       .RetiresOnSaturation();
   scheduler()->ScheduleInvalidationNudge(
-      zero(), BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
+      BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareTimes times2;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
   scheduler()->ScheduleInvalidationNudge(
-      zero(), AUTOFILL, BuildInvalidation(10, "test2"), FROM_HERE);
+      TYPED_URLS, BuildInvalidation(10, "test2"), FROM_HERE);
   RunLoop();
 }
 
 // Test that polling works as expected.
 TEST_F(SyncSchedulerTest, Polling) {
   SyncShareTimes times;
   TimeDelta poll_interval(TimeDelta::FromMilliseconds(30));
   EXPECT_CALL(*syncer(), PollSyncShare(_,_)).Times(AtLeast(kMinNumSamples))
       .WillRepeatedly(
           DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
@@ skipping 53 matching lines @@
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(times, kMinNumSamples, optimal_start, poll2);
 }
 
 // Test that the sessions commit delay is updated when needed.
-TEST_F(SyncSchedulerTest, SessionsCommitDelay) {
+TEST_F(SyncSchedulerTest, CustomNudgeDelays) {
   SyncShareTimes times;
   TimeDelta delay1(TimeDelta::FromMilliseconds(120));
   TimeDelta delay2(TimeDelta::FromMilliseconds(30));
-  scheduler()->OnReceivedSessionsCommitDelay(delay1);
+  std::map<ModelType, int> delay_map;
+  delay_map[SESSIONS] = delay1.InMilliseconds();
+  scheduler()->OnReceivedCustomNudgeDelays(delay_map);
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(
           DoAll(
               WithArgs<0,1,2>(
                   sessions::test_util::SimulateSessionsCommitDelayUpdate(
                       delay2)),
               Invoke(sessions::test_util::SimulateNormalSuccess),
               QuitLoopNowAction()));
 
-  EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
+  EXPECT_EQ(delay1, scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
+  EXPECT_EQ(delay1, scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)));
   const ModelTypeSet model_types(BOOKMARKS);
-  scheduler()->ScheduleLocalNudge(zero(), model_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(model_types, FROM_HERE);
   RunLoop();
 
-  EXPECT_EQ(delay2, scheduler()->GetSessionsCommitDelay());
+  EXPECT_EQ(delay2, scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)));
   StopSyncScheduler();
 }
 
 // Test that no syncing occurs when throttled.
 TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
   const ModelTypeSet types(BOOKMARKS);
   TimeDelta poll(TimeDelta::FromMilliseconds(20));
   TimeDelta throttle(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(
           WithArg<2>(sessions::test_util::SimulateThrottled(throttle)),
           Return(true)))
       .WillRepeatedly(AddFailureAndQuitLoopNow());
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleLocalNudge(
-      TimeDelta::FromMicroseconds(1), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
       GetUpdatesCallerInfo::RECONFIGURATION,
       types,
       TypesToRoutingInfo(types),
@@ skipping 44 matching lines @@
       .WillOnce(DoAll(
           WithArg<2>(sessions::test_util::SimulateThrottled(throttle1)),
           Return(true)))
       .RetiresOnSaturation();
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       QuitLoopNowAction()));
 
   const ModelTypeSet types(BOOKMARKS);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
 
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // To get TrySyncSessionJob called
   EXPECT_TRUE(scheduler()->IsCurrentlyThrottled());
   RunLoop();
   EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
 
   StopSyncScheduler();
 }
 
@@ skipping 32 matching lines @@
 
   RunLoop();
   EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
 
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerTest, TypeThrottlingBlocksNudge) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
-      .WillRepeatedly(Return(zero()));
+      .WillRepeatedly(Return(default_delay()));
 
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   const ModelTypeSet types(BOOKMARKS);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(
           WithArg<2>(
               sessions::test_util::SimulateTypesThrottled(types, throttle1)),
           Return(true)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // To get TrySyncSessionJob called
   EXPECT_TRUE(GetThrottledTypes().HasAll(types));
 
   // This won't cause a sync cycle because the types are throttled.
-  scheduler()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();
 
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
-      .WillRepeatedly(Return(zero()));
+      .WillRepeatedly(Return(default_delay()));
 
   SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   const ModelTypeSet throttled_types(BOOKMARKS);
   const ModelTypeSet unthrottled_types(PREFERENCES);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(
           WithArg<2>(
               sessions::test_util::SimulateTypesThrottled(
                   throttled_types, throttle1)),
           Return(true)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  scheduler()->ScheduleLocalNudge(zero(), throttled_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(throttled_types, FROM_HERE);
   PumpLoop(); // To get PerformDelayedNudge called.
   PumpLoop(); // To get TrySyncSessionJob called
   EXPECT_TRUE(GetThrottledTypes().HasAll(throttled_types));
 
   // Ignore invalidations for throttled types.
   scheduler()->ScheduleInvalidationNudge(
-      zero(), BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
+      BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
   PumpLoop();
 
   // Ignore refresh requests for throttled types.
-  scheduler()->ScheduleLocalRefreshRequest(zero(), throttled_types, FROM_HERE);
+  scheduler()->ScheduleLocalRefreshRequest(throttled_types, FROM_HERE);
   PumpLoop();
 
   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);
+  scheduler()->ScheduleLocalNudge(unthrottled_types, FROM_HERE);
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
 
   StopSyncScheduler();
 }
 
 // Test nudges / polls don't run in config mode and config tasks do.
 TEST_F(SyncSchedulerTest, ConfigurationMode) {
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   SyncShareTimes times;
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
-  const ModelTypeSet nudge_types(AUTOFILL);
-  scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
-  scheduler()->ScheduleLocalNudge(zero(), nudge_types, FROM_HERE);
+  const ModelTypeSet nudge_types(TYPED_URLS);
+  scheduler()->ScheduleLocalNudge(nudge_types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(nudge_types, FROM_HERE);
 
   const ModelTypeSet config_types(BOOKMARKS);
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       RecordSyncShare(&times)))
       .RetiresOnSaturation();
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
@@ skipping 123 matching lines @@
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       RecordSyncShareMultiple(&times, 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()->ScheduleLocalNudge(zero(), types, FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   RunLoop();
 
   // From this point forward, no SyncShare functions should be invoked.
   Mock::VerifyAndClearExpectations(syncer());
 
   // 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()->ScheduleLocalNudge(
-      base::TimeDelta::FromMilliseconds(10),
-      types,
-      FROM_HERE);
+  scheduler()->ScheduleLocalNudge(types, FROM_HERE);
 
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
 
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
@@ skipping 32 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()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(BOOKMARKS), FROM_HERE);
   RunLoop();
 
   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) {
   SyncShareTimes times;
   const TimeDelta poll(TimeDelta::FromMilliseconds(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   const TimeDelta backoff = TimeDelta::FromMilliseconds(10);
   EXPECT_CALL(*delay(), GetDelay(_)).WillOnce(Return(backoff));
 
   // Optimal start for the post-backoff poll party.
   TimeTicks optimal_start = TimeTicks::Now();
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   // 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);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(BOOKMARKS), FROM_HERE);
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
   TimeTicks optimal_job_time = optimal_start;
   ASSERT_EQ(1U, times.size());
   EXPECT_GE(times[0], optimal_job_time);
 
   // The retry succeeds.
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(
               Invoke(sessions::test_util::SimulateNormalSuccess),
@@ skipping 51 matching lines @@
 TEST_F(SyncSchedulerTest, StartWhenNotConnected) {
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConnectionFailure),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                     Return(true)));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(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(), NormalSyncShare(_,_,_))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConnectionFailure),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                     Return(true)));
 
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(BOOKMARKS), FROM_HERE);
   PumpLoop(); // To get PerformDelayedNudge called.
   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(), NormalSyncShare(_,_,_))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConnectionFailure),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                     Return(true)))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                     QuitLoopNowAction()));
 
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(BOOKMARKS), FROM_HERE);
 
   PumpLoop(); // To get PerformDelayedNudge called.
   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();
   PumpLoop();
   connection()->SetServerReachable();
   connection()->UpdateConnectionStatus();
-  scheduler()->ScheduleLocalNudge(zero(), ModelTypeSet(BOOKMARKS), FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(BOOKMARKS), FROM_HERE);
   base::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(), ConfigureSyncShare(_,_,_))
       .WillRepeatedly(DoAll(
               Invoke(sessions::test_util::SimulateConfigureConnectionFailure),
               Return(true)));
@@ skipping 100 matching lines @@
   EXPECT_EQ(expected_delay, scheduler_test->GetRetryTimerDelay());
 }
 
 TEST_F(SyncSchedulerTest, ReceiveNewRetryDelay) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   SyncShareTimes times;
   base::TimeDelta delay1 = base::TimeDelta::FromMilliseconds(100);
   base::TimeDelta delay2 = base::TimeDelta::FromMilliseconds(200);
 
-  scheduler()->ScheduleLocalRefreshRequest(zero(), ModelTypeSet(BOOKMARKS),
-                                           FROM_HERE);
+  scheduler()->ScheduleLocalNudge(ModelTypeSet(BOOKMARKS), FROM_HERE);
   scheduler()->OnReceivedGuRetryDelay(delay1);
   EXPECT_EQ(delay1, GetRetryTimerDelay());
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(
           WithoutArgs(VerifyRetryTimerDelay(this, delay1)),
           WithArg<2>(sessions::test_util::SimulateGuRetryDelayCommand(delay2)),
           RecordSyncShare(&times)));
 
   // Run nudge GU.
   RunLoop();
   EXPECT_EQ(delay2, GetRetryTimerDelay());
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)));
 
   // Run to wait for retrying.
   RunLoop();
 
   StopSyncScheduler();
 }
 
+// Test the default nudge delays for various types, and that we can overwrite
+// them with custom delays.
+TEST_F(SyncSchedulerTest, NudgeDelayTest) {
+  // Reset all delays to default
+  std::map<ModelType, int> delay_map;
+  ModelTypeSet protocol_types = syncer::ProtocolTypes();
+  for (ModelTypeSet::Iterator iter = protocol_types.First(); iter.Good();
+       iter.Inc()) {
+    delay_map[iter.Get()] = -1;
+  }
+  scheduler()->OnReceivedCustomNudgeDelays(delay_map);
+
+  // Bookmarks and preference both have "slow nudge" delays.
+  EXPECT_EQ(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(BOOKMARKS)),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(PREFERENCES)));
+
+  // Typed URLs has a default delay.
+  EXPECT_EQ(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(TYPED_URLS)),
+            default_delay());
+
+  // "Slow nudge" delays are longer than the default.
+  EXPECT_GT(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(BOOKMARKS)),
+            default_delay());
+
+  // Sessions is longer than "slow nudge".
+  EXPECT_GT(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(BOOKMARKS)));
+
+  // Favicons have the same delay as sessions.
+  EXPECT_EQ(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(FAVICON_TRACKING)));
+
+  // Autofill has the longer delay of all.
+  EXPECT_GT(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(AUTOFILL)),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)));
+
+  // A nudge with no types takes the longest delay.
+  EXPECT_GT(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(AUTOFILL)),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet()));
+
+  // The actual nudge delay should be the shortest of the set.
+  EXPECT_EQ(
+      scheduler()->GetNudgeDelayForTypes(ModelTypeSet(TYPED_URLS)),
+      scheduler()->GetNudgeDelayForTypes(ModelTypeSet(TYPED_URLS, AUTOFILL)));
+
+  // Set some custom delays.
+  delay_map[BOOKMARKS] = 10000;
+  delay_map[SESSIONS] = 2000;
+  scheduler()->OnReceivedCustomNudgeDelays(delay_map);
+
+  // Only those with custom delays should be affected, not another type.
+  EXPECT_NE(scheduler()->GetNudgeDelayForTypes(ModelTypeSet(BOOKMARKS)),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(PREFERENCES)));
+
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(10000),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(BOOKMARKS)));
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(2000),
+            scheduler()->GetNudgeDelayForTypes(ModelTypeSet(SESSIONS)));
+}
+
 }  // namespace syncer