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

sync/sessions/session_state.cc

 // 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.
 
 #include "sync/sessions/session_state.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
+#include "sync/engine/model_safe_worker.h"
 #include "sync/protocol/proto_enum_conversions.h"
 
 using std::set;
 using std::vector;
 
 namespace browser_sync {
 namespace sessions {
 
 SyncSourceInfo::SyncSourceInfo()
     : updates_source(sync_pb::GetUpdatesCallerInfo::UNKNOWN) {}
@@ skipping 220 matching lines @@
 void ConflictProgress::AddServerConflictingItemById(
     const syncable::Id& the_id) {
   std::pair<std::set<syncable::Id>::iterator, bool> ret =
       unresolvable_conflicting_item_ids_.insert(the_id);
   if (ret.second) {
     num_server_conflicting_items++;
     *dirty_ = true;
   }
 }
 
-UpdateProgress::UpdateProgress() {}
+UpdateProgress::UpdateProgress(ModelSafeGroup group,
+                               const ModelSafeRoutingInfo& routes)
+    : types_in_model_safe_group_(GetModelTypesForGroup(group, routes)) {
+}
 
 UpdateProgress::~UpdateProgress() {}
 
 void UpdateProgress::AddVerifyResult(const VerifyResult& verify_result,
                                      const sync_pb::SyncEntity& entity) {
   verified_updates_.push_back(std::make_pair(verify_result, entity));
 }
 
 void UpdateProgress::AddAppliedUpdate(const UpdateAttemptResponse& response,
     const syncable::Id& id) {
   applied_updates_.push_back(std::make_pair(response, id));
 }
 
-std::vector<AppliedUpdate>::iterator UpdateProgress::AppliedUpdatesBegin() {
-  return applied_updates_.begin();
+void UpdateProgress::CollectUpdatesToApply(
+    syncable::Directory* dir,
+    syncable::BaseTransaction* trans) {
+  dir->GetUnappliedUpdateMetaHandles(trans,
+                                     types_in_model_safe_group_,
+                                     &unapplied_updates_);
 }
 
 std::vector<VerifiedUpdate>::const_iterator
 UpdateProgress::VerifiedUpdatesBegin() const {
   return verified_updates_.begin();
 }
 
-std::vector<AppliedUpdate>::const_iterator
-UpdateProgress::AppliedUpdatesEnd() const {
-  return applied_updates_.end();
-}
-
 std::vector<VerifiedUpdate>::const_iterator
 UpdateProgress::VerifiedUpdatesEnd() const {
   return verified_updates_.end();
 }
 
 int UpdateProgress::SuccessfullyAppliedUpdateCount() const {
   int count = 0;
   for (std::vector<AppliedUpdate>::const_iterator it =
        applied_updates_.begin();
        it != applied_updates_.end();
@@ skipping 19 matching lines @@
 AllModelTypeState::AllModelTypeState(bool* dirty_flag)
     : unsynced_handles(dirty_flag),
       syncer_status(dirty_flag),
       error(dirty_flag),
       num_server_changes_remaining(dirty_flag, 0),
       commit_set(ModelSafeRoutingInfo()) {
 }
 
 AllModelTypeState::~AllModelTypeState() {}
 
-PerModelSafeGroupState::PerModelSafeGroupState(bool* dirty_flag)
-    : conflict_progress(dirty_flag) {
+PerModelSafeGroupState::PerModelSafeGroupState(
+    bool* dirty_flag,
+    ModelSafeGroup group,
+    const ModelSafeRoutingInfo& routes)
+    : update_progress(group, routes), conflict_progress(dirty_flag) {
 }
 
 PerModelSafeGroupState::~PerModelSafeGroupState() {
 }
 
 }  // namespace sessions
 }  // namespace browser_sync