[SYNC] Refactor SyncSourceInfo and add support in chrome invalidation client ...

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 15 matching lines @@
 using testing::_;
 using testing::AnyNumber;
 using testing::Field;
 
 namespace browser_sync {
 using sessions::ErrorCounters;
 using sessions::TestScopedSessionEventListener;
 using sessions::SyncSessionContext;
 using sessions::SyncSessionSnapshot;
 using sessions::SyncerStatus;
+using sessions::SyncSourceInfo;
 
 typedef testing::Test SyncerThreadTest;
 typedef SyncerThread::WaitInterval WaitInterval;
 
 ACTION_P(SignalEvent, event) {
   event->Signal();
 }
 
 SyncSessionSnapshot SessionSnapshotForTest(
     int64 num_server_changes_remaining,
@@ skipping 116 matching lines @@
     if (!syncer_thread()->RequestResume())
       return false;
     return event.TimedWait(max_wait_time_);
   }
 
   void PreventThreadFromPolling() {
     const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
     syncer_thread()->SetSyncerShortPollInterval(poll_interval);
   }
 
+  // Compare a provided SyncSouceInfo::ModelTypeMap to the pending nudge info
+  // stored in the SyncerThread vault.
+  bool CompareNudgeTypesToVault(const SyncSourceInfo::ModelTypeMap& lhs) {
+    const SyncSourceInfo::ModelTypeMap& vault_nudge_types =
+        syncer_thread()->vault_.pending_nudge_types_;
+    for (size_t i = syncable::FIRST_REAL_MODEL_TYPE;

[akalin, 2011/01/21 19:50:09]

I'm pretty sure a std::map already has operator== defined, which should work as
expected here.

[Nicolas Zea, 2011/01/21 21:57:44]

Done.

+         i < syncable::MODEL_TYPE_COUNT;
+         ++i) {
+      syncable::ModelType type = syncable::ModelTypeFromInt(i);
+      SyncSourceInfo::ModelTypeMap::const_iterator payload = lhs.find(type);
+      if (payload != lhs.end()) {
+        if (vault_nudge_types.count(type) == 0 ||
+            payload->second != vault_nudge_types.find(type)->second) {
+          return false;
+        }
+      } else if (vault_nudge_types.count(type) > 0) {
+          return false;
+      }
+    }
+    return true;
+  }
+
+  // Compare a provided ModelTypeBitset to the pending nudge info stored in the
+  // SyncerThread vault.
+  bool CompareNudgeTypesBitSetToVault(const syncable::ModelTypeBitSet& lhs) {

[akalin, 2011/01/21 19:50:09]

If you write the utility f'n to compare ModelTypeBitSet to ModelTypeMap, you can
invoke that and then compare the two ModelTypeMaps with operator==.

[Nicolas Zea, 2011/01/21 21:57:44]

Done.

+    const SyncSourceInfo::ModelTypeMap& vault_nudge_types =
+        syncer_thread()->vault_.pending_nudge_types_;
+    for (size_t i = syncable::FIRST_REAL_MODEL_TYPE;
+         i < syncable::MODEL_TYPE_COUNT;
+         ++i) {
+      syncable::ModelType type = syncable::ModelTypeFromInt(i);
+      if (lhs[i] && vault_nudge_types.count(type) == 0) {
+        return false;
+      } else if (!lhs[i] && vault_nudge_types.count(type) > 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+
  private:
 
   virtual void OnSyncEngineEvent(const SyncEngineEvent& event) {
     if (event.what_happened == SyncEngineEvent::SYNC_CYCLE_ENDED)
       sync_cycle_ended_event_.Signal();
   }
 
  protected:
   TimeDelta max_wait_time_;
   SyncSessionContext* context_;
@@ skipping 279 matching lines @@
         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, 1));
     bool continue_sync_cycle_param = false;
 
     WaitInterval interval = syncer_thread->CalculatePollingWaitTime(
         0,
         &user_idle_milliseconds_param,
         &continue_sync_cycle_param,
         false);
 
@@ skipping 23 matching lines @@
 
     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, 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 199 matching lines @@
   // The SyncerThread should be waiting for the poll now.  Nudge it to sync
   // immediately (5ms).
   syncable::ModelTypeBitSet model_types;
   model_types[syncable::BOOKMARKS] = true;
 
   // Paused so we can verify the nudge types safely.
   syncer_thread()->RequestPause();
   syncer_thread()->NudgeSyncerWithDataTypes(5,
       SyncerThread::kUnknown,
       model_types);
-  EXPECT_EQ(model_types, syncer_thread()->vault_.pending_nudge_types_);
+  EXPECT_TRUE(CompareNudgeTypesBitSetToVault(model_types));
   syncer_thread()->RequestResume();
 
   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));
-  EXPECT_TRUE(syncer_thread()->vault_.pending_nudge_types_.none());
+  EXPECT_TRUE(syncer_thread()->vault_.pending_nudge_types_.empty());
 }
 
 TEST_F(SyncerThreadWithSyncerTest, NudgeWithDataTypesCoalesced) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
   // We don't want a poll to happen during this test (except the first one).
   PreventThreadFromPolling();
   EXPECT_TRUE(syncer_thread()->Start());
   metadb()->Open();
   syncer_thread()->CreateSyncer(metadb()->name());
   const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
   interceptor.WaitForSyncShare(1, poll_interval + poll_interval);
   EXPECT_EQ(static_cast<unsigned int>(1),
     interceptor.times_sync_occured().size());
 
   // The SyncerThread should be waiting for the poll now.  Nudge it to sync
   // immediately (5ms).
   syncable::ModelTypeBitSet model_types;
   model_types[syncable::BOOKMARKS] = true;
 
   // Paused so we can verify the nudge types safely.
   syncer_thread()->RequestPause();
   syncer_thread()->NudgeSyncerWithDataTypes(100,
       SyncerThread::kUnknown,
       model_types);
-  EXPECT_EQ(model_types, syncer_thread()->vault_.pending_nudge_types_);
+  EXPECT_TRUE(CompareNudgeTypesBitSetToVault(model_types));
 
   model_types[syncable::BOOKMARKS] = false;
   model_types[syncable::AUTOFILL] = true;
   syncer_thread()->NudgeSyncerWithDataTypes(0,
       SyncerThread::kUnknown,
       model_types);
 
   // Reset BOOKMARKS for expectations.
   model_types[syncable::BOOKMARKS] = true;
-  EXPECT_EQ(model_types, syncer_thread()->vault_.pending_nudge_types_);
+  EXPECT_TRUE(CompareNudgeTypesBitSetToVault(model_types));
 
   syncer_thread()->RequestResume();
 
   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));
-  EXPECT_TRUE(syncer_thread()->vault_.pending_nudge_types_.none());
+  EXPECT_TRUE(syncer_thread()->vault_.pending_nudge_types_.empty());
+}
+
+TEST_F(SyncerThreadWithSyncerTest, NudgeWithPayloads) {
+  SyncShareIntercept interceptor;
+  connection()->SetMidCommitObserver(&interceptor);
+  // We don't want a poll to happen during this test (except the first one).
+  PreventThreadFromPolling();
+  EXPECT_TRUE(syncer_thread()->Start());
+  metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
+  const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
+  interceptor.WaitForSyncShare(1, poll_interval + poll_interval);
+  EXPECT_EQ(static_cast<unsigned int>(1),
+            interceptor.times_sync_occured().size());
+
+  // The SyncerThread should be waiting for the poll now.  Nudge it to sync
+  // immediately (5ms).
+  SyncSourceInfo::ModelTypeMap nudge_types;
+  nudge_types[syncable::BOOKMARKS] = "test";
+
+  // Paused so we can verify the nudge types safely.
+  syncer_thread()->RequestPause();
+  syncer_thread()->NudgeSyncerWithPayloads(5,
+      SyncerThread::kUnknown,
+      nudge_types);
+  EXPECT_TRUE(CompareNudgeTypesToVault(nudge_types));
+  syncer_thread()->RequestResume();
+
+  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));
+  EXPECT_TRUE(syncer_thread()->vault_.pending_nudge_types_.empty());
+}
+
+TEST_F(SyncerThreadWithSyncerTest, NudgeWithPayloadsCoalesced) {
+  SyncShareIntercept interceptor;
+  connection()->SetMidCommitObserver(&interceptor);
+  // We don't want a poll to happen during this test (except the first one).
+  PreventThreadFromPolling();
+  EXPECT_TRUE(syncer_thread()->Start());
+  metadb()->Open();
+  syncer_thread()->CreateSyncer(metadb()->name());
+  const TimeDelta poll_interval = TimeDelta::FromMinutes(5);
+  interceptor.WaitForSyncShare(1, poll_interval + poll_interval);
+  EXPECT_EQ(static_cast<unsigned int>(1),
+    interceptor.times_sync_occured().size());
+
+  // The SyncerThread should be waiting for the poll now.  Nudge it to sync
+  // immediately (5ms).
+  SyncSourceInfo::ModelTypeMap nudge_types;
+  nudge_types[syncable::BOOKMARKS] = "books";
+
+  // Paused so we can verify the nudge types safely.
+  syncer_thread()->RequestPause();
+  syncer_thread()->NudgeSyncerWithPayloads(100,
+      SyncerThread::kUnknown,
+      nudge_types);
+  EXPECT_TRUE(CompareNudgeTypesToVault(nudge_types));
+
+  nudge_types.erase(syncable::BOOKMARKS);
+  nudge_types[syncable::AUTOFILL] = "auto";
+  syncer_thread()->NudgeSyncerWithPayloads(0,
+      SyncerThread::kUnknown,
+      nudge_types);
+
+  // Reset BOOKMARKS for expectations.
+  nudge_types[syncable::BOOKMARKS] = "books";
+  EXPECT_TRUE(CompareNudgeTypesToVault(nudge_types));
+
+  syncer_thread()->RequestResume();
+
+  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));
+  EXPECT_TRUE(syncer_thread()->vault_.pending_nudge_types_.empty());
 }
 
 TEST_F(SyncerThreadWithSyncerTest, Throttling) {
   SyncShareIntercept interceptor;
   connection()->SetMidCommitObserver(&interceptor);
   const TimeDelta poll_interval = TimeDelta::FromMilliseconds(10);
   syncer_thread()->SetSyncerShortPollInterval(poll_interval);
 
   EXPECT_TRUE(syncer_thread()->Start());
   metadb()->Open();
@@ skipping 325 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