For sync exponential backoff, allow one nudge per exponential backoff interva...

chrome/browser/sync/engine/syncer_thread_unittest.cc

 // Copyright (c) 2009 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 <list>
 #include <map>
 #include <set>
 
 #include "base/command_line.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/sync/engine/model_safe_worker.h"
 #include "chrome/browser/sync/engine/syncer_thread.h"
 #include "chrome/browser/sync/engine/syncer_thread_timed_stop.h"
 #include "chrome/test/sync/engine/mock_server_connection.h"
 #include "chrome/test/sync/engine/test_directory_setter_upper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeTicks;
 using base::TimeDelta;
 
 namespace browser_sync {
 
 typedef testing::Test SyncerThreadTest;
+typedef SyncerThread::WaitInterval WaitInterval;
 
 class SyncerThreadWithSyncerTest : public testing::Test {
  public:
   SyncerThreadWithSyncerTest() {}
   virtual void SetUp() {
     metadb_.SetUp();
     connection_.reset(new MockConnectionManager(metadb_.manager(),
                                                 metadb_.name()));
     allstatus_.reset(new AllStatus());
 
@@ skipping 116 matching lines @@
               syncer_thread->CalculateSyncWaitTime(last_poll_time,
                                                    over_sync_max_interval));
 }
 
 TEST_F(SyncerThreadTest, CalculatePollingWaitTime) {
   // Set up the environment.
   int user_idle_milliseconds_param = 0;
   scoped_refptr<SyncerThread> syncer_thread(
       SyncerThreadFactory::Create(NULL, NULL, NULL, NULL, NULL));
   syncer_thread->DisableIdleDetection();
+  // Hold the lock to appease asserts in code.
+  AutoLock lock(syncer_thread->lock_);
 
   // Notifications disabled should result in a polling interval of
   // kDefaultShortPollInterval.
   {
     AllStatus::Status status = {};
     status.notifications_enabled = 0;
     bool continue_sync_cycle_param = false;
 
     // No work and no backoff.
-    ASSERT_TRUE(SyncerThread::kDefaultShortPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    0,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
 
     // In this case the continue_sync_cycle is turned off.
     continue_sync_cycle_param = true;
-    ASSERT_TRUE(SyncerThread::kDefaultShortPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    0,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+        interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
-
-    // TODO(brg) : Find a way to test exponential backoff is inoperable.
-    // Exponential backoff should be turned on when notifications are disabled
-    // but this can not be tested since we can not set the last input info.
   }
 
   // Notifications enabled should result in a polling interval of
   // SyncerThread::kDefaultLongPollIntervalSeconds.
   {
     AllStatus::Status status = {};
     status.notifications_enabled = 1;
     bool continue_sync_cycle_param = false;
 
     // No work and no backoff.
-    ASSERT_TRUE(SyncerThread::kDefaultLongPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    0,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_EQ(SyncerThread::kDefaultLongPollIntervalSeconds,
+              interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
 
     // In this case the continue_sync_cycle is turned off.
     continue_sync_cycle_param = true;
-    ASSERT_TRUE(SyncerThread::kDefaultLongPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    0,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_EQ(SyncerThread::kDefaultLongPollIntervalSeconds,
+              interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
-
-    // TODO(brg) : Find a way to test exponential backoff.
-    // Exponential backoff should be turned off when notifications are enabled,
-    // but this can not be tested since we can not set the last input info.
   }
 
   // There are two states which can cause a continuation, either the updates
   // available do not match the updates received, or the unsynced count is
   // non-zero.
   {
     AllStatus::Status status = {};
     status.updates_available = 1;
     status.updates_received = 0;
     bool continue_sync_cycle_param = false;
 
-    ASSERT_TRUE(0 <= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         0,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_LE(0, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     continue_sync_cycle_param = false;
-    ASSERT_TRUE(3 >= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         0,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_GE(3, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
-    ASSERT_TRUE(0 <= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         0,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
-    ASSERT_TRUE(2 >= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         0,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_LE(0, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
+
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_GE(2, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     status.updates_received = 1;
-    ASSERT_TRUE(SyncerThread::kDefaultShortPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    10,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+                interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
   }
 
   {
     AllStatus::Status status = {};
     status.unsynced_count = 1;
     bool continue_sync_cycle_param = false;
 
-    ASSERT_TRUE(0 <= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         0,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_LE(0, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     continue_sync_cycle_param = false;
-    ASSERT_TRUE(2 >= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         0,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        0,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_GE(2, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     status.unsynced_count = 0;
-    ASSERT_TRUE(SyncerThread::kDefaultShortPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    4,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        4,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
   }
 
   // Regression for exponential backoff reset when the syncer is nudged.
   {
     AllStatus::Status status = {};
     status.unsynced_count = 1;
     bool continue_sync_cycle_param = false;
 
     // Expect move from default polling interval to exponential backoff due to
     // unsynced_count != 0.
-    ASSERT_TRUE(0 <= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         3600,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        3600,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_LE(0, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     continue_sync_cycle_param = false;
-    ASSERT_TRUE(2 >= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         3600,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        3600,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_GE(2, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     // Expect exponential backoff.
-    ASSERT_TRUE(2 <= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         2,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
-    ASSERT_TRUE(6 >= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         2,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        2,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_LE(2, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        2,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_GE(6, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    syncer_thread->vault_.current_wait_interval_ = interval;
+
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        static_cast<int>(interval.poll_delta.InSeconds()),
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        true);
+
+    // Don't change poll on a failed nudge during backoff.
+    ASSERT_TRUE(syncer_thread->vault_.current_wait_interval_.poll_delta ==
+              interval.poll_delta);
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_TRUE(interval.had_nudge_during_backoff);
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    // If we got a nudge and we weren't in backoff mode, we see exponential
+    // backoff.
+    syncer_thread->vault_.current_wait_interval_.mode = WaitInterval::NORMAL;
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        2,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        true);
+
+    // 5 and 3 are bounds on the backoff randomization formula given input of 2.
+    ASSERT_GE(5, interval.poll_delta.InSeconds());
+    ASSERT_LE(3, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
+    ASSERT_TRUE(continue_sync_cycle_param);
+
+    // And if another interval expires, we get a bigger backoff.
+    WaitInterval new_interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        static_cast<int>(interval.poll_delta.InSeconds()),
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        false);
+
+    ASSERT_GE(12, new_interval.poll_delta.InSeconds());
+    ASSERT_LE(5, new_interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::EXPONENTIAL_BACKOFF, interval.mode);
+    ASSERT_FALSE(new_interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     // A nudge resets the continue_sync_cycle_param value, so our backoff
     // should return to the minimum.
     continue_sync_cycle_param = false;
-    ASSERT_TRUE(0 <= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         3600,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        3600,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        true);
+
+    ASSERT_LE(0, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     continue_sync_cycle_param = false;
-    ASSERT_TRUE(2 >= syncer_thread->CalculatePollingWaitTime(
-                         status,
-                         3600,
-                         &user_idle_milliseconds_param,
-                         &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        3600,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        true);
+
+    ASSERT_GE(2, interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_TRUE(continue_sync_cycle_param);
 
     // Setting unsynced_count = 0 returns us to the default polling interval.
     status.unsynced_count = 0;
-    ASSERT_TRUE(SyncerThread::kDefaultShortPollIntervalSeconds ==
-                syncer_thread->CalculatePollingWaitTime(
-                    status,
-                    4,
-                    &user_idle_milliseconds_param,
-                    &continue_sync_cycle_param));
+    interval = syncer_thread->CalculatePollingWaitTime(
+        status,
+        4,
+        &user_idle_milliseconds_param,
+        &continue_sync_cycle_param,
+        true);
+
+    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+              interval.poll_delta.InSeconds());
+    ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
+    ASSERT_FALSE(interval.had_nudge_during_backoff);
     ASSERT_FALSE(continue_sync_cycle_param);
   }
 }
 
 TEST_F(SyncerThreadWithSyncerTest, Polling) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
 
   const TimeDelta poll_interval = TimeDelta::FromSeconds(1);
   syncer_thread()->SetSyncerShortPollInterval(poll_interval);
@@ skipping 43 matching lines @@
   syncer_thread()->NudgeSyncer(5, SyncerThread::kUnknown);
   interceptor.WaitForSyncShare(1, TimeDelta::FromSeconds(1));
   EXPECT_EQ(static_cast<unsigned int>(2),
       interceptor.times_sync_occured().size());
 
   // SyncerThread should be waiting again.  Signal it to stop.
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 }  // namespace browser_sync