sync: Remove SyncManager::TestingMode in favour of InternalComponentsFactory.

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.h"
+#include "sync/engine/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 60 matching lines @@
     const base::Closure& ready_task)
     : source(source),
       types_to_download(types_to_download),
       routing_info(routing_info),
       keystore_key_status(keystore_key_status),
       ready_task(ready_task) {
   DCHECK(!ready_task.is_null());
 }
 ConfigurationParams::~ConfigurationParams() {}
 
-SyncScheduler::DelayProvider::DelayProvider() {}
-SyncScheduler::DelayProvider::~DelayProvider() {}
+SyncSchedulerImpl::DelayProvider::DelayProvider() {}
+SyncSchedulerImpl::DelayProvider::~DelayProvider() {}
 
-SyncScheduler::WaitInterval::WaitInterval()
+SyncSchedulerImpl::WaitInterval::WaitInterval()
     : mode(UNKNOWN),
       had_nudge(false) {
 }
 
-SyncScheduler::WaitInterval::~WaitInterval() {}
+SyncSchedulerImpl::WaitInterval::~WaitInterval() {}
 
 #define ENUM_CASE(x) case x: return #x; break;
 
-const char* SyncScheduler::WaitInterval::GetModeString(Mode mode) {
+const char* SyncSchedulerImpl::WaitInterval::GetModeString(Mode mode) {
   switch (mode) {
     ENUM_CASE(UNKNOWN);
     ENUM_CASE(EXPONENTIAL_BACKOFF);
     ENUM_CASE(THROTTLED);
   }
   NOTREACHED();
   return "";
 }
 
-SyncScheduler::SyncSessionJob::SyncSessionJob()
+SyncSchedulerImpl::SyncSessionJob::SyncSessionJob()
     : purpose(UNKNOWN),
       is_canary_job(false) {
 }
 
-SyncScheduler::SyncSessionJob::~SyncSessionJob() {}
+SyncSchedulerImpl::SyncSessionJob::~SyncSessionJob() {}
 
-SyncScheduler::SyncSessionJob::SyncSessionJob(SyncSessionJobPurpose purpose,
+SyncSchedulerImpl::SyncSessionJob::SyncSessionJob(SyncSessionJobPurpose purpose,
     base::TimeTicks start,
     linked_ptr<sessions::SyncSession> session,
     bool is_canary_job,
     const ConfigurationParams& config_params,
     const tracked_objects::Location& from_here)
     : purpose(purpose),
       scheduled_start(start),
       session(session),
       is_canary_job(is_canary_job),
       config_params(config_params),
       from_here(from_here) {
 }
 
-const char* SyncScheduler::SyncSessionJob::GetPurposeString(
-    SyncScheduler::SyncSessionJob::SyncSessionJobPurpose purpose) {
+const char* SyncSchedulerImpl::SyncSessionJob::GetPurposeString(
+    SyncSchedulerImpl::SyncSessionJob::SyncSessionJobPurpose purpose) {
   switch (purpose) {
     ENUM_CASE(UNKNOWN);
     ENUM_CASE(POLL);
     ENUM_CASE(NUDGE);
     ENUM_CASE(CONFIGURATION);
     ENUM_CASE(CLEANUP_DISABLED_TYPES);
   }
   NOTREACHED();
   return "";
 }
 
-TimeDelta SyncScheduler::DelayProvider::GetDelay(
+TimeDelta SyncSchedulerImpl::DelayProvider::GetDelay(
     const base::TimeDelta& last_delay) {
-  return SyncScheduler::GetRecommendedDelay(last_delay);
+  return SyncSchedulerImpl::GetRecommendedDelay(last_delay);
 }
 
 GetUpdatesCallerInfo::GetUpdatesSource GetUpdatesFromNudgeSource(
     NudgeSource source) {
   switch (source) {
     case NUDGE_SOURCE_NOTIFICATION:
       return GetUpdatesCallerInfo::NOTIFICATION;
     case NUDGE_SOURCE_LOCAL:
       return GetUpdatesCallerInfo::LOCAL;
     case NUDGE_SOURCE_CONTINUATION:
       return GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION;
     case NUDGE_SOURCE_LOCAL_REFRESH:
       return GetUpdatesCallerInfo::DATATYPE_REFRESH;
     case NUDGE_SOURCE_UNKNOWN:
       return GetUpdatesCallerInfo::UNKNOWN;
     default:
       NOTREACHED();
       return GetUpdatesCallerInfo::UNKNOWN;
   }
 }
 
-SyncScheduler::WaitInterval::WaitInterval(Mode mode, TimeDelta length)
+SyncSchedulerImpl::WaitInterval::WaitInterval(Mode mode, TimeDelta length)
     : mode(mode), had_nudge(false), length(length) { }
 
 // Helper macros to log with the syncer thread name; useful when there
 // are multiple syncer threads involved.
 
 #define SLOG(severity) LOG(severity) << name_ << ": "
 
 #define SDVLOG(verbose_level) DVLOG(verbose_level) << name_ << ": "
 
 #define SDVLOG_LOC(from_here, verbose_level)             \
@@ skipping 11 matching lines @@
     case GetUpdatesCallerInfo::NEW_CLIENT:
     case GetUpdatesCallerInfo::NEWLY_SUPPORTED_DATATYPE:
       return true;
     default:
       return false;
   }
 }
 
 }  // namespace
 
-SyncScheduler::SyncScheduler(const std::string& name,
-                             sessions::SyncSessionContext* context,
-                             Syncer* syncer)
+SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
+                                     sessions::SyncSessionContext* context,
+                                     Syncer* syncer)
     : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_ptr_factory_for_weak_handle_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       weak_handle_this_(MakeWeakHandle(
           weak_ptr_factory_for_weak_handle_.GetWeakPtr())),
       name_(name),
       sync_loop_(MessageLoop::current()),
       started_(false),
       syncer_short_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
       sessions_commit_delay_(
           TimeDelta::FromSeconds(kDefaultSessionsCommitDelaySeconds)),
       mode_(NORMAL_MODE),
       // Start with assuming everything is fine with the connection.
       // At the end of the sync cycle we would have the correct status.
       connection_code_(HttpResponse::SERVER_CONNECTION_OK),
       delay_provider_(new DelayProvider()),
       syncer_(syncer),
       session_context_(context) {
   DCHECK(sync_loop_);
 }
 
