[Sync] Remove unnecessary posting of methods in sync scheduler.

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 132 matching lines @@
       EXPECT_EQ(GetUpdatesCallerInfo::PERIODIC,
                 records.snapshots[i].source().updates_source);
     }
   }
 
   void DoQuitLoopNow() {
     QuitLoopNow();
   }
 
   void StartSyncScheduler(SyncScheduler::Mode mode) {
-    scheduler()->Start(
-        mode,
-        base::Bind(&SyncSchedulerTest::DoQuitLoopNow,
-                   weak_ptr_factory_.GetWeakPtr()));
+    scheduler()->Start(mode, base::Closure());
   }
 
   // This stops the scheduler synchronously.
   void StopSyncScheduler() {
     scheduler()->RequestStop(base::Bind(&SyncSchedulerTest::DoQuitLoopNow,
                              weak_ptr_factory_.GetWeakPtr()));
     RunLoop();
   }
 
   bool RunAndGetBackoff() {
     ModelTypeSet nudge_types;
     StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-    RunLoop();
 
-    scheduler()->ScheduleNudge(
+    scheduler()->ScheduleNudgeAsync(
         zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
     RunLoop();
 
     return scheduler()->IsBackingOff();
   }
 
   void UseMockDelayProvider() {
     delay_ = new MockDelayProvider();
     scheduler_->delay_provider_.reset(delay_);
   }
@@ skipping 26 matching lines @@
   TestDirectorySetterUpper dir_maker_;
   scoped_ptr<MockConnectionManager> connection_;
   scoped_ptr<SyncSessionContext> context_;
   scoped_ptr<SyncScheduler> scheduler_;
   MockSyncer* syncer_;
   MockDelayProvider* delay_;
   std::vector<scoped_refptr<FakeModelWorker> > workers_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
 };
 
-class BackoffTriggersSyncSchedulerTest : public SyncSchedulerTest {
-  void SetUp() {
-    SyncSchedulerTest::SetUp();
-    UseMockDelayProvider();
-    EXPECT_CALL(*delay(), GetDelay(_))
-        .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
-  }
-
-  void TearDown() {
-    StopSyncScheduler();
-    SyncSchedulerTest::TearDown();
-  }
-};
-
 void RecordSyncShareImpl(SyncSession* s, SyncShareRecords* record) {
   record->times.push_back(TimeTicks::Now());
   record->snapshots.push_back(s->TakeSnapshot());
 }
 
 ACTION_P(RecordSyncShare, record) {
   RecordSyncShareImpl(arg0, record);
-  QuitLoopNow();
+  if (MessageLoop::current()->is_running())
+    QuitLoopNow();
 }
 
 ACTION_P2(RecordSyncShareMultiple, record, quit_after) {
   RecordSyncShareImpl(arg0, record);
   EXPECT_LE(record->times.size(), quit_after);
-  if (record->times.size() >= quit_after) {
+  if (record->times.size() >= quit_after &&
+      MessageLoop::current()->is_running()) {
     QuitLoopNow();
   }
 }
 
 ACTION(AddFailureAndQuitLoopNow) {
   ADD_FAILURE();
   QuitLoopNow();
 }
 
 ACTION(QuitLoopNowAction) {
   QuitLoopNow();
 }
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, Nudge) {
   SyncShareRecords records;
   ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(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(syncable::BOOKMARKS);
   model_types.Put(syncable::AUTOFILL);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(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(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
-  RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(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;
   const ModelTypeSet model_types(syncable::BOOKMARKS);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
-  RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[1].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[1].source().updates_source);
 }
@@ skipping 11 matching lines @@
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       model_types1, GetUpdatesCallerInfo::RECONFIGURATION);
-  RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       model_types2, GetUpdatesCallerInfo::RECONFIGURATION);
+
+  // A canary job gets posted when we go into exponential backoff.
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
   ASSERT_EQ(3U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types2,
       records.snapshots[2].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[2].source().updates_source);
@@ skipping 12 matching lines @@
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
   ASSERT_EQ(0U, records.snapshots.size());
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       model_types, GetUpdatesCallerInfo::RECONFIGURATION);
-  RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(2U, records.snapshots.size());
   RunLoop();
 
   // Now change the mode so nudge can execute.
   ASSERT_EQ(3U, records.snapshots.size());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   ASSERT_EQ(4U, records.snapshots.size());
 
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(model_types,
       records.snapshots[2].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[2].source().updates_source);
 
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(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);
-  RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   const ModelTypeSet
       types1(syncable::BOOKMARKS),
       types2(syncable::AUTOFILL),
       types3(syncable::THEMES);
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(
       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()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(types3,
       r2.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
             r2.snapshots[0].source().updates_source);
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   syncable::ModelTypeSet types1(syncable::BOOKMARKS),
       types2(syncable::AUTOFILL), types3;
 
   // Create a huge time delay.
   TimeDelta delay = TimeDelta::FromDays(1);
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_UNKNOWN, 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(CompareModelTypeSetToModelTypePayloadMap(
       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, NudgeWithPayloads) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   SyncShareRecords records;
   syncable::ModelTypePayloadMap model_types_with_payloads;
   model_types_with_payloads[syncable::BOOKMARKS] = "test";
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
-  scheduler()->ScheduleNudgeWithPayloads(
+  scheduler()->ScheduleNudgeWithPayloadsAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types_with_payloads, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_EQ(model_types_with_payloads, 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_with_payloads.erase(syncable::BOOKMARKS);
   model_types_with_payloads[syncable::AUTOFILL] = "test2";
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
-  scheduler()->ScheduleNudgeWithPayloads(
+  scheduler()->ScheduleNudgeWithPayloadsAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types_with_payloads, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
   EXPECT_EQ(model_types_with_payloads, records2.snapshots[0].source().types);
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records2.snapshots[0].source().updates_source);
 }
 
 // Test that nudges are coalesced.
 TEST_F(SyncSchedulerTest, NudgeWithPayloadsCoalescing) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   SyncShareRecords r;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
   syncable::ModelTypePayloadMap types1, types2, types3;
   types1[syncable::BOOKMARKS] = "test1";
   types2[syncable::AUTOFILL] = "test2";
   types3[syncable::THEMES] = "test3";
   TimeDelta delay = zero();
   TimeTicks optimal_time = TimeTicks::Now() + delay;
-  scheduler()->ScheduleNudgeWithPayloads(
+  scheduler()->ScheduleNudgeWithPayloadsAsync(
       delay, NUDGE_SOURCE_UNKNOWN, types1, FROM_HERE);
-  scheduler()->ScheduleNudgeWithPayloads(
+  scheduler()->ScheduleNudgeWithPayloadsAsync(
       zero(), NUDGE_SOURCE_LOCAL, types2, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
   syncable::ModelTypePayloadMap coalesced_types;
   syncable::CoalescePayloads(&coalesced_types, types1);
   syncable::CoalescePayloads(&coalesced_types, types2);
   EXPECT_EQ(coalesced_types, 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()->ScheduleNudgeWithPayloads(
+  scheduler()->ScheduleNudgeWithPayloadsAsync(
       zero(), NUDGE_SOURCE_NOTIFICATION, types3, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
   EXPECT_EQ(types3, 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);
 
   TimeTicks optimal_start = TimeTicks::Now() + poll_interval;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(records, kMinNumSamples, optimal_start, poll_interval);
 }
 
 // Test that the short poll interval is used.
 TEST_F(SyncSchedulerTest, PollNotificationsDisabled) {
   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()->OnReceivedShortPollIntervalUpdate(poll_interval);
   scheduler()->set_notifications_enabled(false);
 
   TimeTicks optimal_start = TimeTicks::Now() + poll_interval;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(records, kMinNumSamples, optimal_start, poll_interval);
 }
 
 // Test that polling intervals are updated when needed.
 TEST_F(SyncSchedulerTest, PollIntervalUpdate) {
   SyncShareRecords records;
   TimeDelta poll1(TimeDelta::FromMilliseconds(120));
   TimeDelta poll2(TimeDelta::FromMilliseconds(30));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll1);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(AtLeast(kMinNumSamples))
       .WillOnce(WithArg<0>(
           sessions::test_util::SimulatePollIntervalUpdate(poll2)))
       .WillRepeatedly(
           DoAll(Invoke(sessions::test_util::SimulateSuccess),
                 WithArg<0>(
                     RecordSyncShareMultiple(&records, kMinNumSamples))));
 
   TimeTicks optimal_start = TimeTicks::Now() + poll1 + poll2;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(records, kMinNumSamples, optimal_start, poll2);
 }
 
 // Test that the sessions commit delay is updated when needed.
 TEST_F(SyncSchedulerTest, SessionsCommitDelay) {
   SyncShareRecords records;
   TimeDelta delay1(TimeDelta::FromMilliseconds(120));
   TimeDelta delay2(TimeDelta::FromMilliseconds(30));
   scheduler()->OnReceivedSessionsCommitDelay(delay1);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(
           DoAll(
               WithArg<0>(
                   sessions::test_util::SimulateSessionsCommitDelayUpdate(
                       delay2)),
               Invoke(sessions::test_util::SimulateSuccess),
               QuitLoopNowAction()));
 
   EXPECT_EQ(delay1, scheduler()->sessions_commit_delay());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   EXPECT_EQ(delay1, scheduler()->sessions_commit_delay());
   const ModelTypeSet model_types(syncable::BOOKMARKS);
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
   EXPECT_EQ(delay2, scheduler()->sessions_commit_delay());
   StopSyncScheduler();
 }
 
 // Test that a sync session is run through to completion.
 TEST_F(SyncSchedulerTest, HasMoreToSync) {
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(Invoke(sessions::test_util::SimulateHasMoreToSync))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       QuitLoopNowAction()));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   RunLoop();
   // If more nudges are scheduled, they'll be waited on by TearDown, and would
   // cause our expectation to break.
 }
 
 // Test that continuations can go into backoff.
 TEST_F(SyncSchedulerTest, HasMoreToSyncThenFails) {
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
     .WillOnce(Invoke(sessions::test_util::SimulateHasMoreToSync))
     .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                     QuitLoopNowAction()));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
 
   // We should detect the failure on the second sync share, and go into backoff.
   EXPECT_TRUE(RunAndGetBackoff());
 }
 
 // Test that no syncing occurs when throttled.
 TEST_F(SyncSchedulerTest, ThrottlingDoesThrottle) {
   const ModelTypeSet types(syncable::BOOKMARKS);
   TimeDelta poll(TimeDelta::FromMilliseconds(5));
   TimeDelta throttle(TimeDelta::FromMinutes(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(WithArg<0>(sessions::test_util::SimulateThrottled(throttle)))
       .WillRepeatedly(AddFailureAndQuitLoopNow());
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   PumpLoop();
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       types, GetUpdatesCallerInfo::RECONFIGURATION);
-  PumpLoop();
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpires) {
   SyncShareRecords records;
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   TimeDelta throttle1(TimeDelta::FromMilliseconds(150));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(WithArg<0>(sessions::test_util::SimulateThrottled(throttle1)))
       .RetiresOnSaturation();
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
            WithArg<0>(RecordSyncShareMultiple(&records, kMinNumSamples))));
 
   TimeTicks optimal_start = TimeTicks::Now() + poll + throttle1;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(records, kMinNumSamples, optimal_start, poll);
 }
 
 // Test nudges / polls don't run in config mode and config tasks do.
 TEST_F(SyncSchedulerTest, ConfigurationMode) {
   TimeDelta poll(TimeDelta::FromMilliseconds(15));
   SyncShareRecords records;
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
-      .WillOnce((Invoke(sessions::test_util::SimulateSuccess),
-           WithArg<0>(RecordSyncShare(&records))));
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
+                      WithArg<0>(RecordSyncShare(&records))));
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
   const ModelTypeSet nudge_types(syncable::AUTOFILL);
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, nudge_types, FROM_HERE);
 
   const ModelTypeSet config_types(syncable::BOOKMARKS);
 
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       config_types, GetUpdatesCallerInfo::RECONFIGURATION);
-  RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
   EXPECT_TRUE(CompareModelTypeSetToModelTypePayloadMap(config_types,
       records.snapshots[0].source().types));
 }
 
