sync: Per-type update application

sync/engine/update_applicator.cc

 // Copyright 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/engine/update_applicator.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "sync/engine/syncer_util.h"
 #include "sync/syncable/entry.h"
 #include "sync/syncable/mutable_entry.h"
 #include "sync/syncable/syncable_id.h"
 #include "sync/syncable/syncable_write_transaction.h"
 
 using std::vector;
 
 namespace syncer {
 
 using syncable::ID;
 
-UpdateApplicator::UpdateApplicator(Cryptographer* cryptographer,
-                                   const ModelSafeRoutingInfo& routes,
-                                   ModelSafeGroup group_filter)
+UpdateApplicator::UpdateApplicator(Cryptographer* cryptographer)
     : cryptographer_(cryptographer),
-      group_filter_(group_filter),
-      routing_info_(routes),
       updates_applied_(0),
       encryption_conflicts_(0),
       hierarchy_conflicts_(0) {
 }
 
 UpdateApplicator::~UpdateApplicator() {
 }
 
 // Attempt to apply all updates, using multiple passes if necessary.
 //
@@ skipping 13 matching lines @@
     syncable::WriteTransaction* trans,
     const std::vector<int64>& handles) {
   std::vector<int64> to_apply = handles;
 
   DVLOG(1) << "UpdateApplicator running over " << to_apply.size() << " items.";
   while (!to_apply.empty()) {
     std::vector<int64> to_reapply;
 
     for (std::vector<int64>::iterator i = to_apply.begin();
          i != to_apply.end(); ++i) {
-      syncable::Entry read_entry(trans, syncable::GET_BY_HANDLE, *i);
-      if (SkipUpdate(read_entry)) {
-        continue;
-      }
-
       syncable::MutableEntry entry(trans, syncable::GET_BY_HANDLE, *i);
       UpdateAttemptResponse result = AttemptToUpdateEntry(
           trans, &entry, cryptographer_);
 
       switch (result) {
         case SUCCESS:
           updates_applied_++;
           break;
         case CONFLICT_SIMPLE:
           simple_conflict_ids_.insert(entry.GetId());
@@ skipping 20 matching lines @@
     }
 
     // We made some progress, so prepare for what might be another iteration.
     // If everything went well, to_reapply will be empty and we'll break out on
     // the while condition.
     to_apply.swap(to_reapply);
     to_reapply.clear();
   }
 }
 
-bool UpdateApplicator::SkipUpdate(const syncable::Entry& entry) {
-  ModelType type = entry.GetServerModelType();
-  ModelSafeGroup g = GetGroupForModelType(type, routing_info_);
-  // The set of updates passed to the UpdateApplicator should already
-  // be group-filtered.
-  if (g != group_filter_) {
-    NOTREACHED();
-    return true;
-  }
-  if (g == GROUP_PASSIVE &&
-      !routing_info_.count(type) &&
-      type != UNSPECIFIED &&
-      type != TOP_LEVEL_FOLDER) {
-    DVLOG(1) << "Skipping update application, type not permitted.";
-    return true;
-  }
-  return false;
-}
-
 }  // namespace syncer