sync: Loop committing items without downloading updates (v2)

sync/sessions/status_controller.h

 // Copyright (c) 2012 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.
 
 // StatusController handles all counter and status related number crunching and
 // state tracking on behalf of a SyncSession.  It 'controls' the model data
 // defined in session_state.h.  The most important feature of StatusController
 // is the ScopedModelSafetyRestriction. When one of these is active, the
 // underlying data set exposed via accessors is swapped out to the appropriate
 // set for the restricted ModelSafeGroup behind the scenes.  For example, if
@@ skipping 53 matching lines @@
   const ConflictProgress* GetUnrestrictedConflictProgress(
       ModelSafeGroup group) const;
   ConflictProgress* GetUnrestrictedMutableConflictProgressForTest(
       ModelSafeGroup group);
   const UpdateProgress* GetUnrestrictedUpdateProgress(
       ModelSafeGroup group) const;
   UpdateProgress* GetUnrestrictedMutableUpdateProgressForTest(
       ModelSafeGroup group);
 
   // ClientToServer messages.
-  const ClientToServerMessage& commit_message() {
-    return shared_.commit_message;
-  }
-  ClientToServerMessage* mutable_commit_message() {
-    return &shared_.commit_message;
-  }
-  const ClientToServerResponse& commit_response() const {
-    return shared_.commit_response;
-  }
-  ClientToServerResponse* mutable_commit_response() {
-    return &shared_.commit_response;
-  }
   const syncable::ModelTypeSet updates_request_types() const {
     return shared_.updates_request_types;
   }
   void set_updates_request_types(syncable::ModelTypeSet value) {
     shared_.updates_request_types = value;
   }
   const ClientToServerResponse& updates_response() const {
     return shared_.updates_response;
   }
   ClientToServerResponse* mutable_updates_response() {
     return &shared_.updates_response;
   }
 
   // Errors and SyncerStatus.
   const ErrorCounters& error() const {
     return shared_.error.value();
   }
   const SyncerStatus& syncer_status() const {
     return shared_.syncer_status.value();
   }
 
   // Changelog related state.
   int64 num_server_changes_remaining() const {
     return shared_.num_server_changes_remaining.value();
   }
 
