sync: Per-type update application

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 221 matching lines @@
       mode_ == NORMAL_MODE &&
       nudge_tracker_.IsSyncRequired() &&
       CanRunNudgeJobNow(NORMAL_PRIORITY)) {
     // We just got back to normal mode.  Let's try to run the work that was
     // queued up while we were configuring.
     DoNudgeSyncSessionJob(NORMAL_PRIORITY);
   }
 }
 
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnthrottledTypes() {
-  ModelTypeSet enabled_types =
-      GetRoutingInfoTypes(session_context_->routing_info());
-  ModelTypeSet throttled_types =
-      nudge_tracker_.GetThrottledTypes();
+  ModelTypeSet enabled_types = session_context_->enabled_types();
+  ModelTypeSet throttled_types = nudge_tracker_.GetThrottledTypes();
   return Difference(enabled_types, throttled_types);
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK(CalledOnValidThread());
   scoped_ptr<SyncSession> dummy(SyncSession::Build(session_context_, this));
   SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
   session_context_->NotifyListeners(event);
 }
@@ skipping 81 matching lines @@
 }
 
 bool SyncSchedulerImpl::CanRunNudgeJobNow(JobPriority priority) {
   DCHECK(CalledOnValidThread());
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(1) << "Unable to run a nudge job right now";
     return false;
   }
 
-  const ModelTypeSet enabled_types =
-      GetRoutingInfoTypes(session_context_->routing_info());
+  const ModelTypeSet enabled_types = session_context_->enabled_types();
   if (nudge_tracker_.GetThrottledTypes().HasAll(enabled_types)) {
     SDVLOG(1) << "Not running a nudge because we're fully type throttled.";
     return false;
   }
 
   if (mode_ == CONFIGURATION_MODE) {
     SDVLOG(1) << "Not running nudge because we're in configuration mode.";
     return false;
   }
 
@@ skipping 101 matching lines @@
     ENUM_CASE(CONFIGURATION_MODE);
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
 void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
 
-  DVLOG(2) << "Will run normal mode sync cycle with routing info "
-           << ModelSafeRoutingInfoToString(session_context_->routing_info());
+  DVLOG(2) << "Will run normal mode sync cycle with types "
+           << ModelTypeSetToString(session_context_->enabled_types());
   scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
   bool premature_exit = !syncer_->NormalSyncShare(
       GetEnabledAndUnthrottledTypes(),
       nudge_tracker_,
       session.get());
   AdjustPolling(FORCE_RESET);
   // Don't run poll job till the next time poll timer fires.
   do_poll_after_credentials_updated_ = false;
 
   bool success = !premature_exit
@@ skipping 17 matching lines @@
 
 bool SyncSchedulerImpl::DoConfigurationSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(mode_, CONFIGURATION_MODE);
 
   if (!CanRunJobNow(priority)) {
     SDVLOG(2) << "Unable to run configure job right now.";
     return false;
   }
 
-  SDVLOG(2) << "Will run configure SyncShare with routes "
-           << ModelSafeRoutingInfoToString(session_context_->routing_info());
+  SDVLOG(2) << "Will run configure SyncShare with types "
+            << ModelTypeSetToString(session_context_->enabled_types());
   scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
   bool premature_exit = !syncer_->ConfigureSyncShare(
-      GetRoutingInfoTypes(session_context_->routing_info()),
+      session_context_->enabled_types(),
       pending_configure_params_->source,
       session.get());
   AdjustPolling(FORCE_RESET);
   // Don't run poll job till the next time poll timer fires.
   do_poll_after_credentials_updated_ = false;
 
   bool success = !premature_exit
       && !sessions::HasSyncerError(
           session->status_controller().model_neutral_state());
 
@@ skipping 35 matching lines @@
   if (!CanRunJobNow(NORMAL_PRIORITY)) {
     SDVLOG(2) << "Unable to run a poll job right now.";
     return;
   }
 
   if (mode_ != NORMAL_MODE) {
     SDVLOG(2) << "Not running poll job in configure mode.";
     return;
   }
 
-  SDVLOG(2) << "Polling with routes "
-           << ModelSafeRoutingInfoToString(session_context_->routing_info());
+  SDVLOG(2) << "Polling with types "
+            << ModelTypeSetToString(session_context_->enabled_types());
   scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
   syncer_->PollSyncShare(
       GetEnabledAndUnthrottledTypes(),
       session.get());
 
   AdjustPolling(UPDATE_INTERVAL);
 
   if (IsCurrentlyThrottled()) {
     SDVLOG(2) << "Poll request got us throttled.";
     // The OnSilencedUntil() call set up the WaitInterval for us.  All we need
@@ skipping 313 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer