[Sync] Move //sync to //components/sync.

components/sync/engine_impl/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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "sync/engine/backoff_delay_provider.h"
-#include "sync/engine/sync_scheduler_impl.h"
-#include "sync/engine/syncer.h"
-#include "sync/internal_api/public/base/cancelation_signal.h"
-#include "sync/internal_api/public/base/model_type_test_util.h"
-#include "sync/sessions/test_util.h"
-#include "sync/test/callback_counter.h"
-#include "sync/test/engine/fake_model_worker.h"
-#include "sync/test/engine/mock_connection_manager.h"
-#include "sync/test/engine/mock_nudge_handler.h"
-#include "sync/test/engine/test_directory_setter_upper.h"
-#include "sync/test/mock_invalidation.h"
-#include "sync/util/extensions_activity.h"
+#include "components/sync/base/cancelation_signal.h"
+#include "components/sync/base/extensions_activity.h"
+#include "components/sync/base/model_type_test_util.h"
+#include "components/sync/engine_impl/backoff_delay_provider.h"
+#include "components/sync/engine_impl/sync_scheduler_impl.h"
+#include "components/sync/engine_impl/syncer.h"
+#include "components/sync/sessions_impl/test_util.h"
+#include "components/sync/test/callback_counter.h"
+#include "components/sync/test/engine/fake_model_worker.h"
+#include "components/sync/test/engine/mock_connection_manager.h"
+#include "components/sync/test/engine/mock_nudge_handler.h"
+#include "components/sync/test/engine/test_directory_setter_upper.h"
+#include "components/sync/test/mock_invalidation.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using testing::_;
 using testing::AtLeast;
 using testing::DoAll;
 using testing::Invoke;
 using testing::Mock;
@@ skipping 14 matching lines @@
                bool(ModelTypeSet,
                     sessions::NudgeTracker*,
                     sessions::SyncSession*));
   MOCK_METHOD3(ConfigureSyncShare,
                bool(ModelTypeSet,
                     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource,
                     SyncSession*));
   MOCK_METHOD2(PollSyncShare, bool(ModelTypeSet, sessions::SyncSession*));
 };
 
-MockSyncer::MockSyncer()
-  : Syncer(NULL) {}
+MockSyncer::MockSyncer() : Syncer(NULL) {}
 
 typedef std::vector<TimeTicks> SyncShareTimes;
 
 void QuitLoopNow() {
   // We use QuitNow() instead of Quit() as the latter may get stalled
   // indefinitely in the presence of repeated timers with low delays
   // and a slow test (e.g., ThrottlingDoesThrottle [which has a poll
   // delay of 5ms] run under TSAN on the trybots).
   base::MessageLoop::current()->QuitNow();
 }
@@ skipping 19 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;
 }
 
-
 static const size_t kMinNumSamples = 5;
 
 // Test harness for the SyncScheduler.  Test the delays and backoff timers used
 // in response to various events.
 //
 // These tests execute in real time with real timers.  We try to keep the
 // delays short, but there is a limit to how short we can make them.  The
 // timers on some platforms (ie. Windows) have a timer resolution greater than
 // 1ms.  Using 1ms delays may result in test flakiness.
 //
 // See crbug.com/402212 for more info.
 class SyncSchedulerTest : public testing::Test {
  public:
   SyncSchedulerTest() : syncer_(NULL), delay_(NULL), weak_ptr_factory_(this) {}
 
   class MockDelayProvider : public BackoffDelayProvider {
    public:
-    MockDelayProvider() : BackoffDelayProvider(
-        TimeDelta::FromSeconds(kInitialBackoffRetrySeconds),
-        TimeDelta::FromSeconds(kInitialBackoffImmediateRetrySeconds)) {
-    }
+    MockDelayProvider()
+        : BackoffDelayProvider(
+              TimeDelta::FromSeconds(kInitialBackoffRetrySeconds),
+              TimeDelta::FromSeconds(kInitialBackoffImmediateRetrySeconds)) {}
 
     MOCK_METHOD1(GetDelay, TimeDelta(const TimeDelta&));
   };
 
   void SetUp() override {
     dir_maker_.SetUp();
     syncer_ = new testing::StrictMock<MockSyncer>();
     delay_ = NULL;
     extensions_activity_ = new ExtensionsActivity();
 
     routing_info_[THEMES] = GROUP_UI;
     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_));