+class BackoffTriggersSyncSchedulerTest : public SyncSchedulerTest {
+  void SetUp() {
+    SyncSchedulerTest::SetUp();
+    UseMockDelayProvider();
+    EXPECT_CALL(*delay(), GetDelay(_))
+        .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
+  }
+
+  void TearDown() {
+    StopSyncScheduler();
+    SyncSchedulerTest::TearDown();
+  }
+};
+
 // Have the sycner fail during commit.  Expect that the scheduler enters
 // backoff.
 TEST_F(BackoffTriggersSyncSchedulerTest, FailCommitOnce) {
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       QuitLoopNowAction()));
   EXPECT_TRUE(RunAndGetBackoff());
 }
 
 // Have the syncer fail during download updates and succeed on the first
@@ skipping 35 matching lines @@
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(1)
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                             RecordSyncShareMultiple(&r, 1U)));
   EXPECT_CALL(*delay(), GetDelay(_)).
       WillRepeatedly(Return(TimeDelta::FromDays(1)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // This nudge should fail and put us into backoff.  Thanks to our mock
   // GetDelay() setup above, this will be a long backoff.
-  scheduler()->ScheduleNudge(zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
+  scheduler()->ScheduleNudgeAsync(zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             r.snapshots[0].source().updates_source);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(1)
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       RecordSyncShare(&r)));
 
   // We schedule a nudge with enough delay (10X poll interval) that at least
   // one or two polls would have taken place.  The nudge should succeed.
-  scheduler()->ScheduleNudge(poll * 10, NUDGE_SOURCE_LOCAL, types, FROM_HERE);
+  scheduler()->ScheduleNudgeAsync(
+      poll * 10, NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
   ASSERT_EQ(2U, r.snapshots.size());
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             r.snapshots[1].source().updates_source);
 
   // Cleanup is not affected by backoff, but it should not relieve it either.
   EXPECT_CALL(*syncer(),
               SyncShare(_, CLEANUP_DISABLED_TYPES, CLEANUP_DISABLED_TYPES))
       .WillOnce(Invoke(sessions::test_util::SimulateSuccess));
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleCleanupDisabledTypes();
-  scheduler()->ScheduleConfig(
+  scheduler()->CleanupDisabledTypes();
+  scheduler()->ScheduleConfiguration(
       types, GetUpdatesCallerInfo::RECONFIGURATION);
-  PumpLoop();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, types, FROM_HERE);
   PumpLoop();
 }
 
 // Test that backoff is shaping traffic properly with consecutive errors.
 TEST_F(SyncSchedulerTest, BackoffElevation) {
   SyncShareRecords r;
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(kMinNumSamples)
@@ skipping 11 matching lines @@
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(Eq(second))).WillOnce(Return(third))
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(Eq(third))).WillOnce(Return(fourth))
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(Eq(fourth))).WillOnce(Return(fifth))
           .RetiresOnSaturation();
   EXPECT_CALL(*delay(), GetDelay(Eq(fifth))).WillOnce(Return(sixth));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // Run again with a nudge.
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), 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.
 TEST_F(SyncSchedulerTest, BackoffRelief) {
   SyncShareRecords r;
   const TimeDelta poll(TimeDelta::FromMilliseconds(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   const TimeDelta backoff = TimeDelta::FromMilliseconds(5);
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       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);
-  RunLoop();
 
   // Run again to wait for polling.
-  scheduler()->ScheduleNudge(zero(), NUDGE_SOURCE_LOCAL,
-                             ModelTypeSet(), FROM_HERE);
+  scheduler()->ScheduleNudgeAsync(zero(), NUDGE_SOURCE_LOCAL,
+                                  ModelTypeSet(), 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 22 matching lines @@
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
   UseMockDelayProvider(); // Will cause test failure if backoff is initiated.
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       RecordSyncShare(&r)))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       RecordSyncShare(&r)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  // Run the unsucessful poll.  The failed poll should not trigger backoff.
+  // Run the unsucessful poll. The failed poll should not trigger backoff.
   RunLoop();
   EXPECT_FALSE(scheduler()->IsBackingOff());
 
   // Run the successful poll.
   RunLoop();
   EXPECT_FALSE(scheduler()->IsBackingOff());
 }
 
 TEST_F(SyncSchedulerTest, GetRecommendedDelay) {
   EXPECT_LE(TimeDelta::FromSeconds(0),
@@ skipping 11 matching lines @@
             SyncScheduler::GetRecommendedDelay(
                 TimeDelta::FromSeconds(kMaxBackoffSeconds + 1)));
 }
 
 // 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(Invoke(sessions::test_util::SimulateSuccess));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // ClearUserData.
   EXPECT_CALL(*syncer(), SyncShare(_, CLEAR_PRIVATE_DATA, CLEAR_PRIVATE_DATA))
       .WillOnce(Invoke(sessions::test_util::SimulateSuccess));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleClearUserData();
-  PumpLoop();
-  PumpLoop();
+  scheduler()->ClearUserData();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Configuration.
   EXPECT_CALL(*syncer(), SyncShare(_, DOWNLOAD_UPDATES, APPLY_UPDATES))
       .WillOnce(Invoke(sessions::test_util::SimulateSuccess));
   StartSyncScheduler(SyncScheduler::CONFIGURATION_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleConfig(
+  scheduler()->ScheduleConfiguration(
       ModelTypeSet(), GetUpdatesCallerInfo::RECONFIGURATION);
-  PumpLoop();
-  PumpLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Cleanup disabled types.
   EXPECT_CALL(*syncer(),
               SyncShare(_, CLEANUP_DISABLED_TYPES, CLEANUP_DISABLED_TYPES))
       .WillOnce(Invoke(sessions::test_util::SimulateSuccess));
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleCleanupDisabledTypes();
-  // Only need to pump once, as ScheduleCleanupDisabledTypes()
-  // schedules the job directly.
-  PumpLoop();
+  scheduler()->CleanupDisabledTypes();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 
   // Poll.
   EXPECT_CALL(*syncer(), SyncShare(_, SYNCER_BEGIN, SYNCER_END))
       .Times(AtLeast(1))
       .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                             QuitLoopNowAction()));
   const TimeDelta poll(TimeDelta::FromMilliseconds(10));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   Mock::VerifyAndClearExpectations(syncer());
 }
 
 // Test config tasks don't run during normal mode.
 // TODO(tim): Implement this test and then the functionality!
 TEST_F(SyncSchedulerTest, DISABLED_NoConfigDuringNormal) {
 }
 
 // Test that starting the syncer thread without a valid connection doesn't
 // break things when a connection is detected.
 TEST_F(SyncSchedulerTest, StartWhenNotConnected) {
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
     .WillOnce(Invoke(sessions::test_util::SimulateConnectionFailure))
     .WillOnce(QuitLoopNowAction());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  MessageLoop::current()->RunAllPending();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   // Should save the nudge for until after the server is reachable.
   MessageLoop::current()->RunAllPending();
 
   connection()->SetServerReachable();
   connection()->UpdateConnectionStatus();
   scheduler()->OnConnectionStatusChange();
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(SyncSchedulerTest, SetsPreviousRoutingInfo) {
   ModelSafeRoutingInfo info;
   EXPECT_TRUE(info == context()->previous_session_routing_info());
   ModelSafeRoutingInfo expected(context()->routing_info());
   ASSERT_FALSE(expected.empty());
   EXPECT_CALL(*syncer(), SyncShare(_,_,_)).Times(1);
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
-  RunLoop();
 
-  scheduler()->ScheduleNudge(
+  scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, ModelTypeSet(), FROM_HERE);
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
 
   EXPECT_TRUE(expected == context()->previous_session_routing_info());
 }
 
 }  // namespace browser_sync