Client-side changes to support retry GU.

sync/engine/sync_scheduler_unittest.cc

Index: sync/engine/sync_scheduler_unittest.cc
diff --git a/sync/engine/sync_scheduler_unittest.cc b/sync/engine/sync_scheduler_unittest.cc
index e5876554e81a53bdc4f95d95c8bac398f93bc835..561e2042002ac7c4460fede3b1170980bf9b8f1d 100644
--- a/sync/engine/sync_scheduler_unittest.cc
+++ b/sync/engine/sync_scheduler_unittest.cc
@@ -51,6 +51,7 @@ class MockSyncer : public Syncer {
                     sync_pb::GetUpdatesCallerInfo::GetUpdatesSource,
                     SyncSession*));
   MOCK_METHOD2(PollSyncShare, bool(ModelTypeSet, sessions::SyncSession*));
+  MOCK_METHOD2(RetrySyncShare, bool(ModelTypeSet, sessions::SyncSession*));
 };
 
 MockSyncer::MockSyncer()
@@ -545,8 +546,9 @@ 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),
-           RecordSyncShareMultiple(&times, kMinNumSamples)));
+      .WillRepeatedly(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   scheduler()->OnReceivedLongPollIntervalUpdate(poll_interval);
 
@@ -565,8 +567,9 @@ TEST_F(SyncSchedulerTest, PollNotificationsDisabled) {
   SyncShareTimes times;
   TimeDelta poll_interval(TimeDelta::FromMilliseconds(30));
   EXPECT_CALL(*syncer(), PollSyncShare(_,_)).Times(AtLeast(kMinNumSamples))
-      .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           RecordSyncShareMultiple(&times, kMinNumSamples)));
+      .WillRepeatedly(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   scheduler()->OnReceivedShortPollIntervalUpdate(poll_interval);
   scheduler()->SetNotificationsEnabled(false);
@@ -593,7 +596,7 @@ TEST_F(SyncSchedulerTest, PollIntervalUpdate) {
               sessions::test_util::SimulatePollIntervalUpdate(poll2)),
           Return(true)))
       .WillRepeatedly(
-          DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
                 WithArg<1>(
                     RecordSyncShareMultiple(&times, kMinNumSamples))));
 
@@ -684,8 +687,9 @@ TEST_F(SyncSchedulerTest, ThrottlingExpiresFromPoll) {
           Return(true)))
       .RetiresOnSaturation();
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
-      .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           RecordSyncShareMultiple(&times, kMinNumSamples)));
+      .WillRepeatedly(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   TimeTicks optimal_start = TimeTicks::Now() + poll + throttle1;
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -1117,7 +1121,7 @@ TEST_F(SyncSchedulerTest, BackoffRelief) {
   // Now let the Poll timer do its thing.
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
       .WillRepeatedly(DoAll(
-              Invoke(sessions::test_util::SimulatePollSuccess),
+              Invoke(sessions::test_util::SimulatePollRetrySuccess),
               RecordSyncShareMultiple(&times, kMinNumSamples)));
   RunLoop();
   Mock::VerifyAndClearExpectations(syncer());
@@ -1140,9 +1144,9 @@ TEST_F(SyncSchedulerTest, TransientPollFailure) {
   UseMockDelayProvider(); // Will cause test failure if backoff is initiated.
 
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollFailed),
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollRetryFailed),
                       RecordSyncShare(&times)))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
                       RecordSyncShare(&times)));
 
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -1275,8 +1279,9 @@ TEST_F(SyncSchedulerTest, PollFromCanaryAfterAuthError) {
 
   ::testing::InSequence seq;
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
-      .WillRepeatedly(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
-           RecordSyncShareMultiple(&times, kMinNumSamples)));
+      .WillRepeatedly(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                RecordSyncShareMultiple(&times, kMinNumSamples)));
 
   connection()->SetServerStatus(HttpResponse::SYNC_AUTH_ERROR);
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
@@ -1288,7 +1293,7 @@ TEST_F(SyncSchedulerTest, PollFromCanaryAfterAuthError) {
   // but after poll finished with auth error from poll timer it should retry
   // poll once more
   EXPECT_CALL(*syncer(), PollSyncShare(_,_))
-      .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollSuccess),
+      .WillOnce(DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
                       RecordSyncShare(&times)));
   scheduler()->OnCredentialsUpdated();
   connection()->SetServerStatus(HttpResponse::SERVER_CONNECTION_OK);
@@ -1296,4 +1301,85 @@ TEST_F(SyncSchedulerTest, PollFromCanaryAfterAuthError) {
   StopSyncScheduler();
 }
 
+TEST_F(SyncSchedulerTest, SuccessfulRetry) {
+  StartSyncScheduler(SyncScheduler::NORMAL_MODE);
+
+  SyncShareTimes times;
+  base::TimeTicks t1 = base::TimeTicks::Now();
+  scheduler()->OnReceivedGuRetryDelaySeconds(1);

[rlarocque, 2014/01/10 00:42:00]

Hmm... These tests will be slow.  We went out of our way to use a
MockDelayProvider to make these tests faster.  It would be nice to avoid
regressions.

Here's an alternative.  You could change the signature of
OnReceivedGuRetryDelaySeconds(int) to OnReceivedGuRetryDelay(base::TimeDelta). 
The new signature would be better that the original because it is more
expressive.  It will also let you pass in a really short timeout (ie. 1ms) for
tests here.

[haitaol1, 2014/01/10 22:10:34]

Done.

+
+  EXPECT_CALL(*syncer(), RetrySyncShare(_,_))
+      .WillOnce(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                RecordSyncShare(&times)));
+
+  // Run to wait for retrying.
+  RunLoop();
+
+  EXPECT_GE(times[0] - t1, base::TimeDelta::FromSeconds(1));
+
+  StopSyncScheduler();
+}
+
+TEST_F(SyncSchedulerTest, FaileRetry) {

[rlarocque, 2014/01/10 00:42:00]

typo: FailRetry?

[haitaol1, 2014/01/10 22:10:34]

Done.

+  UseMockDelayProvider();
+  EXPECT_CALL(*delay(), GetDelay(_))
+      .WillRepeatedly(Return(TimeDelta::FromMilliseconds(1)));
+
+  StartSyncScheduler(SyncScheduler::NORMAL_MODE);
+
+  scheduler()->OnReceivedGuRetryDelaySeconds(1);
+
+  EXPECT_CALL(*syncer(), RetrySyncShare(_,_))
+      .WillOnce(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetryFailed),
+                QuitLoopNowAction()));
+
+  // Run to wait for retrying.
+  RunLoop();
+
+  EXPECT_TRUE(scheduler()->IsBackingOff());
+  EXPECT_CALL(*syncer(), RetrySyncShare(_,_))
+      .WillOnce(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                QuitLoopNowAction()));
+
+  // Run to wait for second retrying.
+  RunLoop();
+
+  StopSyncScheduler();
+}
+
+TEST_F(SyncSchedulerTest, ReceiveNewRetryDelay) {
+  StartSyncScheduler(SyncScheduler::NORMAL_MODE);
+
+  SyncShareTimes times;
+  base::TimeTicks t1 = base::TimeTicks::Now();
+  scheduler()->OnReceivedGuRetryDelaySeconds(1);
+  scheduler()->ScheduleLocalRefreshRequest(zero(), ModelTypeSet(BOOKMARKS),
+                                           FROM_HERE);
+
+  EXPECT_CALL(*syncer(), NormalSyncShare(_,_,_))
+      .WillOnce(
+          DoAll(WithArg<2>(sessions::test_util::SimulateGuRetryDelayCommand(2)),
+                RecordSyncShare(&times)));
+
+  // Run nudge GU.
+  RunLoop();
+
+  EXPECT_LT(times[0] - t1, base::TimeDelta::FromSeconds(1));

[rlarocque, 2014/01/10 00:42:00]

This looks flaky.  What if the timer takes an unusually long time to fire?

[haitaol1, 2014/01/10 22:10:34]

Done.

+
+  EXPECT_CALL(*syncer(), RetrySyncShare(_,_))
+      .WillOnce(
+          DoAll(Invoke(sessions::test_util::SimulatePollRetrySuccess),
+                RecordSyncShare(&times)));
+
+  // Run to wait for retrying.
+  RunLoop();
+
+  EXPECT_NEAR((times[1] - times[0]).InSeconds(), 2, 0.2);

[rlarocque, 2014/01/10 00:42:00]

This one is almost certain to be flaky.  We can't have tests that rely on
accurate timers.  Every time we've tried it, we ended up having to disable the
tests as flaky then rewrite them.

[haitaol1, 2014/01/10 22:10:34]

Done.

+
+  StopSyncScheduler();
+}
+
 }  // namespace syncer