Unplumb AllStatus from SyncerThread.

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/lock.h"
 #include "base/scoped_ptr.h"
@@ skipping 10 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::TimeTicks;
 using base::TimeDelta;
 using base::WaitableEvent;
 using testing::_;
 using testing::AnyNumber;
 using testing::Field;
 
 namespace browser_sync {
+using sessions::ErrorCounters;
 using sessions::SyncSessionContext;
+using sessions::SyncSessionSnapshot;
+using sessions::SyncerStatus;
 
 typedef testing::Test SyncerThreadTest;
 typedef SyncerThread::WaitInterval WaitInterval;
 
 ACTION_P(SignalEvent, event) {
   event->Signal();
 }
 
+SyncSessionSnapshot SessionSnapshotForTest(
+    int64 num_server_changes_remaining, int64 max_local_timestamp,
+    int64 unsynced_count) {
+  return SyncSessionSnapshot(SyncerStatus(), ErrorCounters(),
+      num_server_changes_remaining, max_local_timestamp, false,
+      syncable::ModelTypeBitSet(), false, false, unsynced_count, 0, false);
+}
+
 class ListenerMock : public ChannelEventHandler<SyncerEvent> {
  public:
   MOCK_METHOD1(HandleChannelEvent, void(const SyncerEvent&));
 };
 
 class SyncerThreadWithSyncerTest : public testing::Test,
                                    public ModelSafeWorkerRegistrar,
                                    public ChannelEventHandler<SyncerEvent> {
  public:
   SyncerThreadWithSyncerTest()
       : max_wait_time_(TimeDelta::FromSeconds(10)),
         sync_cycle_ended_event_(false, false) {}
   virtual void SetUp() {
     metadb_.SetUp();
     connection_.reset(new MockConnectionManager(metadb_.manager(),
                                                 metadb_.name()));
-    allstatus_.reset(new AllStatus());
     worker_ = new ModelSafeWorker();
     SyncSessionContext* context = new SyncSessionContext(connection_.get(),
         NULL, metadb_.manager(), this);
-    syncer_thread_ = new SyncerThread(context, allstatus_.get());
+    syncer_thread_ = new SyncerThread(context);
     syncer_event_hookup_.reset(
         syncer_thread_->relay_channel()->AddObserver(this));
-    allstatus_->WatchSyncerThread(syncer_thread_);
     syncer_thread_->SetConnected(true);
     syncable::ModelTypeBitSet expected_types;
     expected_types[syncable::BOOKMARKS] = true;
     connection_->ExpectGetUpdatesRequestTypes(expected_types);
   }
   virtual void TearDown() {
     syncer_event_hookup_.reset();
-    allstatus_.reset();
     syncer_thread_ = NULL;
     connection_.reset();
     metadb_.TearDown();
   }
 
   // ModelSafeWorkerRegistrar implementation.
   virtual void GetWorkers(std::vector<ModelSafeWorker*>* out) {
     out->push_back(worker_.get());
   }
 
@@ skipping 70 matching lines @@
     if (event.what_happened == SyncerEvent::SYNC_CYCLE_ENDED)
       sync_cycle_ended_event_.Signal();
   }
 
  protected:
   TimeDelta max_wait_time_;
 
  private:
   ManuallyOpenedTestDirectorySetterUpper metadb_;
   scoped_ptr<MockConnectionManager> connection_;
-  scoped_ptr<AllStatus> allstatus_;
   scoped_refptr<SyncerThread> syncer_thread_;
   scoped_refptr<ModelSafeWorker> worker_;
   scoped_ptr<ChannelHookup<SyncerEvent> > syncer_event_hookup_;
   base::WaitableEvent sync_cycle_ended_event_;
   DISALLOW_COPY_AND_ASSIGN(SyncerThreadWithSyncerTest);
 };
 
 class SyncShareIntercept
     : public MockConnectionManager::ResponseCodeOverrideRequestor,
       public MockConnectionManager::MidCommitObserver {
@@ skipping 31 matching lines @@
   }
  private:
   std::vector<TimeTicks> times_sync_occured_;
   base::WaitableEvent sync_occured_;
   bool allow_multiple_interceptions_;
   DISALLOW_COPY_AND_ASSIGN(SyncShareIntercept);
 };
 
 TEST_F(SyncerThreadTest, Construction) {
   SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
-  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context, NULL));
+  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
 }
 
 TEST_F(SyncerThreadTest, StartStop) {
   SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
-  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context, NULL));
+  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
   EXPECT_TRUE(syncer_thread->Start());
   EXPECT_TRUE(syncer_thread->Stop(2000));
 
   // Do it again for good measure.  I caught some bugs by adding this so
   // I would recommend keeping it.
   EXPECT_TRUE(syncer_thread->Start());
   EXPECT_TRUE(syncer_thread->Stop(2000));
 }
 
