Removed safe worker calculation from SyncScheduler.

sync/engine/sync_scheduler_impl.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/engine/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/auto_reset.h"
@@ skipping 273 matching lines @@
              !wait_interval_->pending_configure_job.get());
     }
 
     DoPendingJobIfPossible(false);
   }
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   scoped_ptr<SyncSession> dummy(new SyncSession(session_context_, this,
-      SyncSourceInfo(), ModelSafeRoutingInfo(),
-      std::vector<ModelSafeWorker*>()));
+    SyncSourceInfo(), ModelSafeRoutingInfo()));
   SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
   session_context_->NotifyListeners(event);
 }
 
 namespace {
 
 // Helper to extract the routing info and workers corresponding to types in
 // |types| from |current_routes| and |current_workers|.
 void BuildModelSafeParams(
     ModelTypeSet types_to_download,
     const ModelSafeRoutingInfo& current_routes,
     const std::vector<ModelSafeWorker*>& current_workers,
-    ModelSafeRoutingInfo* result_routes,
-    std::vector<ModelSafeWorker*>* result_workers) {
+    ModelSafeRoutingInfo* result_routes) {
   std::set<ModelSafeGroup> active_groups;
   active_groups.insert(GROUP_PASSIVE);
   for (ModelTypeSet::Iterator iter = types_to_download.First(); iter.Good();
        iter.Inc()) {
     ModelType type = iter.Get();
     ModelSafeRoutingInfo::const_iterator route = current_routes.find(type);
     DCHECK(route != current_routes.end());
     ModelSafeGroup group = route->second;
     (*result_routes)[type] = group;
     active_groups.insert(group);
   }
-
-  for(std::vector<ModelSafeWorker*>::const_iterator iter =
-          current_workers.begin(); iter != current_workers.end(); ++iter) {
-    if (active_groups.count((*iter)->GetModelSafeGroup()) > 0)
-      result_workers->push_back(*iter);
-  }
 }
 
 }  // namespace.
 
 bool SyncSchedulerImpl::ScheduleConfiguration(
     const ConfigurationParams& params) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(IsConfigRelatedUpdateSourceValue(params.source));
   DCHECK_EQ(CONFIGURATION_MODE, mode_);
   DCHECK(!params.ready_task.is_null());
   SDVLOG(2) << "Reconfiguring syncer.";
 
   // Only one configuration is allowed at a time. Verify we're not waiting
   // for a pending configure job.
   DCHECK(!wait_interval_.get() || !wait_interval_->pending_configure_job.get());
 
   // TODO(sync): now that ModelChanging commands only use those workers within
   // the routing info, we don't really need |restricted_workers|. Remove it.
   // crbug.com/133030
   ModelSafeRoutingInfo restricted_routes;
-  std::vector<ModelSafeWorker*> restricted_workers;
   BuildModelSafeParams(params.types_to_download,
                        params.routing_info,
                        session_context_->workers(),
-                       &restricted_routes,
-                       &restricted_workers);
+                       &restricted_routes);
   session_context_->set_routing_info(params.routing_info);
 
   // Only reconfigure if we have types to download.
   if (!params.types_to_download.Empty()) {
     DCHECK(!restricted_routes.empty());
     linked_ptr<SyncSession> session(new SyncSession(
         session_context_,
         this,
         SyncSourceInfo(params.source,
                        ModelSafeRoutingInfoToStateMap(
                            restricted_routes,
                            std::string())),
-        restricted_routes,
-        restricted_workers));
+        restricted_routes));
     SyncSessionJob job(SyncSessionJob::CONFIGURATION,
                        TimeTicks::Now(),
                        session,
                        false,
                        params,
                        FROM_HERE);
     DoSyncSessionJob(job);
 
     // If we failed, the job would have been saved as the pending configure
     // job and a wait interval would have been set.
@@ skipping 128 matching lines @@
 void SyncSchedulerImpl::InitOrCoalescePendingJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(job.purpose != SyncSessionJob::CONFIGURATION);
   if (pending_nudge_.get() == NULL) {
     SDVLOG(2) << "Creating a pending nudge job";
     SyncSession* s = job.session.get();
 
     // Get a fresh session with similar configuration as before (resets
     // StatusController).
     scoped_ptr<SyncSession> session(new SyncSession(s->context(),
-        s->delegate(), s->source(), s->routing_info(), s->workers()));
+        s->delegate(), s->source(), s->routing_info()));
 
     SyncSessionJob new_job(SyncSessionJob::NUDGE, job.scheduled_start,
         make_linked_ptr(session.release()), false,
         ConfigurationParams(), job.from_here);
     pending_nudge_.reset(new SyncSessionJob(new_job));
     return;
   }
 
   SDVLOG(2) << "Coalescing a pending nudge";
   pending_nudge_->session->Coalesce(*(job.session.get()));
@@ skipping 29 matching lines @@
     InitOrCoalescePendingJob(job);
   } else if (job.purpose == SyncSessionJob::CONFIGURATION){
     SDVLOG(2) << "Saving a configuration job";
     DCHECK(wait_interval_.get());
     DCHECK(mode_ == CONFIGURATION_MODE);
 
     // Config params should always get set.
     DCHECK(!job.config_params.ready_task.is_null());
     SyncSession* old = job.session.get();
     SyncSession* s(new SyncSession(session_context_, this, old->source(),
-                                   old->routing_info(), old->workers()));
+                                   old->routing_info()));
     SyncSessionJob new_job(job.purpose,
                            TimeTicks::Now(),
                            make_linked_ptr(s),
                            false,
                            job.config_params,
                            job.from_here);
     wait_interval_->pending_configure_job.reset(new SyncSessionJob(new_job));
   } // drop the rest.
   // TODO(sync): Is it okay to drop the rest?  It's weird that
   // SaveJob() only does what it says sometimes.  (See
@@ skipping 79 matching lines @@
       SDVLOG(2) << "Dropping the nudge because we are in backoff";
       return;
     }
 
     SDVLOG(2) << "Coalescing pending nudge";
     pending_nudge_->session->Coalesce(*(job.session.get()));
 
     SDVLOG(2) << "Rescheduling pending nudge";
     SyncSession* s = pending_nudge_->session.get();
     job.session.reset(new SyncSession(s->context(), s->delegate(),
-        s->source(), s->routing_info(), s->workers()));
+                                      s->source(), s->routing_info()));
 
     // Choose the start time as the earliest of the 2.
     job.scheduled_start = std::min(job.scheduled_start,
                                    pending_nudge_->scheduled_start);
     pending_nudge_.reset();
   }
 
   // TODO(zea): Consider adding separate throttling/backoff for datatype
   // refresh requests.
   ScheduleSyncSessionJob(job);
@@ skipping 296 matching lines @@
 
   // This will reset the had_nudge variable as well.
   wait_interval_.reset(new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF,
                                         length));
   if (old_job.purpose == SyncSessionJob::CONFIGURATION) {
     SDVLOG(2) << "Configuration did not succeed, scheduling retry.";
     // Config params should always get set.
     DCHECK(!old_job.config_params.ready_task.is_null());
     SyncSession* old = old_job.session.get();
     SyncSession* s(new SyncSession(session_context_, this,
-        old->source(), old->routing_info(), old->workers()));
+        old->source(), old->routing_info()));
     SyncSessionJob job(old_job.purpose, TimeTicks::Now() + length,
                        make_linked_ptr(s), false, old_job.config_params,
                        FROM_HERE);
     wait_interval_->pending_configure_job.reset(new SyncSessionJob(job));
   } else {
     // We are not in configuration mode. So wait_interval's pending job
     // should be null.
     DCHECK(wait_interval_->pending_configure_job.get() == NULL);
 
     // TODO(lipalani) - handle clear user data.
@@ skipping 61 matching lines @@
 }
 
 SyncSession* SyncSchedulerImpl::CreateSyncSession(
     const SyncSourceInfo& source) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DVLOG(2) << "Creating sync session with routes "
            << ModelSafeRoutingInfoToString(session_context_->routing_info());
 
   SyncSourceInfo info(source);
   SyncSession* session(new SyncSession(session_context_, this, info,
-      session_context_->routing_info(), session_context_->workers()));
+      session_context_->routing_info()));
 
   return session;
 }
 
 void SyncSchedulerImpl::PollTimerCallback() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   ModelSafeRoutingInfo r;
   ModelTypeStateMap type_state_map =
       ModelSafeRoutingInfoToStateMap(r, std::string());
   SyncSourceInfo info(GetUpdatesCallerInfo::PERIODIC, type_state_map);
@@ skipping 100 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer