sync: use progress markers instead of timestamps during GetUpdates

chrome/browser/sync/syncable/syncable.cc

 // 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.
 
 #include "chrome/browser/sync/syncable/syncable.h"
 
 #include "build/build_config.h"
 
 #include <sys/stat.h>
 #if defined(OS_POSIX)
@@ skipping 158 matching lines @@
 static const DirectoryChangeEvent kShutdownChangesEvent =
     { DirectoryChangeEvent::SHUTDOWN, 0, 0 };
 
 void Directory::init_kernel(const std::string& name) {
   DCHECK(kernel_ == NULL);
   kernel_ = new Kernel(FilePath(), name, KernelLoadInfo());
 }
 
 Directory::PersistedKernelInfo::PersistedKernelInfo()
     : next_id(0) {
-  for (int i = 0; i < MODEL_TYPE_COUNT; ++i) {
-    last_download_timestamp[i] = 0;
+  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
+    reset_download_progress(ModelTypeFromInt(i));
   }
   autofill_migration_state = NOT_DETERMINED;
 }
 
 Directory::PersistedKernelInfo::~PersistedKernelInfo() {}
 
+void Directory::PersistedKernelInfo::reset_download_progress(
+    ModelType model_type) {
+  download_progress[model_type].set_data_type_id(
+      GetExtensionFieldNumberFromModelType(model_type));
+  // An empty-string token indicates no prior knowledge.
+  download_progress[model_type].set_token(std::string());
+}
+
 Directory::SaveChangesSnapshot::SaveChangesSnapshot()
     : kernel_info_status(KERNEL_SHARE_INFO_INVALID) {
 }
 
 Directory::SaveChangesSnapshot::~SaveChangesSnapshot() {}
 
 Directory::Kernel::Kernel(const FilePath& db_path,
                           const string& name,
                           const KernelLoadInfo& info)
     : db_path(db_path),
@@ skipping 472 matching lines @@
           delete entry;
         } else {
           ++it;
         }
       }
 
       // Ensure meta tracking for these data types reflects the deleted state.
       for (std::set<ModelType>::const_iterator it = types.begin();
            it != types.end(); ++it) {
         set_initial_sync_ended_for_type_unsafe(*it, false);
-        set_last_download_timestamp_unsafe(*it, 0);
+        kernel_->persisted_info.reset_download_progress(*it);
       }
     }
   }
 }
 
 void Directory::HandleSaveChangesFailure(const SaveChangesSnapshot& snapshot) {
   ScopedKernelLock lock(this);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 
   // Because we optimistically cleared the dirty bit on the real entries when
   // taking the snapshot, we must restore it on failure.  Not doing this could
   // cause lost data, if no other changes are made to the in-memory entries
   // that would cause the dirty bit to get set again. Setting the bit ensures
   // that SaveChanges will at least try again later.
   for (OriginalEntries::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
     kernel_->needle.put(META_HANDLE, i->ref(META_HANDLE));
     MetahandlesIndex::iterator found =
         kernel_->metahandles_index->find(&kernel_->needle);
     if (found != kernel_->metahandles_index->end()) {
       (*found)->mark_dirty(kernel_->dirty_metahandles);
     }
   }
 
   kernel_->metahandles_to_purge->insert(snapshot.metahandles_to_purge.begin(),
                                         snapshot.metahandles_to_purge.end());
 }
 
-int64 Directory::last_download_timestamp(ModelType model_type) const {
+void Directory::GetDownloadProgress(
+    ModelType model_type,
+    sync_pb::DataTypeProgressMarker* value_out) const {
   ScopedKernelLock lock(this);
-  return kernel_->persisted_info.last_download_timestamp[model_type];
+  return value_out->CopyFrom(
+      kernel_->persisted_info.download_progress[model_type]);
 }
 
-void Directory::set_last_download_timestamp(ModelType model_type,
-    int64 timestamp) {
+void Directory::GetDownloadProgressAsString(
+    ModelType model_type,
+    std::string* value_out) const {
   ScopedKernelLock lock(this);
-  set_last_download_timestamp_unsafe(model_type, timestamp);
+  kernel_->persisted_info.download_progress[model_type].SerializeToString(
+      value_out);
+}
+
+void Directory::SetDownloadProgress(
+    ModelType model_type,
+    const sync_pb::DataTypeProgressMarker& new_progress) {
+  ScopedKernelLock lock(this);
+  kernel_->persisted_info.download_progress[model_type].CopyFrom(new_progress);
 }
 
 bool Directory::initial_sync_ended_for_type(ModelType type) const {
   ScopedKernelLock lock(this);
   return kernel_->persisted_info.initial_sync_ended[type];
 }
 
 AutofillMigrationState Directory::get_autofill_migration_state() const {
   ScopedKernelLock lock(this);
   return kernel_->persisted_info.autofill_migration_state;
@@ skipping 77 matching lines @@
 }
 
 void Directory::set_initial_sync_ended_for_type_unsafe(ModelType type,
                                                        bool x) {
   if (kernel_->persisted_info.initial_sync_ended[type] == x)
     return;
   kernel_->persisted_info.initial_sync_ended.set(type, x);
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
-void Directory::set_last_download_timestamp_unsafe(ModelType model_type,
-                                                   int64 timestamp) {
-  if (kernel_->persisted_info.last_download_timestamp[model_type] == timestamp)
-    return;
-  kernel_->persisted_info.last_download_timestamp[model_type] = timestamp;
-  kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
-}
-
 void Directory::SetNotificationStateUnsafe(
     const std::string& notification_state) {
   if (notification_state == kernel_->persisted_info.notification_state)
     return;
   kernel_->persisted_info.notification_state = notification_state;
   kernel_->info_status = KERNEL_SHARE_INFO_DIRTY;
 }
 
 string Directory::store_birthday() const {
   ScopedKernelLock lock(this);
@@ skipping 210 matching lines @@
     }
   }
 }
 
 browser_sync::ChannelHookup<DirectoryChangeEvent>* Directory::AddChangeObserver(
     browser_sync::ChannelEventHandler<DirectoryChangeEvent>* observer) {
   return kernel_->changes_channel.AddObserver(observer);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// ScopedKernelLocks
+// ScopedKernelLock
 
 ScopedKernelLock::ScopedKernelLock(const Directory* dir)
   :  scoped_lock_(dir->kernel_->mutex), dir_(const_cast<Directory*>(dir)) {
 }
 
 ///////////////////////////////////////////////////////////////////////////
 // Transactions
 
 void BaseTransaction::Lock() {
   base::TimeTicks start_time = base::TimeTicks::Now();
@@ skipping 667 matching lines @@
 
 FastDump& operator<<(FastDump& dump, const Blob& blob) {
   if (blob.empty())
     return dump;
   string buffer(base::HexEncode(&blob[0], blob.size()));
   dump.out_->sputn(buffer.c_str(), buffer.size());
   return dump;
 }
 
 }  // namespace syncable