sync: Remove SyncSourceInfo

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 10 matching lines @@
 #include "sync/util/data_type_histogram.h"
 #include "sync/util/logging.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
-using sessions::SyncSourceInfo;
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace {
 
 bool ShouldRequestEarlyExit(const SyncProtocolError& error) {
   switch (error.error_type) {
     case SYNC_SUCCESS:
     case MIGRATION_DONE:
     case THROTTLED:
     case TRANSIENT_ERROR:
@@ skipping 199 matching lines @@
 ModelTypeSet SyncSchedulerImpl::GetEnabledAndUnthrottledTypes() {
   ModelTypeSet enabled_types =
       GetRoutingInfoTypes(session_context_->routing_info());
   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, SyncSourceInfo()));
+  scoped_ptr<SyncSession> dummy(SyncSession::Build(session_context_, this));
   SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
   session_context_->NotifyListeners(event);
 }
 
 namespace {
 
 // Helper to extract the routing info corresponding to types in
 // |types_to_download| from |current_routes|.
 void BuildModelSafeParams(
@@ skipping 199 matching lines @@
   }
   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());
-  scoped_ptr<SyncSession> session(
-      SyncSession::Build(
-          session_context_,
-          this,
-          nudge_tracker_.GetSourceInfo()));
+  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
       && !sessions::HasSyncerError(
@@ skipping 18 matching lines @@
   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());
-  SyncSourceInfo source_info(pending_configure_params_->source,
-                             ModelSafeRoutingInfoToInvalidationMap(
-                                 session_context_->routing_info(),
-                                 std::string()));
-  scoped_ptr<SyncSession> session(
-      SyncSession::Build(session_context_, this, source_info));
+  scoped_ptr<SyncSession> session(SyncSession::Build(session_context_, this));
   bool premature_exit = !syncer_->ConfigureSyncShare(
       GetRoutingInfoTypes(session_context_->routing_info()),
+      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());
 
   if (success) {
@@ skipping 25 matching lines @@
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
         << wait_interval_->length.InMilliseconds() << "ms.";
     RestartWaiting();
   }
 }
 
 void SyncSchedulerImpl::DoPollSyncSessionJob() {
   ModelSafeRoutingInfo r;
   ModelTypeInvalidationMap invalidation_map =
       ModelSafeRoutingInfoToInvalidationMap(r, std::string());
-  SyncSourceInfo info(GetUpdatesCallerInfo::PERIODIC, invalidation_map);
   base::AutoReset<bool> protector(&no_scheduling_allowed_, true);
 
   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());
-  scoped_ptr<SyncSession> session(
-      SyncSession::Build(session_context_, this, info));
+  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
     // to do is start the timer.
@@ skipping 323 matching lines @@
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer