sync: Inject sync/'s dependency on invalidations

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"
 #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/notifier/invalidation_util.h"
 #include "sync/notifier/object_id_invalidation_map.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/mock_invalidation.h"
 #include "sync/util/extensions_activity.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;
@@ skipping 180 matching lines @@
 
   ModelTypeSet GetThrottledTypes() {
     return scheduler_->nudge_tracker_.GetThrottledTypes();
   }
 
   base::TimeDelta GetRetryTimerDelay() {
     EXPECT_TRUE(scheduler_->retry_timer_.IsRunning());
     return scheduler_->retry_timer_.GetCurrentDelay();
   }
 
+  static scoped_ptr<InvalidationInterface> BuildInvalidation(
+      int64 version,
+      const std::string& payload) {
+    return MockInvalidation::Build(version, payload)
+        .PassAs<InvalidationInterface>();
+  }
+
  private:
   syncable::Directory* directory() {
     return dir_maker_.directory();
   }
 
   base::MessageLoop loop_;
   TestDirectorySetterUpper dir_maker_;
   CancelationSignal cancelation_signal_;
   scoped_ptr<MockConnectionManager> connection_;
   scoped_ptr<ModelTypeRegistry> model_type_registry_;
@@ skipping 283 matching lines @@
   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;
-  ObjectIdInvalidationMap invalidations1 =
-      BuildInvalidationMap(BOOKMARKS, 10, "test");
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times1)))
       .RetiresOnSaturation();
-  scheduler()->ScheduleInvalidationNudge(zero(), invalidations1, FROM_HERE);
+  scheduler()->ScheduleInvalidationNudge(
+      zero(), BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
   RunLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareTimes times2;
-  ObjectIdInvalidationMap invalidations2 =
-      BuildInvalidationMap(AUTOFILL, 10, "test2");
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times2)));
-  scheduler()->ScheduleInvalidationNudge(zero(), invalidations2, FROM_HERE);
+  scheduler()->ScheduleInvalidationNudge(
+      zero(), AUTOFILL, 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 272 matching lines @@
           Return(true)))
       .RetiresOnSaturation();
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
   scheduler()->ScheduleLocalNudge(zero(), 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.
-  ObjectIdInvalidationMap invalidations =
-      BuildInvalidationMap(BOOKMARKS, 10, "test");
-  scheduler()->ScheduleInvalidationNudge(zero(), invalidations, FROM_HERE);
+  scheduler()->ScheduleInvalidationNudge(
+      zero(), BOOKMARKS, BuildInvalidation(10, "test"), FROM_HERE);
   PumpLoop();
 
   // Ignore refresh requests for throttled types.
   scheduler()->ScheduleLocalRefreshRequest(zero(), throttled_types, FROM_HERE);
   PumpLoop();
 
   Mock::VerifyAndClearExpectations(syncer());
 
   // Local nudges for non-throttled types will trigger a sync.
   EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
@@ skipping 534 matching lines @@
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateNormalSuccess),
                       RecordSyncShare(&times)));
 
   // Run to wait for retrying.
   RunLoop();
 
   StopSyncScheduler();
 }
 
 }  // namespace syncer