+TEST(SyncerThread, GetRecommendedDelay) {
+  EXPECT_LE(0, SyncerThread::GetRecommendedDelaySeconds(0));
+  EXPECT_LE(1, SyncerThread::GetRecommendedDelaySeconds(1));
+  EXPECT_LE(50, SyncerThread::GetRecommendedDelaySeconds(50));
+  EXPECT_LE(10, SyncerThread::GetRecommendedDelaySeconds(10));
+  EXPECT_EQ(SyncerThread::kMaxBackoffSeconds,
+            SyncerThread::GetRecommendedDelaySeconds(
+                SyncerThread::kMaxBackoffSeconds));
+  EXPECT_EQ(SyncerThread::kMaxBackoffSeconds,
+            SyncerThread::GetRecommendedDelaySeconds(
+                SyncerThread::kMaxBackoffSeconds+1));
+}
+
 TEST_F(SyncerThreadTest, CalculateSyncWaitTime) {
   SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
-  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context, NULL));
+  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
   syncer_thread->DisableIdleDetection();
 
   // Syncer_polling_interval_ is less than max poll interval.
   TimeDelta syncer_polling_interval = TimeDelta::FromSeconds(1);
 
   syncer_thread->SetSyncerPollingInterval(syncer_polling_interval);
 
   // user_idle_ms is less than 10 * (syncer_polling_interval*1000).
   ASSERT_EQ(syncer_polling_interval.InMilliseconds(),
             syncer_thread->CalculateSyncWaitTime(1000, 0));
@@ skipping 39 matching lines @@
                                                    over_sync_max_interval));
   ASSERT_TRUE(last_poll_time * 3 >=
               syncer_thread->CalculateSyncWaitTime(last_poll_time,
                                                    over_sync_max_interval));
 }
 
 TEST_F(SyncerThreadTest, CalculatePollingWaitTime) {
   // Set up the environment.
   int user_idle_milliseconds_param = 0;
   SyncSessionContext* context = new SyncSessionContext(NULL, NULL, NULL, NULL);
-  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context, NULL));
+  scoped_refptr<SyncerThread> syncer_thread(new SyncerThread(context));
   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;
+    context->set_notifications_enabled(false);
     bool continue_sync_cycle_param = false;
 
     // No work and no backoff.
     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;
     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);
   }
 
   // Notifications enabled should result in a polling interval of
   // SyncerThread::kDefaultLongPollIntervalSeconds.
   {
-    AllStatus::Status status = {};
-    status.notifications_enabled = 1;
+    context->set_notifications_enabled(true);
     bool continue_sync_cycle_param = false;
 
     // No work and no backoff.
     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;
     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);
   }
 
   // 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;
+    // More server changes remaining to download.
+    context->set_last_snapshot(SessionSnapshotForTest(1, 0, 0));
     bool continue_sync_cycle_param = false;
 
     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;
     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);
 
     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;
+    // Now simulate no more server changes remaining.
+    context->set_last_snapshot(SessionSnapshotForTest(1, 1, 0));
     interval = syncer_thread->CalculatePollingWaitTime(
-        status,
         0,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         false);
 
-    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+    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);
   }
 
   {
-    AllStatus::Status status = {};
-    status.unsynced_count = 1;
+
+    // Now try with unsynced local items.
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 1));
     bool continue_sync_cycle_param = false;
 
     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;
     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;
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 0));
     interval = syncer_thread->CalculatePollingWaitTime(
-        status,
         4,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         false);
 
-    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+    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);
   }
 
   // Regression for exponential backoff reset when the syncer is nudged.
   {
-    AllStatus::Status status = {};
-    status.unsynced_count = 1;
+
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 1));
     bool continue_sync_cycle_param = false;
 
     // Expect move from default polling interval to exponential backoff due to
     // unsynced_count != 0.
     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;
     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.
     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;
     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;
     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;
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 0));
     interval = syncer_thread->CalculatePollingWaitTime(
-        status,
         4,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         true);
 
-    ASSERT_EQ(SyncerThread::kDefaultShortPollIntervalSeconds,
+    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);
   }
 }
 
 TEST_F(SyncerThreadWithSyncerTest, Polling) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
@@ skipping 365 matching lines @@
       WillOnce(SignalEvent(&sync_cycle_ended_event));
   EXPECT_CALL(listener, HandleChannelEvent(
       Field(&SyncerEvent::what_happened, SyncerEvent::SYNCER_THREAD_EXITING)));
 
   ASSERT_TRUE(Resume(&listener));
   ASSERT_TRUE(sync_cycle_ended_event.TimedWait(max_wait_time_));
   EXPECT_TRUE(syncer_thread()->Stop(2000));
 }
 
 }  // namespace browser_sync