sync: Report GetUpdate triggers to the server

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 153 matching lines @@
       case SyncEngineEvent::SYNC_CYCLE_BEGIN: // Fall through.
       case SyncEngineEvent::STATUS_CHANGED:
       case SyncEngineEvent::SYNC_CYCLE_ENDED:
         return;
       default:
         CHECK(false) << "Handling unknown error type in unit tests!!";
     }
     saw_syncer_event_ = true;
   }
 
-  SyncSession* MakeSession() {
+  void SyncShareNudge() {
     ModelSafeRoutingInfo info;
     GetModelSafeRoutingInfo(&info);
     ModelTypeInvalidationMap invalidation_map =
         ModelSafeRoutingInfoToInvalidationMap(info, std::string());
-    sessions::SyncSourceInfo source_info(sync_pb::GetUpdatesCallerInfo::UNKNOWN,
-                                         invalidation_map);
-    return new SyncSession(context_.get(), this, source_info);
-  }
+    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.

[tim (not reviewing), 2013/05/07 20:34:13]

"... because they don't target scheduling logic and issue one-off sync
requests", or something to that effect.

[rlarocque, 2013/05/07 21:50:57]

Done.

+    session_.reset(
+        SyncSession::BuildForNudge(context_.get(),
+                                   this,
+                                   source_info,
+                                   &nudge_tracker_));
 
-  void SyncShareNudge() {
-    session_.reset(MakeSession());
     EXPECT_TRUE(syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END));
   }
 
   void SyncShareConfigure() {
-    session_.reset(MakeSession());
+    ModelSafeRoutingInfo info;
+    GetModelSafeRoutingInfo(&info);
+    ModelTypeInvalidationMap invalidation_map =
+        ModelSafeRoutingInfoToInvalidationMap(info, std::string());
+    sessions::SyncSourceInfo source_info(
+        sync_pb::GetUpdatesCallerInfo::RECONFIGURATION,
+        invalidation_map);
+    session_.reset(SyncSession::BuildForNonNudge(context_.get(),
+                                                 this,
+                                                 source_info));
     EXPECT_TRUE(
         syncer_->SyncShare(session_.get(), DOWNLOAD_UPDATES, APPLY_UPDATES));
   }
 
   virtual void SetUp() {
     dir_maker_.SetUp();
     mock_server_.reset(new MockConnectionManager(directory()));
     EnableDatatype(BOOKMARKS);
     EnableDatatype(NIGORI);
     EnableDatatype(PREFERENCES);
@@ skipping 12 matching lines @@
 
     context_.reset(
         new SyncSessionContext(
             mock_server_.get(), directory(), workers,
             &extensions_activity_monitor_, throttled_data_type_tracker_.get(),
             listeners, NULL, &traffic_recorder_,
             true,  // enable keystore encryption
             "fake_invalidator_client_id"));
     context_->set_routing_info(routing_info);
     syncer_ = new Syncer();
-    session_.reset(MakeSession());
 
     syncable::ReadTransaction trans(FROM_HERE, directory());
     syncable::Directory::ChildHandles children;
     directory()->GetChildHandlesById(&trans, trans.root_id(), &children);
     ASSERT_EQ(0u, children.size());
     saw_syncer_event_ = false;
     root_id_ = TestIdFactory::root();
     parent_id_ = ids_.MakeServer("parent id");
     child_id_ = ids_.MakeServer("child id");
     directory()->set_store_birthday(mock_server_->store_birthday());
@@ skipping 326 matching lines @@
   scoped_ptr<SyncSession> session_;
   scoped_ptr<SyncSessionContext> context_;
   bool saw_syncer_event_;
   base::TimeDelta last_short_poll_interval_received_;
   base::TimeDelta last_long_poll_interval_received_;
   base::TimeDelta last_sessions_commit_delay_seconds_;
   scoped_refptr<ModelSafeWorker> worker_;
 
   ModelTypeSet enabled_datatypes_;
   TrafficRecorder traffic_recorder_;
+  sessions::NudgeTracker nudge_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerTest);
 };
 
 TEST_F(SyncerTest, TestCallGatherUnsyncedEntries) {
   {
     Syncer::UnsyncedMetaHandles handles;
     {
       syncable::ReadTransaction trans(FROM_HERE, directory());
       GetUnsyncedEntries(&trans, &handles);
@@ skipping 1655 matching lines @@
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "bob");
     ASSERT_TRUE(entry.good());
     entry.Put(syncable::IS_DIR, true);
     entry.Put(syncable::IS_UNSYNCED, true);
     entry.Put(syncable::SPECIFICS, DefaultBookmarkSpecifics());
   }
 
   mock_server_->SetMidCommitCallback(
       base::Bind(&EntryCreatedInNewFolderTest::CreateFolderInBob,
                  base::Unretained(this)));
-  syncer_->SyncShare(session_.get(), COMMIT, SYNCER_END);
+  SyncShareNudge();
   // We loop until no unsynced handles remain, so we will commit both ids.
   EXPECT_EQ(2u, mock_server_->committed_ids().size());
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry parent_entry(&trans, syncable::GET_BY_ID,
         GetOnlyEntryWithName(&trans, TestIdFactory::root(), "bob"));
     ASSERT_TRUE(parent_entry.good());
 
     Id child_id =
         GetOnlyEntryWithName(&trans, parent_entry.Get(ID), "bob");
@@ skipping 217 matching lines @@
     entry.Put(ID, ids_.FromNumber(20));
     entry.Put(BASE_VERSION, 1);
     entry.Put(SERVER_VERSION, 1);
     entry.Put(SERVER_PARENT_ID, ids_.FromNumber(9999));  // Bad parent.
     entry.Put(IS_UNSYNCED, true);
     entry.Put(IS_UNAPPLIED_UPDATE, true);
     entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(SERVER_SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(IS_DEL, false);
   }
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
+  SyncShareNudge();
   EXPECT_EQ(1, session_->status_controller().TotalNumConflictingItems());
   saw_syncer_event_ = false;
 }
 
 // Original problem synopsis:
 //   Illegal parent
 // Unexpected error during sync if we:
 //   make a new folder bob
 //   wait for sync
 //   make a new folder fred
 //   move bob into fred
 //   remove bob
 //   remove fred
 // if no syncing occured midway, bob will have an illegal parent
 TEST_F(SyncerTest, DeletingEntryInFolder) {
   // This test is a little fake.
   int64 existing_metahandle;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry entry(&trans, CREATE, BOOKMARKS, trans.root_id(), "existing");
     ASSERT_TRUE(entry.good());
     entry.Put(IS_DIR, true);
     entry.Put(SPECIFICS, DefaultBookmarkSpecifics());
     entry.Put(IS_UNSYNCED, true);
     existing_metahandle = entry.Get(META_HANDLE);
   }
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
+  SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(&trans, CREATE, BOOKMARKS, trans.root_id(), "new");
     ASSERT_TRUE(newfolder.good());
     newfolder.Put(IS_DIR, true);
     newfolder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     newfolder.Put(IS_UNSYNCED, true);
 
     MutableEntry existing(&trans, GET_BY_HANDLE, existing_metahandle);
     ASSERT_TRUE(existing.good());
     existing.Put(PARENT_ID, newfolder.Get(ID));
     existing.Put(IS_UNSYNCED, true);
     EXPECT_TRUE(existing.Get(ID).ServerKnows());
 
     newfolder.Put(IS_DEL, true);
     existing.Put(IS_DEL, true);
   }
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
+  SyncShareNudge();
   EXPECT_EQ(0, status().num_server_conflicts());
 }
 
 TEST_F(SyncerTest, DeletingEntryWithLocalEdits) {
   int64 newfolder_metahandle;
 
   mock_server_->AddUpdateDirectory(1, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-1");
   SyncShareNudge();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, directory());
     MutableEntry newfolder(
         &trans, CREATE, BOOKMARKS, ids_.FromNumber(1), "local");
     ASSERT_TRUE(newfolder.good());
     newfolder.Put(IS_UNSYNCED, true);
     newfolder.Put(IS_DIR, true);
     newfolder.Put(SPECIFICS, DefaultBookmarkSpecifics());
     newfolder_metahandle = newfolder.Get(META_HANDLE);
   }
   mock_server_->AddUpdateDirectory(1, 0, "bob", 2, 20,
                                    foreign_cache_guid(), "-1");
   mock_server_->SetLastUpdateDeleted();
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, APPLY_UPDATES);
+  SyncShareConfigure();
   {
     syncable::ReadTransaction trans(FROM_HERE, directory());
     Entry entry(&trans, syncable::GET_BY_HANDLE, newfolder_metahandle);
     ASSERT_TRUE(entry.good());
   }
 }
 
 TEST_F(SyncerTest, FolderSwapUpdate) {
   mock_server_->AddUpdateDirectory(7801, 0, "bob", 1, 10,
                                    foreign_cache_guid(), "-7801");
@@ skipping 634 matching lines @@
   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);
-  syncer_->SyncShare(session_.get(), SYNCER_BEGIN, SYNCER_END);
+  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);
   }
 
@@ skipping 1574 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