sync: use progress markers instead of timestamps during GetUpdates

chrome/browser/sync/syncable/syncable.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.
 
 #ifndef CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #define CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_
 #pragma once
 
 #include <algorithm>
 #include <bitset>
@@ skipping 539 matching lines @@
 class LessField;
 class LessEntryMetaHandles {
  public:
   inline bool operator()(const syncable::EntryKernel& a,
                          const syncable::EntryKernel& b) const {
     return a.ref(META_HANDLE) < b.ref(META_HANDLE);
   }
 };
 typedef std::set<EntryKernel, LessEntryMetaHandles> OriginalEntries;
 
-// Represents one or more model types sharing an update timestamp, as is
-// the case with a GetUpdates request.
-struct MultiTypeTimeStamp {
-  syncable::ModelTypeBitSet data_types;
-  int64 timestamp;
-};
-
 // a WriteTransaction has a writer tag describing which body of code is doing
 // the write. This is defined up here since DirectoryChangeEvent also contains
 // one.
 enum WriterTag {
   INVALID,
   SYNCER,
   AUTHWATCHER,
   UNITTEST,
   VACUUM_AFTER_SAVE,
   PURGE_ENTRIES,
@@ skipping 82 matching lines @@
   class EventListenerHookup;
 
   // Various data that the Directory::Kernel we are backing (persisting data
   // for) needs saved across runs of the application.
   struct PersistedKernelInfo {
     AutofillMigrationDebugInfo autofill_migration_debug_info;
 
     PersistedKernelInfo();
     ~PersistedKernelInfo();
 
+    void reset_download_progress(ModelType model_type);

[tim (not reviewing), 2011/01/11 19:14:23]

comment? Just seems out of place without context...

[ncarter (slow), 2011/01/13 00:06:13]

Done.

+
     // Last sync timestamp fetched from the server.
-    int64 last_download_timestamp[MODEL_TYPE_COUNT];
+    sync_pb::DataTypeProgressMarker download_progress[MODEL_TYPE_COUNT];
     // true iff we ever reached the end of the changelog.
     ModelTypeBitSet initial_sync_ended;
     // The store birthday we were given by the server. Contents are opaque to
     // the client.
     std::string store_birthday;
     // The next local ID that has not been used with this cache-GUID.
     int64 next_id;
     // The persisted notification state.
     std::string notification_state;
 
@@ skipping 39 matching lines @@
   void Close();
 
   int64 NextMetahandle();
   // Always returns a negative id.  Positive client ids are generated
   // by the server only.
   Id NextId();
 
   const FilePath& file_path() const { return kernel_->db_path; }
   bool good() const { return NULL != store_; }
 
-  // The download timestamp is an index into the server's list of changes for
-  // an account.  We keep this for each datatype.  It doesn't actually map
-  // to any time scale; its name is an historical artifact.
-  int64 last_download_timestamp(ModelType type) const;
-  virtual void set_last_download_timestamp(ModelType type, int64 value);
-
-  // Find the model type or model types which have the least timestamp, and
-  // return them along with the types having that timestamp.  This is done
-  // with the intent of sequencing GetUpdates requests in an efficient way:
-  // bundling together requests that have the same timestamp, and requesting
-  // the oldest such bundles first in hopes that they might catch up to
-  // (and thus be merged with) the newer bundles.
-  MultiTypeTimeStamp GetTypesWithOldestLastDownloadTimestamp(
-      ModelTypeBitSet enabled_types) {
-    MultiTypeTimeStamp result;
-    result.timestamp = std::numeric_limits<int64>::max();
-    for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
-      if (!enabled_types[i])
-        continue;
-      int64 stamp = last_download_timestamp(ModelTypeFromInt(i));
-      if (stamp < result.timestamp) {
-        result.data_types.reset();
-        result.timestamp = stamp;
-      }
-      if (stamp == result.timestamp)
-        result.data_types.set(i);
-    }
-    return result;
-  }
+  // The download progress is an opaque token provided by the sync server
+  // to indicate the continuation state of the next GetUpdates operation.
+  void GetDownloadProgress(
+      ModelType type,
+      sync_pb::DataTypeProgressMarker* value_out) const;
+  void GetDownloadProgressAsString(
+      ModelType type,
+      std::string* value_out) const;
+  void SetDownloadProgress(
+      ModelType type,
+      const sync_pb::DataTypeProgressMarker& value);
 
   bool initial_sync_ended_for_type(ModelType type) const;
   void set_initial_sync_ended_for_type(ModelType type, bool value);
   AutofillMigrationState get_autofill_migration_state() const;
 
   AutofillMigrationDebugInfo get_autofill_migration_debug_info() const;
 
   void set_autofill_migration_state(AutofillMigrationState state);
 
   void set_autofill_migration_state_debug_info(
@@ skipping 158 matching lines @@
 
   // Helper method used to implement GetFirstChildId/GetLastChildId.
   Id GetChildWithNullIdField(IdField field,
                              BaseTransaction* trans,
                              const Id& parent_id);
 
   // Internal setters that do not acquire a lock internally.  These are unsafe
   // on their own; caller must guarantee exclusive access manually by holding
   // a ScopedKernelLock.
   void set_initial_sync_ended_for_type_unsafe(ModelType type, bool x);
-  void set_last_download_timestamp_unsafe(ModelType model_type, int64 x);
   void SetNotificationStateUnsafe(const std::string& notification_state);
 
   Directory& operator = (const Directory&);
 
   // TODO(sync):  If lookups and inserts in these sets become
   // the bottle-neck, then we can use hash-sets instead.  But
   // that will require using #ifdefs and compiler-specific code,
   // so use standard sets for now.
  public:
   typedef std::set<EntryKernel*, LessField<MetahandleField, META_HANDLE> >
@@ skipping 206 matching lines @@
 void ZeroFields(EntryKernel* entry, int first_field);
 
 }  // namespace syncable
 
 std::ostream& operator <<(std::ostream&, const syncable::Blob&);
 
 browser_sync::FastDump& operator <<
   (browser_sync::FastDump&, const syncable::Blob&);
 
 #endif  // CHROME_BROWSER_SYNC_SYNCABLE_SYNCABLE_H_