-  // Commit path data.
-  const std::vector<syncable::Id>& commit_ids() const {
-    DCHECK(!group_restriction_in_effect_) << "Group restriction in effect!";
-    return shared_.commit_set.GetAllCommitIds();
-  }
-  const OrderedCommitSet::Projection& commit_id_projection() {
+  const OrderedCommitSet::Projection& commit_id_projection(
+      const sessions::OrderedCommitSet &commit_set) {
     DCHECK(group_restriction_in_effect_)
         << "No group restriction for projection.";
-    return shared_.commit_set.GetCommitIdProjection(group_restriction_);
-  }
-  const syncable::Id& GetCommitIdAt(size_t index) {
-    DCHECK(CurrentCommitIdProjectionHasIndex(index));
-    return shared_.commit_set.GetCommitIdAt(index);
-  }
-  syncable::ModelType GetCommitModelTypeAt(size_t index) {
-    DCHECK(CurrentCommitIdProjectionHasIndex(index));
-    return shared_.commit_set.GetModelTypeAt(index);
-  }
-  syncable::ModelType GetUnrestrictedCommitModelTypeAt(size_t index) const {
-    DCHECK(!group_restriction_in_effect_) << "Group restriction in effect!";
-    return shared_.commit_set.GetModelTypeAt(index);
-  }
-  const std::vector<int64>& unsynced_handles() const {
-    DCHECK(!group_restriction_in_effect_)
-        << "unsynced_handles is unrestricted.";
-    return shared_.unsynced_handles.value();
+    return commit_set.GetCommitIdProjection(group_restriction_);
   }
 
   // Control parameters for sync cycles.
   bool conflicts_resolved() const {
     return shared_.control_params.conflicts_resolved;
   }
-  bool did_commit_items() const {
-    return shared_.control_params.items_committed;
-  }
 
   // If a GetUpdates for any data type resulted in downloading an update that
   // is in conflict, this method returns true.
   // Note: this includes unresolvable conflicts.
   bool HasConflictingUpdates() const;
 
   // Aggregate sums of various types of conflict counters accross all
   // ConflictProgress objects (one for each ModelSafeGroup currently in-use).
   int TotalNumEncryptionConflictingItems() const;
   int TotalNumHierarchyConflictingItems() const;
   int TotalNumServerConflictingItems() const;
   int TotalNumSimpleConflictingItems() const;
 
   // Aggregate sum of SimpleConflictingItemSize() and other
   // ${Type}ConflictingItemSize() methods over all ConflictProgress objects (one
   // for each ModelSafeGroup currently in-use).
   int TotalNumConflictingItems() const;
 
   // Returns the number of updates received from the sync server.
   int64 CountUpdates() const;
 
-  // Returns true iff any of the commit ids added during this session are
-  // bookmark related, and the bookmark group restriction is in effect.
-  bool HasBookmarkCommitActivity() const {
-    return ActiveGroupRestrictionIncludesModel(syncable::BOOKMARKS) &&
-        shared_.commit_set.HasBookmarkCommitId();
-  }
-
   // Returns true if the last download_updates_command received a valid
   // server response.
   bool download_updates_succeeded() const {
     return shared_.error.value().last_download_updates_result
         == SYNCER_OK;
   }
 
   // Returns true if the last updates response indicated that we were fully
   // up to date.  This is subtle: if it's false, it could either mean that
   // the server said there WAS more to download, or it could mean that we
   // were unable to reach the server.  If we didn't request every enabled
   // datatype, then we can't say for sure that there's nothing left to
   // download: in that case, this also returns false.
   bool ServerSaysNothingMoreToDownload() const;
 
   ModelSafeGroup group_restriction() const {
     return group_restriction_;
   }
 
   base::Time sync_start_time() const {
     // The time at which we sent the first GetUpdates command for this sync.
     return sync_start_time_;
   }
 
-  // Check whether a particular model is included by the active group
-  // restriction.
-  bool ActiveGroupRestrictionIncludesModel(syncable::ModelType model) const {
-    if (!group_restriction_in_effect_)
-      return true;
-    ModelSafeRoutingInfo::const_iterator it = routing_info_.find(model);
-    if (it == routing_info_.end())
-      return false;
-    return group_restriction() == it->second;
+  bool HasBookmarkCommitActivity() const {
+    return ActiveGroupRestrictionIncludesModel(syncable::BOOKMARKS);
   }
 
+  SyncerError last_post_commit_result() const;
+  SyncerError last_process_commit_response_result() const;
+
   // A toolbelt full of methods for updating counters and flags.
   void set_num_server_changes_remaining(int64 changes_remaining);
   void set_invalid_store(bool invalid_store);
   void set_num_successful_bookmark_commits(int value);
   void increment_num_successful_commits();
   void increment_num_successful_bookmark_commits();
   void increment_num_updates_downloaded_by(int value);
   void increment_num_tombstone_updates_downloaded_by(int value);
   void increment_num_reflected_updates_downloaded_by(int value);
   void set_types_needing_local_migration(syncable::ModelTypeSet types);
-  void set_unsynced_handles(const std::vector<int64>& unsynced_handles);
   void increment_num_local_overwrites();
   void increment_num_server_overwrites();
   void set_sync_protocol_error(const SyncProtocolError& error);
   void set_last_download_updates_result(const SyncerError result);
   void set_last_post_commit_result(const SyncerError result);
   void set_last_process_commit_response_result(const SyncerError result);
 
-  void set_commit_set(const OrderedCommitSet& commit_set);
   void update_conflicts_resolved(bool resolved);
   void reset_conflicts_resolved();
-  void set_items_committed();
 
   void UpdateStartTime();
 
   void set_debug_info_sent();
 
   bool debug_info_sent() const;
 
  private:
   friend class ScopedModelSafeGroupRestriction;
 
-  // Returns true iff the commit id projection for |group_restriction_|
-  // references position |index| into the full set of commit ids in play.
-  bool CurrentCommitIdProjectionHasIndex(size_t index);
+  // Check whether a particular model is included by the active group
+  // restriction.
+  bool ActiveGroupRestrictionIncludesModel(syncable::ModelType model) const {
+    if (!group_restriction_in_effect_)
+      return true;
+    ModelSafeRoutingInfo::const_iterator it = routing_info_.find(model);
+    if (it == routing_info_.end())
+      return false;
+    return group_restriction() == it->second;
+  }
 
   // Returns the state, if it exists, or NULL otherwise.
   const PerModelSafeGroupState* GetModelSafeGroupState(
       bool restrict, ModelSafeGroup group) const;
 
   // Helper to lazily create objects for per-ModelSafeGroup state.
   PerModelSafeGroupState* GetOrCreateModelSafeGroupState(
       bool restrict, ModelSafeGroup group);
 
   AllModelTypeState shared_;
@@ skipping 35 matching lines @@
   }
  private:
   StatusController* status_;
   DISALLOW_COPY_AND_ASSIGN(ScopedModelSafeGroupRestriction);
 };
 
 }
 }
 
 #endif  // SYNC_SESSIONS_STATUS_CONTROLLER_H_