[not for review] sync: Don't use group_restriction from ApplyUpdatesCommand.

sync/sessions/session_state.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.
 
 // The 'sessions' namespace comprises all the pieces of state that are
 // combined to form a SyncSession instance. In that way, it can be thought of
 // as an extension of the SyncSession type itself. Session scoping gives
 // context to things like "conflict progress", "update progress", etc, and the
 // separation this file provides allows clients to only include the parts they
 // need rather than the entire session stack.
@@ skipping 195 matching lines @@
   // points to StatusController::is_dirty_.
   bool* dirty_;
 };
 
 typedef std::pair<VerifyResult, sync_pb::SyncEntity> VerifiedUpdate;
 typedef std::pair<UpdateAttemptResponse, syncable::Id> AppliedUpdate;
 
 // Tracks update application and verification.
 class UpdateProgress {
  public:
-  UpdateProgress();
+  UpdateProgress(ModelSafeGroup group, const ModelSafeRoutingInfo& routes);
   ~UpdateProgress();
 
   void AddVerifyResult(const VerifyResult& verify_result,
                        const sync_pb::SyncEntity& entity);
 
   // Log a successful or failing update attempt.
   void AddAppliedUpdate(const UpdateAttemptResponse& response,
                         const syncable::Id& id);
 
+  // Fills our unapplied updates state from the set indexed in the directory for
+  // each ModelType in our ModelSafeGroup (using types_in_model_safe_group).
+  void CollectUpdatesToApply(
+      syncable::Directory* dir,
+      syncable::BaseTransaction* trans);
+
   // Various iterators.
-  std::vector<AppliedUpdate>::iterator AppliedUpdatesBegin();
   std::vector<VerifiedUpdate>::const_iterator VerifiedUpdatesBegin() const;
-  std::vector<AppliedUpdate>::const_iterator AppliedUpdatesEnd() const;
   std::vector<VerifiedUpdate>::const_iterator VerifiedUpdatesEnd() const;
 
   // Returns the number of update application attempts.  This includes both
   // failures and successes.
   int AppliedUpdatesSize() const { return applied_updates_.size(); }
   int VerifiedUpdatesSize() const { return verified_updates_.size(); }
   bool HasVerifiedUpdates() const { return !verified_updates_.empty(); }
-  bool HasAppliedUpdates() const { return !applied_updates_.empty(); }
   void ClearVerifiedUpdates() { verified_updates_.clear(); }
 
+  std::vector<int64>* unapplied_updates() {
+    return &unapplied_updates_;
+  }
+
+  bool HasUnappliedUpdates() const { return !unapplied_updates_.empty(); }
+
   // Count the number of successful update applications that have happend this
   // cycle. Note that if an item is successfully applied twice, it will be
   // double counted here.
   int SuccessfullyAppliedUpdateCount() const;
 
   // Returns true if at least one update application failed due to a conflict
   // during this sync cycle.
   bool HasConflictingUpdates() const;
 
  private:
   // Container for updates that passed verification.
   std::vector<VerifiedUpdate> verified_updates_;
 
   // Stores the result of the various ApplyUpdate attempts we've made.
   // May contain duplicate entries.
   std::vector<AppliedUpdate> applied_updates_;
+
+  std::vector<int64> unapplied_updates_;
+
+  // The set of types corresponding to the ModelSafeGroup we are tracking
+  // update progress for, generated on construction from the routing info.
+  const syncable::FullModelTypeSet types_in_model_safe_group_;
 };
 
 struct SyncCycleControlParameters {
   SyncCycleControlParameters() : conflicts_resolved(false),
                                  items_committed(false),
                                  debug_info_sent(false) {}
   // Set to true by ResolveConflictsCommand if any forward progress was made.
   bool conflicts_resolved;
 
   // Set to true by PostCommitMessageCommand if any commits were successful.
@@ skipping 46 matching lines @@
   DirtyOnWrite<std::vector<int64> > unsynced_handles;
   DirtyOnWrite<SyncerStatus> syncer_status;
   DirtyOnWrite<ErrorCounters> error;
   SyncCycleControlParameters control_params;
   DirtyOnWrite<int64> num_server_changes_remaining;
   OrderedCommitSet commit_set;
 };
 
 // Grouping of all state that applies to a single ModelSafeGroup.
 struct PerModelSafeGroupState {
-  explicit PerModelSafeGroupState(bool* dirty_flag);
+  PerModelSafeGroupState(bool* dirty_flag,
+                         ModelSafeGroup group,
+                         const ModelSafeRoutingInfo& routes);
   ~PerModelSafeGroupState();
 
   UpdateProgress update_progress;
   ConflictProgress conflict_progress;
 };
 
 }  // namespace sessions
 }  // namespace browser_sync
 
 #endif  // SYNC_SESSIONS_SESSION_STATE_H_