+    connection_.reset(
+        new MockConnectionManager(directory(), &cancelation_signal_));
     connection_->SetServerReachable();
 
     model_type_registry_.reset(
         new ModelTypeRegistry(workers_, directory(), &mock_nudge_handler_));
 
     context_.reset(new SyncSessionContext(
-            connection_.get(), directory(),
-            extensions_activity_.get(),
-            std::vector<SyncEngineEventListener*>(), NULL,
-            model_type_registry_.get(),
-            true,  // enable keystore encryption
-            false,  // force enable pre-commit GU avoidance
-            "fake_invalidator_client_id"));
+        connection_.get(), directory(), extensions_activity_.get(),
+        std::vector<SyncEngineEventListener*>(), NULL,
+        model_type_registry_.get(),
+        true,   // enable keystore encryption
+        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_.reset(new SyncSchedulerImpl("TestSyncScheduler",
+                                           BackoffDelayProvider::FromDefaults(),
+                                           context(), syncer_));
     scheduler_->SetDefaultNudgeDelay(default_delay());
   }
 
   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 default_delay() { return TimeDelta::FromSeconds(0); }
-  TimeDelta timeout() {
-    return TestTimeouts::action_timeout();
-  }
+  TimeDelta timeout() { return TestTimeouts::action_timeout(); }
 
   void TearDown() override {
     PumpLoop();
     scheduler_.reset();
     PumpLoop();
     dir_maker_.TearDown();
   }
 
-  void AnalyzePollRun(const SyncShareTimes& times, size_t min_num_samples,
-      const TimeTicks& optimal_start, const TimeDelta& poll_interval) {
+  void AnalyzePollRun(const SyncShareTimes& times,
+                      size_t min_num_samples,
+                      const TimeTicks& optimal_start,
+                      const TimeDelta& poll_interval) {
     EXPECT_GE(times.size(), min_num_samples);
     for (size_t i = 0; i < times.size(); i++) {
       SCOPED_TRACE(testing::Message() << "SyncShare # (" << i << ")");
       TimeTicks optimal_next_sync = optimal_start + poll_interval * i;
       EXPECT_GE(times[i], optimal_next_sync);
     }
   }
 
-  void DoQuitLoopNow() {
-    QuitLoopNow();
-  }
+  void DoQuitLoopNow() { QuitLoopNow(); }
 
   void StartSyncConfiguration() {
     scheduler()->Start(SyncScheduler::CONFIGURATION_MODE, base::Time());
   }
 
   void StartSyncScheduler(base::Time last_poll_time) {
     scheduler()->Start(SyncScheduler::NORMAL_MODE, last_poll_time);
   }
 
   // This stops the scheduler synchronously.
@@ skipping 30 matching lines @@
     return scheduler_->retry_timer_.GetCurrentDelay();
   }
 
   static std::unique_ptr<InvalidationInterface> BuildInvalidation(
       int64_t version,
       const std::string& payload) {
     return MockInvalidation::Build(version, payload);
   }
 
  private:
-  syncable::Directory* directory() {
-    return dir_maker_.directory();
-  }
+  syncable::Directory* directory() { return dir_maker_.directory(); }
 
   base::MessageLoop loop_;
   TestDirectorySetterUpper dir_maker_;
   CancelationSignal cancelation_signal_;
   std::unique_ptr<MockConnectionManager> connection_;
   std::unique_ptr<ModelTypeRegistry> model_type_registry_;
   std::unique_ptr<SyncSessionContext> context_;
   std::unique_ptr<SyncSchedulerImpl> scheduler_;
   MockNudgeHandler mock_nudge_handler_;
   MockSyncer* syncer_;
   MockDelayProvider* delay_;
-  std::vector<scoped_refptr<ModelSafeWorker> > workers_;
+  std::vector<scoped_refptr<ModelSafeWorker>> workers_;
   scoped_refptr<ExtensionsActivity> extensions_activity_;
   ModelSafeRoutingInfo routing_info_;
   base::WeakPtrFactory<SyncSchedulerTest> weak_ptr_factory_;
 };
 
 void RecordSyncShareImpl(SyncShareTimes* times) {
   times->push_back(TimeTicks::Now());
 }
 
 ACTION_P2(RecordSyncShare, times, success) {
@@ skipping 64 matching lines @@
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       RecordSyncShare(&times, true)));
 
   StartSyncConfiguration();
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      model_types,
+      GetUpdatesCallerInfo::RECONFIGURATION, model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   PumpLoop();
   ASSERT_EQ(1, ready_counter.times_called());
   ASSERT_EQ(0, retry_counter.times_called());
 }
 
 // Simulate a failure and make sure the config request is retried.
 TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(20)));
   SyncShareTimes times;
   const ModelTypeSet model_types(THEMES);
 
   StartSyncConfiguration();
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
                       RecordSyncShare(&times, false)))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
                       RecordSyncShare(&times, false)));
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      model_types,
+      GetUpdatesCallerInfo::RECONFIGURATION, model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   RunLoop();
   ASSERT_EQ(0, ready_counter.times_called());
   ASSERT_EQ(1, retry_counter.times_called());
 
   // RunLoop() will trigger TryCanaryJob which will retry configuration.
   // Since retry_task was already called it shouldn't be called again.
@@ skipping 25 matching lines @@
   // Make ConfigureSyncShare call scheduler->Stop(). It is not supposed to call
   // retry_task or dereference configuration params.
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
                       StopScheduler(scheduler()),
                       RecordSyncShare(&times, false)));
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      model_types,
+      GetUpdatesCallerInfo::RECONFIGURATION, model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   PumpLoop();
   ASSERT_EQ(0, ready_counter.times_called());
   ASSERT_EQ(0, retry_counter.times_called());
 }
 
 // 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(THEMES);
   UseMockDelayProvider();
   EXPECT_CALL(*delay(), GetDelay(_))
       .WillRepeatedly(Return(TimeDelta::FromMilliseconds(50)));
   SyncShareTimes times;
 
   StartSyncConfiguration();
 
   // Request a configure and make sure it fails.
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureFailed),
                       RecordSyncShare(&times, false)));
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      model_types,
+      GetUpdatesCallerInfo::RECONFIGURATION, model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   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.
@@ skipping 82 matching lines @@
 
 // Test nudge scheduling.
 TEST_F(SyncSchedulerTest, NudgeWithStates) {
   StartSyncScheduler(base::Time());
 
   SyncShareTimes times1;
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times1, true)))
       .RetiresOnSaturation();
