sync: Remove SyncManager::TestingMode in favour of InternalComponentsFactory.

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"
-#include "sync/engine/sync_scheduler.h"
+#include "sync/engine/sync_scheduler_impl.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/throttled_data_type_tracker.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/test_directory_setter_upper.h"
 #include "sync/test/fake_extensions_activity_monitor.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 59 matching lines @@
 // Convenient to use in tests wishing to analyze SyncShare calls over time.
 static const size_t kMinNumSamples = 5;
 class SyncSchedulerTest : public testing::Test {
  public:
   SyncSchedulerTest()
       : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
         context_(NULL),
         syncer_(NULL),
         delay_(NULL) {}
 
-  class MockDelayProvider : public SyncScheduler::DelayProvider {
+  class MockDelayProvider : public SyncSchedulerImpl::DelayProvider {
    public:
     MOCK_METHOD1(GetDelay, TimeDelta(const TimeDelta&));
   };
 
   virtual void SetUp() {
     dir_maker_.SetUp();
     syncer_ = new MockSyncer();
     delay_ = NULL;
 
     ModelSafeRoutingInfo routing_info;
@@ skipping 15 matching lines @@
     connection_.reset(new MockConnectionManager(directory()));
     connection_->SetServerReachable();
     throttled_data_type_tracker_.reset(new ThrottledDataTypeTracker(NULL));
     context_.reset(new SyncSessionContext(
             connection_.get(), directory(), routing_info, workers,
             &extensions_activity_monitor_, throttled_data_type_tracker_.get(),
             std::vector<SyncEngineEventListener*>(), NULL, NULL));
     context_->set_notifications_enabled(true);
     context_->set_account_name("Test");
     scheduler_.reset(
-        new SyncScheduler("TestSyncScheduler", context(), syncer_));
+        new SyncSchedulerImpl("TestSyncScheduler", context(), syncer_));
   }
 
-  SyncScheduler* scheduler() { return scheduler_.get(); }
+  SyncSchedulerImpl* scheduler() { return scheduler_.get(); }
   MockSyncer* syncer() { return syncer_; }
   MockDelayProvider* delay() { return delay_; }
   MockConnectionManager* connection() { return connection_.get(); }
   TimeDelta zero() { return TimeDelta::FromSeconds(0); }
   TimeDelta timeout() {
     return TestTimeouts::action_timeout();
   }
 
   virtual void TearDown() {
     PumpLoop();
@@ skipping 67 matching lines @@
  private:
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
   base::WeakPtrFactory<SyncSchedulerTest> weak_ptr_factory_;
   MessageLoop message_loop_;
   TestDirectorySetterUpper dir_maker_;
   scoped_ptr<MockConnectionManager> connection_;
   scoped_ptr<SyncSessionContext> context_;
-  scoped_ptr<SyncScheduler> scheduler_;
+  scoped_ptr<SyncSchedulerImpl> scheduler_;
   MockSyncer* syncer_;
   MockDelayProvider* delay_;
   std::vector<scoped_refptr<FakeModelWorker> > workers_;
   FakeExtensionsActivityMonitor extensions_activity_monitor_;
   scoped_ptr<ThrottledDataTypeTracker> throttled_data_type_tracker_;
 };
 
 void RecordSyncShareImpl(SyncSession* s, SyncShareRecords* record) {
   record->times.push_back(TimeTicks::Now());
   record->snapshots.push_back(s->TakeSnapshot());
@@ skipping 382 matching lines @@
 
 // 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);
+  scheduler()->SetNotificationsEnabled(false);
 
   TimeTicks optimal_start = TimeTicks::Now() + poll_interval;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   // Run again to wait for polling.
   RunLoop();
 
   StopSyncScheduler();
   AnalyzePollRun(records, kMinNumSamples, optimal_start, poll_interval);
 }
@@ skipping 31 matching lines @@
 
   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());
+  EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
-  EXPECT_EQ(delay1, scheduler()->sessions_commit_delay());
+  EXPECT_EQ(delay1, scheduler()->GetSessionsCommitDelay());
   const ModelTypeSet model_types(syncer::BOOKMARKS);
   scheduler()->ScheduleNudgeAsync(
       zero(), NUDGE_SOURCE_LOCAL, model_types, FROM_HERE);
   RunLoop();
 
-  EXPECT_EQ(delay2, scheduler()->sessions_commit_delay());
+  EXPECT_EQ(delay2, scheduler()->GetSessionsCommitDelay());
   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);
@@ skipping 347 matching lines @@
   RunLoop();
   EXPECT_FALSE(scheduler()->IsBackingOff());
 
   // Run the successful poll.
   RunLoop();
   EXPECT_FALSE(scheduler()->IsBackingOff());
 }
 
 TEST_F(SyncSchedulerTest, GetRecommendedDelay) {
   EXPECT_LE(TimeDelta::FromSeconds(0),
-            SyncScheduler::GetRecommendedDelay(TimeDelta::FromSeconds(0)));
+            SyncSchedulerImpl::GetRecommendedDelay(TimeDelta::FromSeconds(0)));
   EXPECT_LE(TimeDelta::FromSeconds(1),
-            SyncScheduler::GetRecommendedDelay(TimeDelta::FromSeconds(1)));
+            SyncSchedulerImpl::GetRecommendedDelay(TimeDelta::FromSeconds(1)));
   EXPECT_LE(TimeDelta::FromSeconds(50),
-            SyncScheduler::GetRecommendedDelay(TimeDelta::FromSeconds(50)));
+            SyncSchedulerImpl::GetRecommendedDelay(
+                TimeDelta::FromSeconds(50)));
   EXPECT_LE(TimeDelta::FromSeconds(10),
-            SyncScheduler::GetRecommendedDelay(TimeDelta::FromSeconds(10)));
+            SyncSchedulerImpl::GetRecommendedDelay(
+                TimeDelta::FromSeconds(10)));
   EXPECT_EQ(TimeDelta::FromSeconds(kMaxBackoffSeconds),
-            SyncScheduler::GetRecommendedDelay(
+            SyncSchedulerImpl::GetRecommendedDelay(
                 TimeDelta::FromSeconds(kMaxBackoffSeconds)));
   EXPECT_EQ(TimeDelta::FromSeconds(kMaxBackoffSeconds),
-            SyncScheduler::GetRecommendedDelay(
+            SyncSchedulerImpl::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);
 
@@ skipping 106 matching lines @@
   PumpLoop();
   // Pump again to run job.
   PumpLoop();
 
   StopSyncScheduler();
 
   EXPECT_TRUE(expected == context()->previous_session_routing_info());
 }
 
 }  // namespace syncer