sync: use progress markers instead of timestamps during GetUpdates

chrome/browser/sync/sessions/status_controller.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.
 
 #include "chrome/browser/sync/sessions/status_controller.h"
 
 #include "base/basictypes.h"
 #include "chrome/browser/sync/syncable/model_type.h"
 
 namespace browser_sync {
@@ skipping 44 matching lines @@
   }
   return per_model_type_[model];
 }
 
 void StatusController::increment_num_conflicting_commits_by(int value) {
   if (value == 0)
     return;
   shared_.error_counters.mutate()->num_conflicting_commits += value;
 }
 
+void StatusController::increment_num_updates_downloaded_by(int value) {
+  shared_.syncer_status.mutate()->num_updates_downloaded += value;
+}
+
+void StatusController::increment_num_tombstone_updates_downloaded_by(
+    int value) {
+  shared_.syncer_status.mutate()->num_tombstone_updates_downloaded += value;
+}
+
 void StatusController::reset_num_conflicting_commits() {
   if (shared_.error_counters.value().num_conflicting_commits != 0)
     shared_.error_counters.mutate()->num_conflicting_commits = 0;
 }
 
 void StatusController::set_num_consecutive_transient_error_commits(int value) {
   if (shared_.error_counters.value().consecutive_transient_error_commits !=
       value) {
     shared_.error_counters.mutate()->consecutive_transient_error_commits =
         value;
   }
 }
 
 void StatusController::increment_num_consecutive_transient_error_commits_by(
     int value) {
   set_num_consecutive_transient_error_commits(
       shared_.error_counters.value().consecutive_transient_error_commits +
       value);
 }
 
 void StatusController::set_num_consecutive_errors(int value) {
   if (shared_.error_counters.value().consecutive_errors != value)
     shared_.error_counters.mutate()->consecutive_errors = value;
 }
 
-void StatusController::set_current_download_timestamp(
-    syncable::ModelType model,
-    int64 current_timestamp) {
-  PerModelTypeState* state = GetOrCreateModelTypeState(false, model);
-  if (current_timestamp > state->current_download_timestamp.value())
-    *(state->current_download_timestamp.mutate()) = current_timestamp;
-}
-
 void StatusController::set_num_server_changes_remaining(
     int64 changes_remaining) {
   if (shared_.num_server_changes_remaining.value() != changes_remaining)
     *(shared_.num_server_changes_remaining.mutate()) = changes_remaining;
 }
 
 void StatusController::set_invalid_store(bool invalid_store) {
   if (shared_.syncer_status.value().invalid_store != invalid_store)
     shared_.syncer_status.mutate()->invalid_store = invalid_store;
 }
@@ skipping 66 matching lines @@
     return 0;
   }
 }
 
 bool StatusController::CurrentCommitIdProjectionHasIndex(size_t index) {
   OrderedCommitSet::Projection proj =
       shared_.commit_set.GetCommitIdProjection(group_restriction_);
   return std::binary_search(proj.begin(), proj.end(), index);
 }
 
-int64 StatusController::ComputeMaxLocalTimestamp() const {
-  std::map<syncable::ModelType, PerModelTypeState*>::const_iterator it =
-      per_model_type_.begin();
-  int64 max_timestamp = 0;
-  for (; it != per_model_type_.end(); ++it) {
-    if (it->second->current_download_timestamp.value() > max_timestamp)
-      max_timestamp = it->second->current_download_timestamp.value();
-  }
-  return max_timestamp;
-}
-
 bool StatusController::HasConflictingUpdates() const {
   DCHECK(!group_restriction_in_effect_)
       << "HasConflictingUpdates applies to all ModelSafeGroups";
   std::map<ModelSafeGroup, PerModelSafeGroupState*>::const_iterator it =
     per_model_group_.begin();
   for (; it != per_model_group_.end(); ++it) {
     if (it->second->update_progress.HasConflictingUpdates())
       return true;
   }
   return false;
 }
 
 int StatusController::TotalNumConflictingItems() const {
   DCHECK(!group_restriction_in_effect_)
       << "TotalNumConflictingItems applies to all ModelSafeGroups";
   std::map<ModelSafeGroup, PerModelSafeGroupState*>::const_iterator it =
     per_model_group_.begin();
   int sum = 0;
   for (; it != per_model_group_.end(); ++it) {
     sum += it->second->conflict_progress.ConflictingItemsSize();
   }
   return sum;
 }
 
 bool StatusController::ServerSaysNothingMoreToDownload() const {
   if (!download_updates_succeeded())
     return false;
-  // If we didn't request every enabled datatype, then we can't say for
-  // sure that there's nothing left to download.
-  for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
-    if (!updates_request_parameters().data_types[i] &&
-        routing_info_.count(syncable::ModelTypeFromInt(i)) != 0) {
-      return false;
-    }
+
+  if (!updates_response().get_updates().has_changes_remaining()) {
+    NOTREACHED();  // Server should always send changes remaining.
+    return false;  // Avoid looping forever.
   }
   // Changes remaining is an estimate, but if it's estimated to be
   // zero, that's firm and we don't have to ask again.
-  if (updates_response().get_updates().has_changes_remaining() &&
-      updates_response().get_updates().changes_remaining() == 0) {
-    return true;
-  }
-  // Otherwise, the server can also indicate "you're up to date"
-  // by not sending a new timestamp.
-  return !updates_response().get_updates().has_new_timestamp();
+  return updates_response().get_updates().changes_remaining() == 0;
 }
 
 }  // namespace sessions
 }  // namespace browser_sync