-  scheduler()->ScheduleInvalidationNudge(
-      THEMES, BuildInvalidation(10, "test"), FROM_HERE);
+  scheduler()->ScheduleInvalidationNudge(THEMES, 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, true)));
   scheduler()->ScheduleInvalidationNudge(
@@ skipping 139 matching lines @@
   StartSyncScheduler(base::Time());
 
   scheduler()->ScheduleLocalNudge(types, FROM_HERE);
   PumpLoop();
 
   StartSyncConfiguration();
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      types,
-      TypesToRoutingInfo(types),
+      GetUpdatesCallerInfo::RECONFIGURATION, types, TypesToRoutingInfo(types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   PumpLoop();
   ASSERT_EQ(0, ready_counter.times_called());
   ASSERT_EQ(1, retry_counter.times_called());
 }
 
 TEST_F(SyncSchedulerTest, ThrottlingExpiresFromPoll) {
   SyncShareTimes times;
@@ skipping 66 matching lines @@
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       QuitLoopNowAction(true)));
 
   const ModelTypeSet types(THEMES);
   StartSyncConfiguration();
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      types,
-      TypesToRoutingInfo(types),
+      GetUpdatesCallerInfo::RECONFIGURATION, types, TypesToRoutingInfo(types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   PumpLoop();
   EXPECT_EQ(0, ready_counter.times_called());
   EXPECT_EQ(1, retry_counter.times_called());
   EXPECT_TRUE(scheduler()->IsCurrentlyThrottled());
 
   RunLoop();
   EXPECT_FALSE(scheduler()->IsCurrentlyThrottled());
 
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerTest, TypeThrottlingBlocksNudge) {
   UseMockDelayProvider();
-  EXPECT_CALL(*delay(), GetDelay(_))
-      .WillRepeatedly(Return(default_delay()));
+  EXPECT_CALL(*delay(), GetDelay(_)).WillRepeatedly(Return(default_delay()));
 
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   const ModelTypeSet types(THEMES);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(WithArg<2>(sessions::test_util::SimulateTypesThrottled(
                           types, throttle1)),
                       Return(false)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(base::Time());
   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(types, FROM_HERE);
   PumpLoop();
 
   StopSyncScheduler();
 }
 
 TEST_F(SyncSchedulerTest, TypeThrottlingDoesBlockOtherSources) {
   UseMockDelayProvider();
-  EXPECT_CALL(*delay(), GetDelay(_))
-      .WillRepeatedly(Return(default_delay()));
+  EXPECT_CALL(*delay(), GetDelay(_)).WillRepeatedly(Return(default_delay()));
 
   SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromDays(1));
   TimeDelta throttle1(TimeDelta::FromSeconds(60));
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
 
   const ModelTypeSet throttled_types(THEMES);
   const ModelTypeSet unthrottled_types(PREFERENCES);
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(WithArg<2>(sessions::test_util::SimulateTypesThrottled(
                           throttled_types, throttle1)),
                       Return(false)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(base::Time());
   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(
-      THEMES, BuildInvalidation(10, "test"), FROM_HERE);
+  scheduler()->ScheduleInvalidationNudge(THEMES, BuildInvalidation(10, "test"),
+                                         FROM_HERE);
   PumpLoop();
 
   // Ignore refresh requests for throttled types.
   scheduler()->ScheduleLocalRefreshRequest(throttled_types, FROM_HERE);
   PumpLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Local nudges for non-throttled types will trigger a sync.
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
@@ skipping 20 matching lines @@
 
   const ModelTypeSet config_types(THEMES);
 
   EXPECT_CALL(*syncer(), ConfigureSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateConfigureSuccess),
                       RecordSyncShare(&times, true)))
       .RetiresOnSaturation();
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      config_types,
+      GetUpdatesCallerInfo::RECONFIGURATION, config_types,
       TypesToRoutingInfo(config_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   RunLoop();
   ASSERT_EQ(1, ready_counter.times_called());
   ASSERT_EQ(0, retry_counter.times_called());
 
   Mock::VerifyAndClearExpectations(syncer());
 
@@ skipping 81 matching lines @@
                 Return(false)))
       .WillRepeatedly(
           DoAll(Invoke(sessions::test_util::SimulateGetEncryptionKeyFailed),
                 QuitLoopNowAction(false)));
   StartSyncConfiguration();
 
   ModelTypeSet types(THEMES);
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      types,
-      TypesToRoutingInfo(types),
+      GetUpdatesCallerInfo::RECONFIGURATION, types, TypesToRoutingInfo(types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   RunLoop();
 
   EXPECT_TRUE(scheduler()->IsBackingOff());
 }
 
 // Test that no polls or extraneous nudges occur when in backoff.
 TEST_F(SyncSchedulerTest, BackoffDropsJobs) {
   SyncShareTimes times;
   TimeDelta poll(TimeDelta::FromMilliseconds(10));
   const ModelTypeSet types(THEMES);
   scheduler()->OnReceivedLongPollIntervalUpdate(poll);
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                       RecordSyncShareMultiple(&times, 1U, false)));
-  EXPECT_CALL(*delay(), GetDelay(_)).
-      WillRepeatedly(Return(TimeDelta::FromDays(1)));
+  EXPECT_CALL(*delay(), GetDelay(_))
+      .WillRepeatedly(Return(TimeDelta::FromDays(1)));
 
   StartSyncScheduler(base::Time());
 
   // This nudge should fail and put us into backoff.  Thanks to our mock
   // GetDelay() setup above, this will be a long backoff.
   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(types, FROM_HERE);
 
   Mock::VerifyAndClearExpectations(syncer());
   Mock::VerifyAndClearExpectations(delay());
 
   EXPECT_CALL(*delay(), GetDelay(_)).Times(0);
 
   StartSyncConfiguration();
 
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      types,
-      TypesToRoutingInfo(types),
+      GetUpdatesCallerInfo::RECONFIGURATION, types, TypesToRoutingInfo(types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
   PumpLoop();
   ASSERT_EQ(0, ready_counter.times_called());
   ASSERT_EQ(1, retry_counter.times_called());
 }
 
 // Test that backoff is shaping traffic properly with consecutive errors.
 TEST_F(SyncSchedulerTest, BackoffElevation) {
   SyncShareTimes times;
   UseMockDelayProvider();
 
   EXPECT_CALL(*syncer(), NormalSyncShare(_, _, _))
       .Times(kMinNumSamples)
       .WillRepeatedly(
           DoAll(Invoke(sessions::test_util::SimulateCommitFailed),
                 RecordSyncShareMultiple(&times, kMinNumSamples, false)));
 
   const TimeDelta first = TimeDelta::FromSeconds(kInitialBackoffRetrySeconds);
   const TimeDelta second = TimeDelta::FromMilliseconds(20);
   const TimeDelta third = TimeDelta::FromMilliseconds(30);
   const TimeDelta fourth = TimeDelta::FromMilliseconds(40);
   const TimeDelta fifth = TimeDelta::FromMilliseconds(50);
   const TimeDelta sixth = TimeDelta::FromDays(1);
 
-  EXPECT_CALL(*delay(), GetDelay(first)).WillOnce(Return(second))
-          .RetiresOnSaturation();
-  EXPECT_CALL(*delay(), GetDelay(second)).WillOnce(Return(third))
-          .RetiresOnSaturation();
-  EXPECT_CALL(*delay(), GetDelay(third)).WillOnce(Return(fourth))
-          .RetiresOnSaturation();
-  EXPECT_CALL(*delay(), GetDelay(fourth)).WillOnce(Return(fifth))
-          .RetiresOnSaturation();
+  EXPECT_CALL(*delay(), GetDelay(first))
+      .WillOnce(Return(second))
+      .RetiresOnSaturation();
+  EXPECT_CALL(*delay(), GetDelay(second))
+      .WillOnce(Return(third))
+      .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(base::Time());
 
   // Run again with a nudge.
   scheduler()->ScheduleLocalNudge(ModelTypeSet(THEMES), FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(kMinNumSamples, times.size());
   EXPECT_GE(times[1] - times[0], second);
@@ skipping 177 matching lines @@
           DoAll(Invoke(sessions::test_util::SimulateConfigureConnectionFailure),
                 Return(true)));
   StartSyncConfiguration();
   connection()->SetServerNotReachable();
   connection()->UpdateConnectionStatus();
 
   ModelTypeSet model_types(THEMES);
   CallbackCounter ready_counter;
   CallbackCounter retry_counter;
   ConfigurationParams params(
-      GetUpdatesCallerInfo::RECONFIGURATION,
-      model_types,
+      GetUpdatesCallerInfo::RECONFIGURATION, model_types,
       TypesToRoutingInfo(model_types),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&ready_counter)),
       base::Bind(&CallbackCounter::Callback, base::Unretained(&retry_counter)));
   scheduler()->ScheduleConfiguration(params);
 
   scheduler()->OnConnectionStatusChange();
   scheduler()->OnConnectionStatusChange();
 
   PumpLoop();  // Run the nudge, that will fail and schedule a quick retry.
 }
@@ skipping 141 matching lines @@
   ASSERT_TRUE(scheduler()->IsBackingOff());
 
   // Now succeed.
   connection()->SetServerReachable();
   PumpLoopFor(2 * delta);
   ASSERT_EQ(1, success_counter.times_called());
   ASSERT_FALSE(scheduler()->IsBackingOff());
 }
 
 }  // namespace syncer