Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(2705)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: chrome/browser/sync/engine/syncer_thread_unittest.cc

Issue 275015: For sync exponential backoff, allow one nudge per exponential backoff interva... (Closed) Base URL: svn://chrome-svn/chrome/trunk/src/
Patch Set: '' Created 11 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « chrome/browser/sync/engine/syncer_thread.cc ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: chrome/browser/sync/engine/syncer_thread_unittest.cc
===================================================================
--- chrome/browser/sync/engine/syncer_thread_unittest.cc (revision 28645)
+++ chrome/browser/sync/engine/syncer_thread_unittest.cc (working copy)
@@ -22,6 +22,7 @@
namespace browser_sync {
typedef testing::Test SyncerThreadTest;
+typedef SyncerThread::WaitInterval WaitInterval;
class SyncerThreadWithSyncerTest : public testing::Test {
public:
@@ -158,6 +159,8 @@
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.
@@ -167,27 +170,33 @@
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
@@ -198,27 +207,33 @@
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
@@ -230,40 +245,66 @@
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);
}
@@ -272,28 +313,43 @@
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);
}
@@ -305,60 +361,144 @@
// 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);
}
}
« no previous file with comments | « chrome/browser/sync/engine/syncer_thread.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698