sync: use progress markers instead of timestamps during GetUpdates

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 "base/lock.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
@@ skipping 24 matching lines @@
 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 num_server_changes_remaining,
     int64 unsynced_count) {
+  std::string download_progress_markers[syncable::MODEL_TYPE_COUNT];
+  for (int i = syncable::FIRST_REAL_MODEL_TYPE;
+       i < syncable::MODEL_TYPE_COUNT;
+       ++i) {
+    syncable::ModelType type(syncable::ModelTypeFromInt(i));
+    sync_pb::DataTypeProgressMarker token;
+    token.set_data_type_id(
+        syncable::GetExtensionFieldNumberFromModelType(type));
+    token.set_token("foobar");
+    token.SerializeToString(&download_progress_markers[i]);
+  }
   return SyncSessionSnapshot(SyncerStatus(), ErrorCounters(),
-      num_server_changes_remaining, max_local_timestamp, false,
-      syncable::ModelTypeBitSet(), false, false, unsynced_count, 0, false);
+      num_server_changes_remaining, false,
+      syncable::ModelTypeBitSet(), download_progress_markers,
+      false, false, unsynced_count, 0, false);
 }
 
 class ListenerMock : public SyncEngineEventListener {
  public:
   MOCK_METHOD1(OnSyncEngineEvent, void(const SyncEngineEvent&));
 };
 
 class SyncerThreadWithSyncerTest : public testing::Test,
                                    public ModelSafeWorkerRegistrar,
                                    public SyncEngineEventListener {
@@ skipping 326 matching lines @@
     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.
   {
     // More server changes remaining to download.
-    context->set_last_snapshot(SessionSnapshotForTest(1, 0, 0));
+    context->set_last_snapshot(SessionSnapshotForTest(1, 0));
     bool continue_sync_cycle_param = false;
 
     WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
         0,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         false);
 
     ASSERT_LE(0, interval.poll_delta.InSeconds());
     ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
@@ skipping 27 matching lines @@
         &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);
 
     // Now simulate no more server changes remaining.
-    context->set_last_snapshot(SessionSnapshotForTest(1, 1, 0));
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0));
     interval = syncer_thread->CalculatePollingWaitTime(
         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);
   }
 
   {
 
     // Now try with unsynced local items.
-    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 1));
+    context->set_last_snapshot(SessionSnapshotForTest(0, 1));
     bool continue_sync_cycle_param = false;
 
     WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
         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(
         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);
 
-    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 0));
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0));
     interval = syncer_thread->CalculatePollingWaitTime(
         4,
         &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);
   }
 
   // Regression for exponential backoff reset when the syncer is nudged.
   {
 
-    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 1));
+    context->set_last_snapshot(SessionSnapshotForTest(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(
         3600,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         false);
 
@@ skipping 101 matching lines @@
         &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.
-    context->set_last_snapshot(SessionSnapshotForTest(0, 0, 0));
+    context->set_last_snapshot(SessionSnapshotForTest(0, 0));
     interval = syncer_thread->CalculatePollingWaitTime(
         4,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         true);
 
     ASSERT_EQ(SyncerThread::kDefaultLongPollIntervalSeconds,
               interval.poll_delta.InSeconds());
     ASSERT_EQ(WaitInterval::NORMAL, interval.mode);
     ASSERT_FALSE(interval.had_nudge_during_backoff);
@@ skipping 477 matching lines @@
   EXPECT_CALL(listener, OnSyncEngineEvent(
       Field(&SyncEngineEvent::what_happened,
       SyncEngineEvent::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