Removed safe worker calculation from SyncScheduler.

sync/sessions/sync_session.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/sync_session.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/logging.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/engine/model_safe_worker.h"
 #include "sync/syncable/directory.h"
 
 namespace syncer {
 namespace sessions {
 
 namespace {
 
 std::set<ModelSafeGroup> ComputeEnabledGroups(
-    const ModelSafeRoutingInfo& routing_info,
-    const std::vector<ModelSafeWorker*>& workers) {
+    const ModelSafeRoutingInfo& routing_info) {
   std::set<ModelSafeGroup> enabled_groups;
   // Project the list of enabled types (i.e., types in the routing
   // info) to a list of enabled groups.
   for (ModelSafeRoutingInfo::const_iterator it = routing_info.begin();
        it != routing_info.end(); ++it) {
     enabled_groups.insert(it->second);
   }
   // GROUP_PASSIVE is always enabled, since that's the group that
   // top-level folders map to.
   enabled_groups.insert(GROUP_PASSIVE);
-  if (DCHECK_IS_ON()) {
-    // We sometimes create dummy SyncSession objects (see
-    // SyncScheduler::InitialSnapshot) so don't check in that case.
-    if (!routing_info.empty() || !workers.empty()) {
-      std::set<ModelSafeGroup> groups_with_workers;
-      for (std::vector<ModelSafeWorker*>::const_iterator it = workers.begin();
-           it != workers.end(); ++it) {
-        groups_with_workers.insert((*it)->GetModelSafeGroup());
-      }
-      // All enabled groups should have a corresponding worker.
-      DCHECK(std::includes(
-          groups_with_workers.begin(), groups_with_workers.end(),
-          enabled_groups.begin(), enabled_groups.end()));
-    }
-  }
   return enabled_groups;
 }
 
 void PurgeStaleStates(ModelTypeStateMap* original,
                       const ModelSafeRoutingInfo& routing_info) {
   std::vector<ModelTypeStateMap::iterator> iterators_to_delete;
   for (ModelTypeStateMap::iterator i = original->begin();
        i != original->end(); ++i) {
     if (routing_info.end() == routing_info.find(i->first)) {
       iterators_to_delete.push_back(i);
     }
   }
 
   for (std::vector<ModelTypeStateMap::iterator>::iterator
        it = iterators_to_delete.begin(); it != iterators_to_delete.end();
        ++it) {
     original->erase(*it);
   }
 }
 
 }  // namesepace
 
 SyncSession::SyncSession(SyncSessionContext* context, Delegate* delegate,
-    const SyncSourceInfo& source,
-    const ModelSafeRoutingInfo& routing_info,
-    const std::vector<ModelSafeWorker*>& workers)
+                         const SyncSourceInfo& source,
+                         const ModelSafeRoutingInfo& routing_info)
     : context_(context),
       source_(source),
       write_transaction_(NULL),
       delegate_(delegate),
-      workers_(workers),

[rlarocque, 2012/09/19 20:39:21]

What will be the effect of sync sessions with no workers?

I'm most concerned about model_changing_syncer_command.cc.

       routing_info_(routing_info),
-      enabled_groups_(ComputeEnabledGroups(routing_info_, workers_)),
+      enabled_groups_(ComputeEnabledGroups(routing_info_)),
       finished_(false) {
   status_controller_.reset(new StatusController(routing_info_));
-  std::sort(workers_.begin(), workers_.end());
 }
 
 SyncSession::~SyncSession() {}
 
 void SyncSession::Coalesce(const SyncSession& session) {
   if (context_ != session.context() || delegate_ != session.delegate_) {
     NOTREACHED();
     return;
   }
 
   // When we coalesce sessions, the sync update source gets overwritten with the
   // most recent, while the type/state map gets merged.
   CoalesceStates(&source_.types, session.source_.types);
   source_.updates_source = session.source_.updates_source;
 
-  std::vector<ModelSafeWorker*> temp;
-  std::set_union(workers_.begin(), workers_.end(),
-                 session.workers_.begin(), session.workers_.end(),
-                 std::back_inserter(temp));
-  workers_.swap(temp);
-
   // We have to update the model safe routing info to the union. In case the
   // same key is present in both pick the one from session.
   for (ModelSafeRoutingInfo::const_iterator it =
        session.routing_info_.begin();
        it != session.routing_info_.end();
        ++it) {
     routing_info_[it->first] = it->second;
   }
 
   // Now update enabled groups.
-  enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
+  enabled_groups_ = ComputeEnabledGroups(routing_info_);
 }
 
 void SyncSession::RebaseRoutingInfoWithLatest(const SyncSession& session) {
   ModelSafeRoutingInfo temp_routing_info;
 
   // Take the intersecion and also set the routing info(it->second) from the
   // passed in session.
   for (ModelSafeRoutingInfo::const_iterator it =
        session.routing_info_.begin(); it != session.routing_info_.end();
        ++it) {
     if (routing_info_.find(it->first) != routing_info_.end()) {
       temp_routing_info[it->first] = it->second;
     }
   }
 
   // Now swap it.
   routing_info_.swap(temp_routing_info);
 
   // Now update the payload map.
   PurgeStaleStates(&source_.types, session.routing_info_);
 
-  // Now update the workers.
-  std::vector<ModelSafeWorker*> temp;
-  std::set_intersection(workers_.begin(), workers_.end(),
-                 session.workers_.begin(), session.workers_.end(),
-                 std::back_inserter(temp));
-  workers_.swap(temp);
-
   // Now update enabled groups.
-  enabled_groups_ = ComputeEnabledGroups(routing_info_, workers_);
+  enabled_groups_ = ComputeEnabledGroups(routing_info_);
 }
 
 void SyncSession::PrepareForAnotherSyncCycle() {
   finished_ = false;
   source_.updates_source =
       sync_pb::GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
   status_controller_.reset(new StatusController(routing_info_));
 }
 
 SyncSessionSnapshot SyncSession::TakeSnapshot() const {
@@ skipping 111 matching lines @@
   // with the server. Therefore, we verify no errors and at least one SYNCER_OK.
   return reached_server && !HadErrors(state);
 }
 
 void SyncSession::SetFinished() {
   finished_ = true;
 }
 
 }  // namespace sessions
 }  // namespace syncer