Experimental functionize patch

sync/engine/syncer_unittest.cc

 // Copyright 2012 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.
 //
 // Syncer unit tests. Unfortunately a lot of these tests
 // are outdated and need to be reworked and updated.
 
 #include <algorithm>
 #include <limits>
 #include <list>
@@ skipping 170 matching lines @@
   }
 
   void SyncShareNudge() {
     ModelSafeRoutingInfo info;
     GetModelSafeRoutingInfo(&info);
     ModelTypeInvalidationMap invalidation_map =
         ModelSafeRoutingInfoToInvalidationMap(info, std::string());
     sessions::SyncSourceInfo source_info(
         sync_pb::GetUpdatesCallerInfo::LOCAL,
         invalidation_map);
-    // Use our dummy nudge tracker.  These tests won't notice that it hasn't
-    // been tracking anything because the server is mocked out and ignores most
-    // of the content of requests sent by the client.
-    session_.reset(
-        SyncSession::BuildForNudge(context_.get(),
-                                   this,
-                                   source_info,
-                                   &nudge_tracker_));
+    session_.reset(SyncSession::Build(context_.get(), this, source_info));
 
-    EXPECT_TRUE(syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END));
+    // Pretend we've seen a local change, to make the nudge_tracker look normal.
+    nudge_tracker_.RecordLocalChange(ModelTypeSet(BOOKMARKS));
+
+    EXPECT_TRUE(
+        syncer_->NormalSyncShare(
+            session_.get(),
+            GetRoutingInfoTypes(context_->routing_info()),
+            nudge_tracker_));
   }
 
   void SyncShareConfigure() {
     ModelSafeRoutingInfo info;
     GetModelSafeRoutingInfo(&info);
     ModelTypeInvalidationMap invalidation_map =
         ModelSafeRoutingInfoToInvalidationMap(info, std::string());
     sessions::SyncSourceInfo source_info(
         sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
         invalidation_map);
     session_.reset(SyncSession::Build(context_.get(),
                                       this,
                                       source_info));
-    EXPECT_TRUE(
-        syncer_->SyncShare(session_.get(), DOWNLOAD_UPDATES, APPLY_UPDATES));
+    EXPECT_TRUE(syncer_->ConfigureSyncShare(
+            session_.get(),
+            GetRoutingInfoTypes(context_->routing_info())));
   }
 
   virtual void SetUp() {
     dir_maker_.SetUp();
     mock_server_.reset(new MockConnectionManager(directory()));
     EnableDatatype(BOOKMARKS);
     EnableDatatype(NIGORI);
     EnableDatatype(PREFERENCES);
     EnableDatatype(NIGORI);
     worker_ = new FakeModelWorker(GROUP_PASSIVE);
@@ skipping 71 matching lines @@
     EXPECT_FALSE(client_status.hierarchy_conflict_detected());
   }
 
   void VerifyHierarchyConflictsUnspecified(
       const sync_pb::ClientToServerMessage& message) {
     // Our request should have neither confirmed nor denied hierarchy conflicts.
     const sync_pb::ClientStatus& client_status = message.client_status();
     EXPECT_FALSE(client_status.has_hierarchy_conflict_detected());
   }
 
-  void SyncRepeatedlyToTriggerConflictResolution(SyncSession* session) {
-    // We should trigger after less than 6 syncs, but extra does no harm.
-    for (int i = 0 ; i < 6 ; ++i)
-      syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
-  }
-  void SyncRepeatedlyToTriggerStuckSignal(SyncSession* session) {
-    // We should trigger after less than 10 syncs, but we want to avoid brittle
-    // tests.
-    for (int i = 0 ; i < 12 ; ++i)
-      syncer_->SyncShare(session, SYNCER_BEGIN, SYNCER_END);
-  }
   sync_pb::EntitySpecifics DefaultBookmarkSpecifics() {
     sync_pb::EntitySpecifics result;
     AddDefaultFieldValue(BOOKMARKS, &result);
     return result;
   }
 
   sync_pb::EntitySpecifics DefaultPreferencesSpecifics() {
     sync_pb::EntitySpecifics result;
     AddDefaultFieldValue(PREFERENCES, &result);
     return result;
@@ skipping 87 matching lines @@
     }
   }
 
   void DoTruncationTest(const vector<int64>& unsynced_handle_view,
                         const vector<syncable::Id>& expected_id_order) {
     for (size_t limit = expected_id_order.size() + 2; limit > 0; --limit) {
       WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
 
       ModelSafeRoutingInfo routes;
       GetModelSafeRoutingInfo(&routes);
+      ModelTypeSet types = GetRoutingInfoTypes(routes);
       sessions::OrderedCommitSet output_set(routes);
-      GetCommitIdsCommand command(&wtrans, limit, &output_set);
+      GetCommitIdsCommand command(&wtrans, types, limit, &output_set);
       std::set<int64> ready_unsynced_set;
-      command.FilterUnreadyEntries(&wtrans, ModelTypeSet(),
+      command.FilterUnreadyEntries(&wtrans, types,
                                    ModelTypeSet(), false,
                                    unsynced_handle_view, &ready_unsynced_set);
       command.BuildCommitIds(&wtrans, routes, ready_unsynced_set);
       size_t truncated_size = std::min(limit, expected_id_order.size());
       ASSERT_EQ(truncated_size, output_set.Size());
       for (size_t i = 0; i < truncated_size; ++i) {
         ASSERT_EQ(expected_id_order[i], output_set.GetCommitIdAt(i))
             << "At index " << i << " with batch size limited to " << limit;
       }
       sessions::OrderedCommitSet::Projection proj;
@@ skipping 217 matching lines @@
   // appropriately.
   expected_order.push_back(ids_.MakeServer("x"));
   expected_order.push_back(ids_.MakeLocal("b"));
   expected_order.push_back(ids_.MakeLocal("c"));
   expected_order.push_back(ids_.MakeLocal("d"));
   expected_order.push_back(ids_.MakeLocal("e"));
   expected_order.push_back(ids_.MakeLocal("j"));
   DoTruncationTest(unsynced_handle_view, expected_order);
 }
 
-// TODO(rlarocque): re-enable this test.
-TEST_F(SyncerTest, DISABLED_GetCommitIdsFiltersThrottledEntries) {
+TEST_F(SyncerTest, GetCommitIdsFiltersThrottledEntries) {
   const ModelTypeSet throttled_types(BOOKMARKS);
   sync_pb::EntitySpecifics bookmark_data;
   AddDefaultFieldValue(BOOKMARKS, &bookmark_data);
 
   mock_server_->AddUpdateDirectory(1, 0, "A", 10, 10,
                                    foreign_cache_guid(), "-1");
   SyncShareNudge();
 
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, directory());
     MutableEntry A(&wtrans, GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(A.good());
     A.Put(IS_UNSYNCED, true);
     A.Put(SPECIFICS, bookmark_data);
     A.Put(NON_UNIQUE_NAME, "bookmark");
   }
 
-  // Now set the throttled types.
-  // context_->throttled_data_type_tracker()->SetUnthrottleTime(
-  //     throttled_types,
-  //     base::TimeTicks::Now() + base::TimeDelta::FromSeconds(1200));
-  SyncShareNudge();
+  // Now sync without enabling bookmarks.
+  syncer_->NormalSyncShare(
+      session_.get(),
+      Difference(GetRoutingInfoTypes(context_->routing_info()),
+                 ModelTypeSet(BOOKMARKS)),
+      nudge_tracker_);
 
   {
     // Nothing should have been committed as bookmarks is throttled.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_TRUE(entryA.Get(IS_UNSYNCED));
   }
 
-  // Now unthrottle.
-  // context_->throttled_data_type_tracker()->SetUnthrottleTime(
-  //    throttled_types,
-  //    base::TimeTicks::Now() - base::TimeDelta::FromSeconds(1200));
+  // Sync again with bookmarks enabled.
+  syncer_->NormalSyncShare(
+      session_.get(),
+      GetRoutingInfoTypes(context_->routing_info()),
+      nudge_tracker_);
   SyncShareNudge();
   {
     // It should have been committed.
     syncable::ReadTransaction rtrans(FROM_HERE, directory());
     Entry entryA(&rtrans, syncable::GET_BY_ID, ids_.FromNumber(1));
     ASSERT_TRUE(entryA.good());
     EXPECT_FALSE(entryA.Get(IS_UNSYNCED));
   }
 }
 
@@ skipping 2493 matching lines @@
                                   local_cache_guid(), "-1");
   SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(
         &trans, CREATE, BOOKMARKS, trans.root_id(), "Copy of base");
     WriteTestDataToEntry(&trans, &entry);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   local_cache_guid(), "-1");
-  SyncRepeatedlyToTriggerConflictResolution(session_.get());
+  SyncShareNudge();
 }
 
 // In this test a long changelog contains a child at the start of the changelog
 // and a parent at the end. While these updates are in progress the client would
 // appear stuck.
 TEST_F(SyncerTest, LongChangelistWithApplicationConflict) {
   const int depth = 400;
   syncable::Id folder_id = ids_.FromNumber(1);
 
   // First we an item in a folder in the root. However the folder won't come
   // till much later.
   syncable::Id stuck_entry_id = TestIdFactory::FromNumber(99999);
   mock_server_->AddUpdateDirectory(stuck_entry_id,
       folder_id, "stuck", 1, 1,
       foreign_cache_guid(), "-99999");
   mock_server_->SetChangesRemaining(depth - 1);
   SyncShareNudge();
 
   // Buffer up a very long series of downloads.
   // We should never be stuck (conflict resolution shouldn't
   // kick in so long as we're making forward progress).
   for (int i = 0; i < depth; i++) {
     mock_server_->NextUpdateBatch();
     mock_server_->SetNewTimestamp(i + 1);
     mock_server_->SetChangesRemaining(depth - i);
   }
 
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
+  SyncShareNudge();
 
   // Ensure our folder hasn't somehow applied.
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry child(&trans, GET_BY_ID, stuck_entry_id);
     EXPECT_TRUE(child.good());
     EXPECT_TRUE(child.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(child.Get(IS_DEL));
     EXPECT_FALSE(child.Get(IS_UNSYNCED));
   }
@@ skipping 26 matching lines @@
   SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, GET_BY_ID, ids_.FromNumber(2));
     ASSERT_TRUE(entry.good());
     EXPECT_TRUE(entry.Put(NON_UNIQUE_NAME, "Copy of base"));
     entry.Put(IS_UNSYNCED, true);
   }
   mock_server_->AddUpdateBookmark(1, 0, "Copy of base", 50, 50,
                                   foreign_cache_guid(), "-1");
-  SyncRepeatedlyToTriggerConflictResolution(session_.get());
+  SyncShareNudge();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry1(&trans, GET_BY_ID, ids_.FromNumber(1));
     EXPECT_FALSE(entry1.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_FALSE(entry1.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry1.Get(IS_DEL));
     Entry entry2(&trans, GET_BY_ID, ids_.FromNumber(2));
     EXPECT_FALSE(entry2.Get(IS_UNAPPLIED_UPDATE));
     EXPECT_TRUE(entry2.Get(IS_UNSYNCED));
     EXPECT_FALSE(entry2.Get(IS_DEL));
@@ skipping 1524 matching lines @@
     EXPECT_EQ("xyz", final_monitor_records["xyz"].extension_id);
     EXPECT_EQ(2049U, final_monitor_records["ABC"].bookmark_write_count);
     EXPECT_EQ(4U,    final_monitor_records["xyz"].bookmark_write_count);
   } else {
     EXPECT_TRUE(final_monitor_records.empty())
         << "Should not restore records after successful bookmark commit.";
   }
 }
 
 }  // namespace syncer