sync: use progress markers instead of timestamps during GetUpdates

chrome/test/sync/engine/mock_connection_manager.h

 // Copyright (c) 2010 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 unit tests.
 
 #ifndef CHROME_TEST_SYNC_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #define CHROME_TEST_SYNC_ENGINE_MOCK_CONNECTION_MANAGER_H_
 #pragma once
 
@@ skipping 40 matching lines @@
   virtual bool IsUserAuthenticated();
 
   // Control of commit response.
   void SetMidCommitCallback(Callback0::Type* callback);
   void SetMidCommitObserver(MidCommitObserver* observer);
 
   // Set this if you want commit to perform commit time rename. Will request
   // that the client renames all commited entries, prepending this string.
   void SetCommitTimeRename(string prepend);
 
-  // Control of get updates response. All updates set will only be returned
-  // once. This mock object doesn't simulate a changelist, it simulates server
-  // responses.
-  void ResetUpdates();
-
   // Generic versions of AddUpdate functions. Tests using these function should
   // compile for both the int64 and string id based versions of the server.
   // The SyncEntity returned is only valid until the Sync is completed
   // (e.g. with SyncShare.) It allows to add further entity properties before
   // sync, using SetLastXXX() methods and/or GetMutableLastUpdate().
   sync_pb::SyncEntity* AddUpdateDirectory(syncable::Id id,
                                           syncable::Id parent_id,
                                           string name,
                                           int64 version,
                                           int64 sync_ts);
@@ skipping 34 matching lines @@
   // additional information beyond the deletion, and no specifics.
   // The server may send the originator fields.
   void AddUpdateTombstone(const syncable::Id& id);
 
   void SetLastUpdateDeleted();
   void SetLastUpdateServerTag(const string& tag);
   void SetLastUpdateClientTag(const string& tag);
   void SetLastUpdateOriginatorFields(const string& client_id,
                                      const string& entry_id);
   void SetLastUpdatePosition(int64 position_in_parent);
-  void SetNewTimestamp(int64 ts);
-  void SetChangesRemaining(int64 timestamp);
+  void SetNewTimestamp(int ts);
+  void SetChangesRemaining(int64 count);
+
+  // Add a new batch of updates after the current one.  Allows multiple
+  // GetUpdates responses to be buffered up, since the syncer may
+  // issue multiple requests during a sync cycle.
+  void NextUpdateBatch();
 
   // For AUTHENTICATE responses.
   void SetAuthenticationResponseInfo(const std::string& valid_auth_token,
                                      const std::string& user_display_name,
                                      const std::string& user_display_email,
                                      const std::string& user_obfuscated_id);
 
   void FailNextPostBufferToPathCall() { fail_next_postbuffer_ = true; }
 
   void SetClearUserDataResponseStatus(
@@ skipping 116 matching lines @@
   // Determine if one entry in a commit should be rejected with a conflict.
   bool ShouldConflictThisCommit();
 
   // Generate a numeric position_in_parent value.  We use a global counter
   // that only decreases; this simulates new objects always being added to the
   // front of the ordering.
   int64 GeneratePositionInParent() {
     return next_position_in_parent_--;
   }
 
-  // Determine whether an EntitySpecifics filter (like that sent in
-  // GetUpdates.requested_types) indicates that a particular ModelType
+  // Get a mutable update response which will eventually be returned to the
+  // client.
+  sync_pb::GetUpdatesResponse* GetUpdateResponse();
+  void ApplyToken();
+
+  // Determine whether an progress marker array (like that sent in
+  // GetUpdates.from_progress_marker) indicates that a particular ModelType
   // should be included.
-  bool IsModelTypePresentInSpecifics(const sync_pb::EntitySpecifics& filter,
+  bool IsModelTypePresentInSpecifics(
+      const google::protobuf::RepeatedPtrField<
+          sync_pb::DataTypeProgressMarker>& filter,
       syncable::ModelType value);
 
   // All IDs that have been committed.
   std::vector<syncable::Id> committed_ids_;
 
   // Control of when/if we return conflicts.
   bool conflict_all_commits_;
   int conflict_n_commits_;
 
   // Commit messages we've sent, and responses we've returned.
@@ skipping 11 matching lines @@
   string commit_time_rename_prepended_string_;
 
   // Fail on the next call to PostBufferToPath().
   bool fail_next_postbuffer_;
 
   // Our directory.
   syncable::DirectoryManager* directory_manager_;
   std::string directory_name_;
 
   // The updates we'll return to the next request.
-  sync_pb::GetUpdatesResponse updates_;
+  std::list<sync_pb::GetUpdatesResponse> update_queue_;
   scoped_ptr<Callback0::Type> mid_commit_callback_;
   MidCommitObserver* mid_commit_observer_;
 
   // The clear data response we'll return in the next response
   sync_pb::ClientToServerResponse::ErrorType
       clear_user_data_response_errortype_;
 
   // The AUTHENTICATE response we'll return for auth requests.
   sync_pb::AuthenticateResponse auth_response_;
   // What we use to determine if we should return SUCCESS or BAD_AUTH_TOKEN.
@@ skipping 20 matching lines @@
 
   // The default is to use the newer sync_pb::BookmarkSpecifics-style protocol.
   // If this option is set to true, then the MockConnectionManager will
   // use the older sync_pb::SyncEntity_BookmarkData-style protocol.
   bool use_legacy_bookmarks_protocol_;
 
   std::bitset<syncable::MODEL_TYPE_COUNT> expected_filter_;
 
   int num_get_updates_requests_;
 
+  std::string next_token_;
+
   sync_pb::ClientToServerMessage last_request_;
 
   DISALLOW_COPY_AND_ASSIGN(MockConnectionManager);
 };
 
 #endif  // CHROME_TEST_SYNC_ENGINE_MOCK_CONNECTION_MANAGER_H_