-SyncScheduler::~SyncScheduler() {
+SyncSchedulerImpl::~SyncSchedulerImpl() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   StopImpl(base::Closure());
 }
 
-void SyncScheduler::OnCredentialsUpdated() {
+void SyncSchedulerImpl::OnCredentialsUpdated() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   // TODO(lipalani): crbug.com/106262. One issue here is that if after
   // the auth error we happened to do gettime and it succeeded then
   // the |connection_code_| would be briefly OK however it would revert
   // back to SYNC_AUTH_ERROR at the end of the sync cycle. The
   // referenced bug explores the option of removing gettime calls
   // altogethere
   if (HttpResponse::SYNC_AUTH_ERROR == connection_code_) {
     OnServerConnectionErrorFixed();
   }
 }
 
-void SyncScheduler::OnConnectionStatusChange() {
+void SyncSchedulerImpl::OnConnectionStatusChange() {
   if (HttpResponse::CONNECTION_UNAVAILABLE  == connection_code_) {
     // Optimistically assume that the connection is fixed and try
     // connecting.
     OnServerConnectionErrorFixed();
   }
 }
 
-void SyncScheduler::OnServerConnectionErrorFixed() {
+void SyncSchedulerImpl::OnServerConnectionErrorFixed() {
   connection_code_ = HttpResponse::SERVER_CONNECTION_OK;
   PostTask(FROM_HERE, "DoCanaryJob",
-           base::Bind(&SyncScheduler::DoCanaryJob,
+           base::Bind(&SyncSchedulerImpl::DoCanaryJob,
                       weak_ptr_factory_.GetWeakPtr()));
 
 }
 
-void SyncScheduler::UpdateServerConnectionManagerStatus(
+void SyncSchedulerImpl::UpdateServerConnectionManagerStatus(
     HttpResponse::ServerConnectionCode code) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "New server connection code: "
             << HttpResponse::GetServerConnectionCodeString(code);
 
   connection_code_ = code;
 }
 
-void SyncScheduler::Start(Mode mode) {
+void SyncSchedulerImpl::Start(Mode mode) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   std::string thread_name = MessageLoop::current()->thread_name();
   if (thread_name.empty())
     thread_name = "<Main thread>";
   SDVLOG(2) << "Start called from thread "
             << thread_name << " with mode " << GetModeString(mode);
   if (!started_) {
     started_ = true;
     SendInitialSnapshot();
   }
 
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
   Mode old_mode = mode_;
   mode_ = mode;
   AdjustPolling(NULL);  // Will kick start poll timer if needed.
 
   if (old_mode != mode_) {
     // We just changed our mode. See if there are any pending jobs that we could
     // execute in the new mode.
     DoPendingJobIfPossible(false);
   }
 }
 
-void SyncScheduler::SendInitialSnapshot() {
+void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   scoped_ptr<SyncSession> dummy(new SyncSession(session_context_, this,
       SyncSourceInfo(), ModelSafeRoutingInfo(),
       std::vector<ModelSafeWorker*>()));
   SyncEngineEvent event(SyncEngineEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
   session_context_->NotifyListeners(event);
 }
 
 namespace {
@@ skipping 20 matching lines @@
 
   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 SyncScheduler::ScheduleConfiguration(const ConfigurationParams& params) {
+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());
 
@@ skipping 54 matching lines @@
       return false;
     }
   } else {
     SDVLOG(2) << "No change in routing info, calling ready task directly.";
     params.ready_task.Run();
   }
 
   return true;
 }
 
-SyncScheduler::JobProcessDecision SyncScheduler::DecideWhileInWaitInterval(
+SyncSchedulerImpl::JobProcessDecision
+SyncSchedulerImpl::DecideWhileInWaitInterval(
     const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(wait_interval_.get());
   DCHECK_NE(job.purpose, SyncSessionJob::CLEANUP_DISABLED_TYPES);
 
   SDVLOG(2) << "DecideWhileInWaitInterval with WaitInterval mode "
             << WaitInterval::GetModeString(wait_interval_->mode)
             << (wait_interval_->had_nudge ? " (had nudge)" : "")
             << (job.is_canary_job ? " (canary)" : "");
 
@@ skipping 13 matching lines @@
     // If we already had one nudge then just drop this nudge. We will retry
     // later when the timer runs out.
     if (!job.is_canary_job)
       return wait_interval_->had_nudge ? DROP : CONTINUE;
     else // We are here because timer ran out. So retry.
       return CONTINUE;
   }
   return job.is_canary_job ? CONTINUE : SAVE;
 }
 
-SyncScheduler::JobProcessDecision SyncScheduler::DecideOnJob(
+SyncSchedulerImpl::JobProcessDecision SyncSchedulerImpl::DecideOnJob(
     const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (job.purpose == SyncSessionJob::CLEANUP_DISABLED_TYPES)
     return CONTINUE;
 
   // See if our type is throttled.
   syncer::ModelTypeSet throttled_types =
       session_context_->throttled_data_type_tracker()->GetThrottledTypes();
   if (job.purpose == SyncSessionJob::NUDGE &&
       job.session->source().updates_source == GetUpdatesCallerInfo::LOCAL) {
@@ skipping 31 matching lines @@
     return DROP;
   }
 
   if (!session_context_->connection_manager()->HasInvalidAuthToken())
     return CONTINUE;
 
   SDVLOG(2) << "No valid auth token. Using that to decide on job.";
   return job.purpose == SyncSessionJob::NUDGE ? SAVE : DROP;
 }
 
-void SyncScheduler::InitOrCoalescePendingJob(const SyncSessionJob& job) {
+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();
     scoped_ptr<SyncSession> session(new SyncSession(s->context(),
         s->delegate(), s->source(), s->routing_info(), s->workers()));
 
     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()));
   pending_nudge_->scheduled_start = job.scheduled_start;
 
   // Unfortunately the nudge location cannot be modified. So it stores the
   // location of the first caller.
 }
 
-bool SyncScheduler::ShouldRunJob(const SyncSessionJob& job) {
+bool SyncSchedulerImpl::ShouldRunJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(started_);
 
   JobProcessDecision decision = DecideOnJob(job);
   SDVLOG(2) << "Should run "
             << SyncSessionJob::GetPurposeString(job.purpose)
             << " job in mode " << GetModeString(mode_)
             << ": " << GetDecisionString(decision);
   if (decision != SAVE)
     return decision == CONTINUE;
 
   DCHECK(job.purpose == SyncSessionJob::NUDGE || job.purpose ==
       SyncSessionJob::CONFIGURATION);
 
   SaveJob(job);
   return false;
 }
 
-void SyncScheduler::SaveJob(const SyncSessionJob& job) {
+void SyncSchedulerImpl::SaveJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // TODO(sync): Should we also check that job.purpose !=
   // CLEANUP_DISABLED_TYPES?  (See http://crbug.com/90868.)
   if (job.purpose == SyncSessionJob::NUDGE) {
     SDVLOG(2) << "Saving a nudge job";
     InitOrCoalescePendingJob(job);
   } else if (job.purpose == SyncSessionJob::CONFIGURATION){
     SDVLOG(2) << "Saving a configuration job";
     DCHECK(wait_interval_.get());
     DCHECK(mode_ == CONFIGURATION_MODE);
@@ skipping 18 matching lines @@
 
 // Functor for std::find_if to search by ModelSafeGroup.
 struct ModelSafeWorkerGroupIs {
   explicit ModelSafeWorkerGroupIs(ModelSafeGroup group) : group(group) {}
   bool operator()(ModelSafeWorker* w) {
     return group == w->GetModelSafeGroup();
   }
   ModelSafeGroup group;
 };
 
-void SyncScheduler::ScheduleNudgeAsync(
+void SyncSchedulerImpl::ScheduleNudgeAsync(
     const TimeDelta& delay,
     NudgeSource source, ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG_LOC(nudge_location, 2)
       << "Nudge scheduled with delay " << delay.InMilliseconds() << " ms, "
       << "source " << GetNudgeSourceString(source) << ", "
       << "types " << ModelTypeSetToString(types);
 
   ModelTypePayloadMap types_with_payloads =
       syncer::ModelTypePayloadMapFromEnumSet(types, std::string());
-  SyncScheduler::ScheduleNudgeImpl(delay,
-                                   GetUpdatesFromNudgeSource(source),
-                                   types_with_payloads,
-                                   false,
-                                   nudge_location);
+  SyncSchedulerImpl::ScheduleNudgeImpl(delay,
+                                       GetUpdatesFromNudgeSource(source),
+                                       types_with_payloads,
+                                       false,
+                                       nudge_location);
 }
 
-void SyncScheduler::ScheduleNudgeWithPayloadsAsync(
+void SyncSchedulerImpl::ScheduleNudgeWithPayloadsAsync(
     const TimeDelta& delay,
     NudgeSource source, const ModelTypePayloadMap& types_with_payloads,
     const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG_LOC(nudge_location, 2)
       << "Nudge scheduled with delay " << delay.InMilliseconds() << " ms, "
       << "source " << GetNudgeSourceString(source) << ", "
       << "payloads "
       << syncer::ModelTypePayloadMapToString(types_with_payloads);
 
-  SyncScheduler::ScheduleNudgeImpl(delay,
-                                   GetUpdatesFromNudgeSource(source),
-                                   types_with_payloads,
-                                   false,
-                                   nudge_location);
+  SyncSchedulerImpl::ScheduleNudgeImpl(delay,
+                                       GetUpdatesFromNudgeSource(source),
+                                       types_with_payloads,
+                                       false,
+                                       nudge_location);
 }
 
-void SyncScheduler::ScheduleNudgeImpl(
+void SyncSchedulerImpl::ScheduleNudgeImpl(
     const TimeDelta& delay,
     GetUpdatesCallerInfo::GetUpdatesSource source,
     const ModelTypePayloadMap& types_with_payloads,
     bool is_canary_job, const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   SDVLOG_LOC(nudge_location, 2)
       << "In ScheduleNudgeImpl with delay "
       << delay.InMilliseconds() << " ms, "
       << "source " << GetUpdatesSourceString(source) << ", "
@@ skipping 30 matching lines @@
     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);
 }
 
-const char* SyncScheduler::GetModeString(SyncScheduler::Mode mode) {
+const char* SyncSchedulerImpl::GetModeString(SyncScheduler::Mode mode) {
   switch (mode) {
     ENUM_CASE(CONFIGURATION_MODE);
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
-const char* SyncScheduler::GetDecisionString(
-    SyncScheduler::JobProcessDecision mode) {
+const char* SyncSchedulerImpl::GetDecisionString(
+    SyncSchedulerImpl::JobProcessDecision mode) {
   switch (mode) {
     ENUM_CASE(CONTINUE);
     ENUM_CASE(SAVE);
     ENUM_CASE(DROP);
   }
   return "";
 }
 
 // static
-void SyncScheduler::SetSyncerStepsForPurpose(
+void SyncSchedulerImpl::SetSyncerStepsForPurpose(
     SyncSessionJob::SyncSessionJobPurpose purpose,
     SyncerStep* start,
     SyncerStep* end) {
   switch (purpose) {
     case SyncSessionJob::CONFIGURATION:
       *start = DOWNLOAD_UPDATES;
       *end = APPLY_UPDATES;
       return;
     case SyncSessionJob::NUDGE:
     case SyncSessionJob::POLL:
       *start = SYNCER_BEGIN;
       *end = SYNCER_END;
       return;
     case SyncSessionJob::CLEANUP_DISABLED_TYPES:
       *start = CLEANUP_DISABLED_TYPES;
       *end = CLEANUP_DISABLED_TYPES;
       return;
     default:
       NOTREACHED();
       *start = SYNCER_END;
       *end = SYNCER_END;
       return;
   }
 }
 
-void SyncScheduler::PostTask(
+void SyncSchedulerImpl::PostTask(
     const tracked_objects::Location& from_here,
     const char* name, const base::Closure& task) {
   SDVLOG_LOC(from_here, 3) << "Posting " << name << " task";
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (!started_) {
     SDVLOG(1) << "Not posting task as scheduler is stopped.";
     return;
   }
   sync_loop_->PostTask(from_here, task);
 }
 
-void SyncScheduler::PostDelayedTask(
+void SyncSchedulerImpl::PostDelayedTask(
     const tracked_objects::Location& from_here,
     const char* name, const base::Closure& task, base::TimeDelta delay) {
   SDVLOG_LOC(from_here, 3) << "Posting " << name << " task with "
                            << delay.InMilliseconds() << " ms delay";
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (!started_) {
     SDVLOG(1) << "Not posting task as scheduler is stopped.";
     return;
   }
   sync_loop_->PostDelayedTask(from_here, task, delay);
 }
 
-void SyncScheduler::ScheduleSyncSessionJob(const SyncSessionJob& job) {
+void SyncSchedulerImpl::ScheduleSyncSessionJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   TimeDelta delay = job.scheduled_start - TimeTicks::Now();
   if (delay < TimeDelta::FromMilliseconds(0))
     delay = TimeDelta::FromMilliseconds(0);
   SDVLOG_LOC(job.from_here, 2)
       << "In ScheduleSyncSessionJob with "
       << SyncSessionJob::GetPurposeString(job.purpose)
       << " job and " << delay.InMilliseconds() << " ms delay";
 
   DCHECK(job.purpose == SyncSessionJob::NUDGE ||
          job.purpose == SyncSessionJob::POLL);
   if (job.purpose == SyncSessionJob::NUDGE) {
     SDVLOG_LOC(job.from_here, 2) << "Resetting pending_nudge";
     DCHECK(!pending_nudge_.get() || pending_nudge_->session.get() ==
            job.session);
     pending_nudge_.reset(new SyncSessionJob(job));
   }
   PostDelayedTask(job.from_here, "DoSyncSessionJob",
-                  base::Bind(&SyncScheduler::DoSyncSessionJob,
+                  base::Bind(&SyncSchedulerImpl::DoSyncSessionJob,
                              weak_ptr_factory_.GetWeakPtr(),
                              job),
                   delay);
 }
 
-void SyncScheduler::DoSyncSessionJob(const SyncSessionJob& job) {
+void SyncSchedulerImpl::DoSyncSessionJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (!ShouldRunJob(job)) {
     SLOG(WARNING)
         << "Not executing "
         << SyncSessionJob::GetPurposeString(job.purpose) << " job from "
         << GetUpdatesSourceString(job.session->source().updates_source);
     return;
   }
 
   if (job.purpose == SyncSessionJob::NUDGE) {
@@ skipping 25 matching lines @@
     syncer_->SyncShare(job.session.get(), begin, end);
     has_more_to_sync = job.session->HasMoreToSync();
     if (has_more_to_sync)
       job.session->PrepareForAnotherSyncCycle();
   }
   SDVLOG(2) << "Done SyncShare looping.";
 
   FinishSyncSessionJob(job);
 }
 
-void SyncScheduler::UpdateCarryoverSessionState(
+void SyncSchedulerImpl::UpdateCarryoverSessionState(
     const SyncSessionJob& old_job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (old_job.purpose == SyncSessionJob::CONFIGURATION) {
     // Whatever types were part of a configuration task will have had updates
     // downloaded.  For that reason, we make sure they get recorded in the
     // event that they get disabled at a later time.
     ModelSafeRoutingInfo r(session_context_->previous_session_routing_info());
     if (!r.empty()) {
       ModelSafeRoutingInfo temp_r;
       ModelSafeRoutingInfo old_info(old_job.session->routing_info());
       std::set_union(r.begin(), r.end(), old_info.begin(), old_info.end(),
           std::insert_iterator<ModelSafeRoutingInfo>(temp_r, temp_r.begin()));
       session_context_->set_previous_session_routing_info(temp_r);
     }
   } else {
     session_context_->set_previous_session_routing_info(
         old_job.session->routing_info());
   }
 }
 
-void SyncScheduler::FinishSyncSessionJob(const SyncSessionJob& job) {
+void SyncSchedulerImpl::FinishSyncSessionJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   // Update timing information for how often datatypes are triggering nudges.
   base::TimeTicks now = TimeTicks::Now();
   if (!last_sync_session_end_time_.is_null()) {
     ModelTypePayloadMap::const_iterator iter;
     for (iter = job.session->source().types.begin();
          iter != job.session->source().types.end();
          ++iter) {
 #define PER_DATA_TYPE_MACRO(type_str) \
     SYNC_FREQ_HISTOGRAM("Sync.Freq" type_str, \
@@ skipping 26 matching lines @@
              !job.config_params.ready_task.is_null()) {
     // If this was a configuration job with a ready task, invoke it now that
     // we finished successfully.
     job.config_params.ready_task.Run();
   }
 
   SDVLOG(2) << "Updating the next polling time after SyncMain";
   ScheduleNextSync(job);
 }
 
-void SyncScheduler::ScheduleNextSync(const SyncSessionJob& old_job) {
+void SyncSchedulerImpl::ScheduleNextSync(const SyncSessionJob& old_job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK(!old_job.session->HasMoreToSync());
 
   AdjustPolling(&old_job);
 
   if (old_job.session->Succeeded()) {
     // Only reset backoff if we actually reached the server.
     if (old_job.session->SuccessfullyReachedServer())
       wait_interval_.reset();
     SDVLOG(2) << "Job succeeded so not scheduling more jobs";
@@ skipping 27 matching lines @@
     InitOrCoalescePendingJob(old_job);
     RestartWaiting();
   } else {
     // Either this is the first failure or a consecutive failure after our
     // backoff timer expired.  We handle it the same way in either case.
     SDVLOG(2) << "Non-'backoff nudge' SyncShare job failed";
     HandleContinuationError(old_job);
   }
 }
 
-void SyncScheduler::AdjustPolling(const SyncSessionJob* old_job) {
+void SyncSchedulerImpl::AdjustPolling(const SyncSessionJob* old_job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
 
   TimeDelta poll  = (!session_context_->notifications_enabled()) ?
       syncer_short_poll_interval_seconds_ :
       syncer_long_poll_interval_seconds_;
   bool rate_changed = !poll_timer_.IsRunning() ||
                        poll != poll_timer_.GetCurrentDelay();
 
   if (old_job && old_job->purpose != SyncSessionJob::POLL && !rate_changed)
     poll_timer_.Reset();
 
   if (!rate_changed)
     return;
 
   // Adjust poll rate.
   poll_timer_.Stop();
-  poll_timer_.Start(FROM_HERE, poll, this, &SyncScheduler::PollTimerCallback);
+  poll_timer_.Start(FROM_HERE, poll, this,
+                    &SyncSchedulerImpl::PollTimerCallback);
 }
 
-void SyncScheduler::RestartWaiting() {
+void SyncSchedulerImpl::RestartWaiting() {
   CHECK(wait_interval_.get());
   wait_interval_->timer.Stop();
   wait_interval_->timer.Start(FROM_HERE, wait_interval_->length,
-                              this, &SyncScheduler::DoCanaryJob);
+                              this, &SyncSchedulerImpl::DoCanaryJob);
 }
 
-void SyncScheduler::HandleContinuationError(
+void SyncSchedulerImpl::HandleContinuationError(
     const SyncSessionJob& old_job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (DCHECK_IS_ON()) {
     if (IsBackingOff()) {
       DCHECK(wait_interval_->timer.IsRunning() || old_job.is_canary_job);
     }
   }
 
   TimeDelta length = delay_provider_->GetDelay(
       IsBackingOff() ? wait_interval_->length : TimeDelta::FromSeconds(1));
@@ skipping 22 matching lines @@
     // should be null.
     DCHECK(wait_interval_->pending_configure_job.get() == NULL);
 
     // TODO(lipalani) - handle clear user data.
     InitOrCoalescePendingJob(old_job);
   }
   RestartWaiting();
 }
 
 // static
-TimeDelta SyncScheduler::GetRecommendedDelay(const TimeDelta& last_delay) {
+TimeDelta SyncSchedulerImpl::GetRecommendedDelay(const TimeDelta& last_delay) {
   if (last_delay.InSeconds() >= kMaxBackoffSeconds)
     return TimeDelta::FromSeconds(kMaxBackoffSeconds);
 
   // This calculates approx. base_delay_seconds * 2 +/- base_delay_seconds / 2
   int64 backoff_s =
       std::max(static_cast<int64>(1),
                last_delay.InSeconds() * kBackoffRandomizationFactor);
 
   // Flip a coin to randomize backoff interval by +/- 50%.
   int rand_sign = base::RandInt(0, 1) * 2 - 1;
 
   // Truncation is adequate for rounding here.
   backoff_s = backoff_s +
       (rand_sign * (last_delay.InSeconds() / kBackoffRandomizationFactor));
 
   // Cap the backoff interval.
   backoff_s = std::max(static_cast<int64>(1),
                        std::min(backoff_s, kMaxBackoffSeconds));
 
   return TimeDelta::FromSeconds(backoff_s);
 }
 
-void SyncScheduler::RequestStop(const base::Closure& callback) {
+void SyncSchedulerImpl::RequestStop(const base::Closure& callback) {
   syncer_->RequestEarlyExit();  // Safe to call from any thread.
   DCHECK(weak_handle_this_.IsInitialized());
   SDVLOG(3) << "Posting StopImpl";
   weak_handle_this_.Call(FROM_HERE,
-                         &SyncScheduler::StopImpl,
+                         &SyncSchedulerImpl::StopImpl,
                          callback);
 }
 
-void SyncScheduler::StopImpl(const base::Closure& callback) {
+void SyncSchedulerImpl::StopImpl(const base::Closure& callback) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "StopImpl called";
 
   // Kill any in-flight method calls.
   weak_ptr_factory_.InvalidateWeakPtrs();
   wait_interval_.reset();
   poll_timer_.Stop();
   if (started_) {
     started_ = false;
   }
   if (!callback.is_null())
     callback.Run();
 }
 
-void SyncScheduler::DoCanaryJob() {
+void SyncSchedulerImpl::DoCanaryJob() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "Do canary job";
   DoPendingJobIfPossible(true);
 }
 
-void SyncScheduler::DoPendingJobIfPossible(bool is_canary_job) {
+void SyncSchedulerImpl::DoPendingJobIfPossible(bool is_canary_job) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SyncSessionJob* job_to_execute = NULL;
   if (mode_ == CONFIGURATION_MODE && wait_interval_.get()
       && wait_interval_->pending_configure_job.get()) {
     SDVLOG(2) << "Found pending configure job";
     job_to_execute = wait_interval_->pending_configure_job.get();
   } else if (mode_ == NORMAL_MODE && pending_nudge_.get()) {
     SDVLOG(2) << "Found pending nudge job";
     // Pending jobs mostly have time from the past. Reset it so this job
     // will get executed.
@@ skipping 11 matching lines @@
   }
 
   if (job_to_execute != NULL) {
     SDVLOG(2) << "Executing pending job";
     SyncSessionJob copy = *job_to_execute;
     copy.is_canary_job = is_canary_job;
     DoSyncSessionJob(copy);
   }
 }
 
-SyncSession* SyncScheduler::CreateSyncSession(const SyncSourceInfo& source) {
+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()));
 
   return session;
 }
 
-void SyncScheduler::PollTimerCallback() {
+void SyncSchedulerImpl::PollTimerCallback() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   ModelSafeRoutingInfo r;
   ModelTypePayloadMap types_with_payloads =
       ModelSafeRoutingInfoToPayloadMap(r, std::string());
   SyncSourceInfo info(GetUpdatesCallerInfo::PERIODIC, types_with_payloads);
   SyncSession* s = CreateSyncSession(info);
 
   SyncSessionJob job(SyncSessionJob::POLL, TimeTicks::Now(),
                      make_linked_ptr(s),
                      false,
                      ConfigurationParams(),
                      FROM_HERE);
 
   ScheduleSyncSessionJob(job);
 }
 
-void SyncScheduler::Unthrottle() {
+void SyncSchedulerImpl::Unthrottle() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   DCHECK_EQ(WaitInterval::THROTTLED, wait_interval_->mode);
   SDVLOG(2) << "Unthrottled.";
   DoCanaryJob();
   wait_interval_.reset();
 }
 
-void SyncScheduler::Notify(SyncEngineEvent::EventCause cause) {
+void SyncSchedulerImpl::Notify(SyncEngineEvent::EventCause cause) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   session_context_->NotifyListeners(SyncEngineEvent(cause));
 }
 
-bool SyncScheduler::IsBackingOff() const {
+bool SyncSchedulerImpl::IsBackingOff() const {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   return wait_interval_.get() && wait_interval_->mode ==
       WaitInterval::EXPONENTIAL_BACKOFF;
 }
 
-void SyncScheduler::OnSilencedUntil(const base::TimeTicks& silenced_until) {
+void SyncSchedulerImpl::OnSilencedUntil(
+    const base::TimeTicks& silenced_until) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   wait_interval_.reset(new WaitInterval(WaitInterval::THROTTLED,
                                         silenced_until - TimeTicks::Now()));
   wait_interval_->timer.Start(FROM_HERE, wait_interval_->length, this,
-      &SyncScheduler::Unthrottle);
+      &SyncSchedulerImpl::Unthrottle);
 }
 
-bool SyncScheduler::IsSyncingCurrentlySilenced() {
+bool SyncSchedulerImpl::IsSyncingCurrentlySilenced() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   return wait_interval_.get() && wait_interval_->mode ==
       WaitInterval::THROTTLED;
 }
 
-void SyncScheduler::OnReceivedShortPollIntervalUpdate(
+void SyncSchedulerImpl::OnReceivedShortPollIntervalUpdate(
     const base::TimeDelta& new_interval) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   syncer_short_poll_interval_seconds_ = new_interval;
 }
 
-void SyncScheduler::OnReceivedLongPollIntervalUpdate(
+void SyncSchedulerImpl::OnReceivedLongPollIntervalUpdate(
     const base::TimeDelta& new_interval) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   syncer_long_poll_interval_seconds_ = new_interval;
 }
 
-void SyncScheduler::OnReceivedSessionsCommitDelay(
+void SyncSchedulerImpl::OnReceivedSessionsCommitDelay(
     const base::TimeDelta& new_delay) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   sessions_commit_delay_ = new_delay;
 }
 
-void SyncScheduler::OnShouldStopSyncingPermanently() {
+void SyncSchedulerImpl::OnShouldStopSyncingPermanently() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "OnShouldStopSyncingPermanently";
   syncer_->RequestEarlyExit();  // Thread-safe.
   Notify(SyncEngineEvent::STOP_SYNCING_PERMANENTLY);
 }
 
-void SyncScheduler::OnActionableError(
+void SyncSchedulerImpl::OnActionableError(
     const sessions::SyncSessionSnapshot& snap) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG(2) << "OnActionableError";
   SyncEngineEvent event(SyncEngineEvent::ACTIONABLE_ERROR);
   event.snapshot = snap;
   session_context_->NotifyListeners(event);
 }
 
-void SyncScheduler::OnSyncProtocolError(
+void SyncSchedulerImpl::OnSyncProtocolError(
     const sessions::SyncSessionSnapshot& snapshot) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   if (ShouldRequestEarlyExit(
           snapshot.model_neutral_state().sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     syncer_->RequestEarlyExit();  // Thread-safe.
   }
   if (IsActionableError(snapshot.model_neutral_state().sync_protocol_error))
     OnActionableError(snapshot);
 }
 
-void SyncScheduler::set_notifications_enabled(bool notifications_enabled) {
+void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   session_context_->set_notifications_enabled(notifications_enabled);
 }
 
-base::TimeDelta SyncScheduler::sessions_commit_delay() const {
+base::TimeDelta SyncSchedulerImpl::GetSessionsCommitDelay() const {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   return sessions_commit_delay_;
 }
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer