sync: use progress markers instead of timestamps during GetUpdates

chrome/test/sync/engine/mock_connection_manager.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.
 //
 // Mock ServerConnectionManager class for use in client regression tests.
 
 #include "chrome/test/sync/engine/mock_connection_manager.h"
 
 #include "chrome/browser/sync/engine/syncer_proto_util.h"
 #include "chrome/browser/sync/protocol/bookmark_specifics.pb.h"
@@ skipping 34 matching lines @@
       directory_manager_(dirmgr),
       directory_name_(name),
       mid_commit_observer_(NULL),
       throttling_(false),
       fail_with_auth_invalid_(false),
       fail_non_periodic_get_updates_(false),
       client_command_(NULL),
       next_position_in_parent_(2),
       use_legacy_bookmarks_protocol_(false),
       num_get_updates_requests_(0) {
-    server_reachable_ = true;
+  server_reachable_ = true;
+  SetNewTimestamp(0);
 };
 
 MockConnectionManager::~MockConnectionManager() {
+  EXPECT_TRUE(update_queue_.empty()) << "Unfetched updates.";
 }
 
 void MockConnectionManager::SetCommitTimeRename(string prepend) {
   commit_time_rename_prepended_string_ = prepend;
 }
 
 void MockConnectionManager::SetMidCommitCallback(Callback0::Type* callback) {
   mid_commit_callback_.reset(callback);
 }
 
@@ skipping 92 matching lines @@
 }
 
 bool MockConnectionManager::IsServerReachable() {
   return true;
 }
 
 bool MockConnectionManager::IsUserAuthenticated() {
   return true;
 }
 
-void MockConnectionManager::ResetUpdates() {
-  updates_.Clear();
+sync_pb::GetUpdatesResponse* MockConnectionManager::GetUpdateResponse() {
+  if (update_queue_.empty()) {
+    NextUpdateBatch();
+  }
+  return &update_queue_.back();
 }
 
 void MockConnectionManager::AddDefaultBookmarkData(sync_pb::SyncEntity* entity,
                                                    bool is_folder) {
   if (use_legacy_bookmarks_protocol_) {
     sync_pb::SyncEntity_BookmarkData* data = entity->mutable_bookmarkdata();
     data->set_bookmark_folder(is_folder);
 
     if (!is_folder) {
       data->set_bookmark_url("http://google.com");
@@ skipping 32 matching lines @@
   return AddUpdateBookmark(TestIdFactory::FromNumber(id),
                            TestIdFactory::FromNumber(parent_id),
                            name,
                            version,
                            sync_ts);
 }
 
 SyncEntity* MockConnectionManager::AddUpdateFull(string id, string parent_id,
                                                  string name, int64 version,
                                                  int64 sync_ts, bool is_dir) {
-  SyncEntity* ent = updates_.add_entries();
+  SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id);
   ent->set_parent_id_string(parent_id);
   ent->set_non_unique_name(name);
   ent->set_name(name);
   ent->set_version(version);
   ent->set_sync_timestamp(sync_ts);
   ent->set_mtime(sync_ts);
   ent->set_ctime(1);
   ent->set_position_in_parent(GeneratePositionInParent());
   AddDefaultBookmarkData(ent, is_dir);
@@ skipping 19 matching lines @@
 SyncEntity* MockConnectionManager::AddUpdateFromLastCommit() {
   EXPECT_EQ(1, last_sent_commit().entries_size());
   EXPECT_EQ(1, last_commit_response().entryresponse_size());
   EXPECT_EQ(CommitResponse::SUCCESS,
       last_commit_response().entryresponse(0).response_type());
 
   if (last_sent_commit().entries(0).deleted()) {
     AddUpdateTombstone(syncable::Id::CreateFromServerId(
         last_sent_commit().entries(0).id_string()));
   } else {
-    SyncEntity* ent = updates_.add_entries();
+    SyncEntity* ent = GetUpdateResponse()->add_entries();
     ent->CopyFrom(last_sent_commit().entries(0));
     ent->clear_insert_after_item_id();
     ent->clear_old_parent_id();
     ent->set_position_in_parent(
         last_commit_response().entryresponse(0).position_in_parent());
     ent->set_version(
         last_commit_response().entryresponse(0).version());
     ent->set_id_string(
         last_commit_response().entryresponse(0).id_string());
     // Tests don't currently care about the following:
     // originator_cache_guid, originator_client_item_id, parent_id_string,
     // name, non_unique_name.
   }
   return GetMutableLastUpdate();
 }
 
 void MockConnectionManager::AddUpdateTombstone(const syncable::Id& id) {
   // Tombstones have only the ID set and dummy values for the required fields.
-  SyncEntity* ent = updates_.add_entries();
+  SyncEntity* ent = GetUpdateResponse()->add_entries();
   ent->set_id_string(id.GetServerId());
   ent->set_version(0);
   ent->set_name("");
   ent->set_deleted(true);
 }
 
 void MockConnectionManager::SetLastUpdateDeleted() {
   // Tombstones have only the ID set.  Wipe anything else.
   string id_string = GetMutableLastUpdate()->id_string();
-  updates_.mutable_entries()->RemoveLast();
+  GetUpdateResponse()->mutable_entries()->RemoveLast();
   AddUpdateTombstone(syncable::Id::CreateFromServerId(id_string));
 }
 
 void MockConnectionManager::SetLastUpdateOriginatorFields(
     const string& client_id,
     const string& entry_id) {
   GetMutableLastUpdate()->set_originator_cache_guid(client_id);
   GetMutableLastUpdate()->set_originator_client_item_id(entry_id);
 }
 
 void MockConnectionManager::SetLastUpdateServerTag(const string& tag) {
   GetMutableLastUpdate()->set_server_defined_unique_tag(tag);
 }
 
 void MockConnectionManager::SetLastUpdateClientTag(const string& tag) {
   GetMutableLastUpdate()->set_client_defined_unique_tag(tag);
 }
 
 void MockConnectionManager::SetLastUpdatePosition(int64 server_position) {
   GetMutableLastUpdate()->set_position_in_parent(server_position);
 }
 
-void MockConnectionManager::SetNewTimestamp(int64 ts) {
-  updates_.set_new_timestamp(ts);
+void MockConnectionManager::SetNewTimestamp(int ts) {
+  next_token_ = base::StringPrintf("mock connection ts = %d", ts);
+  ApplyToken();
+}
+
+void MockConnectionManager::ApplyToken() {
+  if (!update_queue_.empty()) {
+    GetUpdateResponse()->clear_new_progress_marker();
+    sync_pb::DataTypeProgressMarker* new_marker =
+        GetUpdateResponse()->add_new_progress_marker();
+    new_marker->set_data_type_id(-1);  // Invalid -- clients shouldn't see.
+    new_marker->set_token(next_token_);
+  }
 }
 
 void MockConnectionManager::SetChangesRemaining(int64 timestamp) {
-  updates_.set_changes_remaining(timestamp);
+  GetUpdateResponse()->set_changes_remaining(timestamp);
 }
 
 void MockConnectionManager::ProcessGetUpdates(ClientToServerMessage* csm,
     ClientToServerResponse* response) {
   CHECK(csm->has_get_updates());
   ASSERT_EQ(csm->message_contents(), ClientToServerMessage::GET_UPDATES);
   const GetUpdatesMessage& gu = csm->get_updates();
   num_get_updates_requests_++;
-  EXPECT_TRUE(gu.has_from_timestamp());
+  EXPECT_FALSE(gu.has_from_timestamp());
+  EXPECT_FALSE(gu.has_requested_types());
+
   if (fail_non_periodic_get_updates_) {
     EXPECT_EQ(sync_pb::GetUpdatesCallerInfo::PERIODIC,
               gu.caller_info().source());
   }
 
   // Verify that the GetUpdates filter sent by the Syncer matches the test
   // expectation.
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType model_type = syncable::ModelTypeFromInt(i);
     EXPECT_EQ(expected_filter_[i],
-        IsModelTypePresentInSpecifics(gu.requested_types(), model_type))
+      IsModelTypePresentInSpecifics(gu.from_progress_marker(), model_type))
         << "Syncer requested_types differs from test expectation.";
   }
 
   // Verify that the items we're about to send back to the client are of
   // the types requested by the client.  If this fails, it probably indicates
   // a test bug.
   EXPECT_TRUE(gu.fetch_folders());
-  EXPECT_TRUE(gu.has_requested_types());
-  for (int i = 0; i < updates_.entries_size(); ++i) {
-    if (!updates_.entries(i).deleted()) {
-      ModelType entry_type = syncable::GetModelType(updates_.entries(i));
+  EXPECT_FALSE(gu.has_requested_types());
+  if (update_queue_.empty()) {
+    GetUpdateResponse();
+  }
+  sync_pb::GetUpdatesResponse* updates = &update_queue_.front();
+  for (int i = 0; i < updates->entries_size(); ++i) {
+    if (!updates->entries(i).deleted()) {
+      ModelType entry_type = syncable::GetModelType(updates->entries(i));
       EXPECT_TRUE(
-          IsModelTypePresentInSpecifics(gu.requested_types(), entry_type))
+        IsModelTypePresentInSpecifics(gu.from_progress_marker(), entry_type))
           << "Syncer did not request updates being provided by the test.";
     }
   }
 
-  // TODO(sync): filter results dependant on timestamp? or check limits?
-  response->mutable_get_updates()->CopyFrom(updates_);
-  ResetUpdates();
+  response->mutable_get_updates()->CopyFrom(*updates);
+
+  // Set appropriate progress markers, overriding the value squirreled
+  // away by ApplyToken().
+  std::string token = response->get_updates().new_progress_marker(0).token();
+  response->mutable_get_updates()->clear_new_progress_marker();
+  for (int i = 0; i < gu.from_progress_marker_size(); ++i) {
+    if (gu.from_progress_marker(i).token() != token) {
+      sync_pb::DataTypeProgressMarker* new_marker =
+          response->mutable_get_updates()->add_new_progress_marker();
+      new_marker->set_data_type_id(gu.from_progress_marker(i).data_type_id());
+      new_marker->set_token(token);
+    }
+  }
+
+  update_queue_.pop_front();
 }
 
 void MockConnectionManager::SetClearUserDataResponseStatus(
   sync_pb::ClientToServerResponse::ErrorType errortype ) {
   // Note: this is not a thread-safe set, ok for now.  NOT ok if tests
   // run the syncer on the background thread while this method is called.
   clear_user_data_response_errortype_ = errortype;
 }
 
 void MockConnectionManager::ProcessClearData(ClientToServerMessage* csm,
@@ skipping 105 matching lines @@
 }
 
 SyncEntity* MockConnectionManager::AddUpdateBookmark(
     syncable::Id id, syncable::Id parent_id, string name, int64 version,
     int64 sync_ts) {
   return AddUpdateBookmark(id.GetServerId(), parent_id.GetServerId(),
                            name, version, sync_ts);
 }
 
 SyncEntity* MockConnectionManager::GetMutableLastUpdate() {
-  EXPECT_TRUE(updates_.entries_size() > 0);
-  return updates_.mutable_entries()->Mutable(updates_.entries_size() - 1);
+  sync_pb::GetUpdatesResponse* updates = GetUpdateResponse();
+  EXPECT_TRUE(updates->entries_size() > 0);
+  return updates->mutable_entries()->Mutable(updates->entries_size() - 1);
+}
+
+void MockConnectionManager::NextUpdateBatch() {
+  update_queue_.push_back(sync_pb::GetUpdatesResponse::default_instance());
+  SetChangesRemaining(0);
+  ApplyToken();
 }
 
 const CommitMessage& MockConnectionManager::last_sent_commit() const {
   EXPECT_TRUE(!commit_messages_.empty());
   return *commit_messages_->back();
 }
 
 const CommitResponse& MockConnectionManager::last_commit_response() const {
   EXPECT_TRUE(!commit_responses_.empty());
   return *commit_responses_->back();
@@ skipping 17 matching lines @@
 
 void MockConnectionManager::StopFailingWithAuthInvalid(
     ResponseCodeOverrideRequestor* visitor) {
   AutoLock lock(response_code_override_lock_);
   fail_with_auth_invalid_ = false;
   if (visitor)
     visitor->OnOverrideComplete();
 }
 
 bool MockConnectionManager::IsModelTypePresentInSpecifics(
-    const sync_pb::EntitySpecifics& filter, syncable::ModelType value) {
-  // This implementation is a little contorted; it's done this way
-  // to avoid having to switch on the ModelType.  We're basically doing
-  // the protobuf equivalent of ((value & filter) == filter).
-  sync_pb::EntitySpecifics value_filter;
-  syncable::AddDefaultExtensionValue(value, &value_filter);
-  value_filter.MergeFrom(filter);
-  return value_filter.SerializeAsString() == filter.SerializeAsString();
+    const google::protobuf::RepeatedPtrField<
+        sync_pb::DataTypeProgressMarker>& filter,
+    syncable::ModelType value) {
+  int data_type_id = syncable::GetExtensionFieldNumberFromModelType(value);
+  for (int i = 0; i < filter.size(); ++i) {
+    if (filter.Get(i).data_type_id() == data_type_id) {
+      return true;
+    }
+  }
+  return false;
 }
 
 void MockConnectionManager::SetServerReachable() {
   server_status_ = HttpResponse::SERVER_CONNECTION_OK;
   server_reachable_ = true;
   browser_sync::ServerConnectionEvent event = {
     browser_sync::ServerConnectionEvent::STATUS_CHANGED,
     server_status_,
     server_reachable_ };
   channel_->NotifyListeners(event);
 }
 
 void MockConnectionManager::SetServerNotReachable() {
   server_status_ = HttpResponse::CONNECTION_UNAVAILABLE;
   server_reachable_ = false;
   browser_sync::ServerConnectionEvent event = {
     browser_sync::ServerConnectionEvent::STATUS_CHANGED,
     server_status_,
     server_reachable_ };
   channel_->NotifyListeners(event);
 }