[Sync] Move //sync to //components/sync.

components/sync/engine_impl/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 "components/sync/engine_impl/sync_scheduler_impl.h"
 
 #include <algorithm>
 #include <cstring>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "sync/engine/backoff_delay_provider.h"
-#include "sync/engine/syncer.h"
-#include "sync/protocol/proto_enum_conversions.h"
-#include "sync/protocol/sync.pb.h"
-#include "sync/util/data_type_histogram.h"
-#include "sync/util/logging.h"
+#include "components/sync/base/data_type_histogram.h"
+#include "components/sync/base/logging.h"
+#include "components/sync/engine_impl/backoff_delay_provider.h"
+#include "components/sync/engine_impl/syncer.h"
+#include "components/sync/protocol/proto_enum_conversions.h"
+#include "components/sync/protocol/sync.pb.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace syncer {
 
 using sessions::SyncSession;
 using sessions::SyncSessionSnapshot;
 using sync_pb::GetUpdatesCallerInfo;
 
@@ skipping 37 matching lines @@
       return true;
     // Make UNKNOWN_ERROR a NOTREACHED. All the other error should be explicitly
     // handled.
     case UNKNOWN_ERROR:
       NOTREACHED();
       return false;
   }
   return false;
 }
 
-bool IsActionableError(
-    const SyncProtocolError& error) {
+bool IsActionableError(const SyncProtocolError& error) {
   return (error.action != UNKNOWN_ACTION);
 }
 
 void RunAndReset(base::Closure* task) {
   DCHECK(task);
   if (task->is_null())
     return;
   task->Run();
   task->Reset();
 }
@@ skipping 19 matching lines @@
     default;
 ConfigurationParams::~ConfigurationParams() {}
 
 ClearParams::ClearParams(const base::Closure& report_success_task)
     : report_success_task(report_success_task) {
   DCHECK(!report_success_task.is_null());
 }
 ClearParams::ClearParams(const ClearParams& other) = default;
 ClearParams::~ClearParams() {}
 
-SyncSchedulerImpl::WaitInterval::WaitInterval()
-    : mode(UNKNOWN) {}
+SyncSchedulerImpl::WaitInterval::WaitInterval() : mode(UNKNOWN) {}
 
 SyncSchedulerImpl::WaitInterval::WaitInterval(Mode mode, TimeDelta length)
     : mode(mode), length(length) {}
 
 SyncSchedulerImpl::WaitInterval::~WaitInterval() {}
 
-#define ENUM_CASE(x) case x: return #x; break;
+#define ENUM_CASE(x) \
+  case x:            \
+    return #x;       \
+    break;
 
 const char* SyncSchedulerImpl::WaitInterval::GetModeString(Mode mode) {
   switch (mode) {
     ENUM_CASE(UNKNOWN);
     ENUM_CASE(EXPONENTIAL_BACKOFF);
     ENUM_CASE(THROTTLED);
   }
   NOTREACHED();
   return "";
 }
@@ skipping 15 matching lines @@
   }
 }
 
 // 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)             \
+#define SDVLOG_LOC(from_here, verbose_level) \
   DVLOG_LOC(from_here, verbose_level) << name_ << ": "
 
 SyncSchedulerImpl::SyncSchedulerImpl(const std::string& name,
                                      BackoffDelayProvider* delay_provider,
                                      sessions::SyncSessionContext* context,
                                      Syncer* syncer)
     : name_(name),
       started_(false),
       syncer_short_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultShortPollIntervalSeconds)),
       syncer_long_poll_interval_seconds_(
           TimeDelta::FromSeconds(kDefaultLongPollIntervalSeconds)),
       mode_(CONFIGURATION_MODE),
       delay_provider_(delay_provider),
       syncer_(syncer),
       session_context_(context),
       next_sync_session_job_priority_(NORMAL_PRIORITY),
       weak_ptr_factory_(this),
       weak_ptr_factory_for_weak_handle_(this) {
-  weak_handle_this_ = MakeWeakHandle(
-      weak_ptr_factory_for_weak_handle_.GetWeakPtr());
+  weak_handle_this_ =
+      MakeWeakHandle(weak_ptr_factory_for_weak_handle_.GetWeakPtr());
 }
 
 SyncSchedulerImpl::~SyncSchedulerImpl() {
   DCHECK(CalledOnValidThread());
   Stop();
 }
 
 void SyncSchedulerImpl::OnCredentialsUpdated() {
   DCHECK(CalledOnValidThread());
 
   if (HttpResponse::SYNC_AUTH_ERROR ==
       session_context_->connection_manager()->server_status()) {
     OnServerConnectionErrorFixed();
   }
 }
 
 void SyncSchedulerImpl::OnConnectionStatusChange() {
-  if (HttpResponse::CONNECTION_UNAVAILABLE  ==
+  if (HttpResponse::CONNECTION_UNAVAILABLE ==
       session_context_->connection_manager()->server_status()) {
     // Optimistically assume that the connection is fixed and try
     // connecting.
     OnServerConnectionErrorFixed();
   }
 }
 
 void SyncSchedulerImpl::OnServerConnectionErrorFixed() {
   // There could be a pending nudge or configuration job in several cases:
   //
   // 1. We're in exponential backoff.
   // 2. We're silenced / throttled.
   // 3. A nudge was saved previously due to not having a valid auth token.
   // 4. A nudge was scheduled + saved while in configuration mode.
   //
   // In all cases except (2), we want to retry contacting the server. We
   // call TryCanaryJob to achieve this, and note that nothing -- not even a
   // canary job -- can bypass a THROTTLED WaitInterval. The only thing that
   // has the authority to do that is the Unthrottle timer.
   TryCanaryJob();
 }
 
 void SyncSchedulerImpl::Start(Mode mode, base::Time last_poll_time) {
   DCHECK(CalledOnValidThread());
   std::string thread_name = base::PlatformThread::GetName();
   if (thread_name.empty())
     thread_name = "<Main thread>";
-  SDVLOG(2) << "Start called from thread "
-            << thread_name << " with mode " << GetModeString(mode);
+  SDVLOG(2) << "Start called from thread " << thread_name << " with mode "
+            << GetModeString(mode);
   if (!started_) {
     started_ = true;
     SendInitialSnapshot();
   }
 
   DCHECK(syncer_.get());
 
   if (mode == CLEAR_SERVER_DATA_MODE) {
     DCHECK_EQ(mode_, CONFIGURATION_MODE);
   }
@@ skipping 32 matching lines @@
   ModelTypeSet throttled_types = nudge_tracker_.GetThrottledTypes();
   return Difference(enabled_protocol_types, throttled_types);
 }
 
 void SyncSchedulerImpl::SendInitialSnapshot() {
   DCHECK(CalledOnValidThread());
   std::unique_ptr<SyncSession> dummy(
       SyncSession::Build(session_context_, this));
   SyncCycleEvent event(SyncCycleEvent::STATUS_CHANGED);
   event.snapshot = dummy->TakeSnapshot();
-  FOR_EACH_OBSERVER(SyncEngineEventListener,
-                    *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
                     OnSyncCycleEvent(event));
 }
 
 namespace {
 
 // Helper to extract the routing info corresponding to types in
 // |types_to_download| from |current_routes|.
-void BuildModelSafeParams(
-    ModelTypeSet types_to_download,
-    const ModelSafeRoutingInfo& current_routes,
-    ModelSafeRoutingInfo* result_routes) {
+void BuildModelSafeParams(ModelTypeSet types_to_download,
+                          const ModelSafeRoutingInfo& current_routes,
+                          ModelSafeRoutingInfo* result_routes) {
   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;
   }
 }
 
 }  // namespace.
 
 void SyncSchedulerImpl::ScheduleConfiguration(
     const ConfigurationParams& params) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsConfigRelatedUpdateSourceValue(params.source));
   DCHECK_EQ(CONFIGURATION_MODE, mode_);
   DCHECK(!params.ready_task.is_null());
   CHECK(started_) << "Scheduler must be running to configure.";
   SDVLOG(2) << "Reconfiguring syncer.";
 
   // Only one configuration is allowed at a time. Verify we're not waiting
   // for a pending configure job.
   DCHECK(!pending_configure_params_);
 
   ModelSafeRoutingInfo restricted_routes;
-  BuildModelSafeParams(params.types_to_download,
-                       params.routing_info,
+  BuildModelSafeParams(params.types_to_download, params.routing_info,
                        &restricted_routes);
   session_context_->SetRoutingInfo(restricted_routes);
 
   // Only reconfigure if we have types to download.
   if (!params.types_to_download.Empty()) {
     pending_configure_params_.reset(new ConfigurationParams(params));
     TrySyncSessionJob();
   } else {
     SDVLOG(2) << "No change in routing info, calling ready task directly.";
     params.ready_task.Run();
@@ skipping 51 matching lines @@
 
   return true;
 }
 
 void SyncSchedulerImpl::ScheduleLocalNudge(
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
   DCHECK(!types.Empty());
 
-  SDVLOG_LOC(nudge_location, 2)
-      << "Scheduling sync because of local change to "
-      << ModelTypeSetToString(types);
+  SDVLOG_LOC(nudge_location, 2) << "Scheduling sync because of local change to "
+                                << ModelTypeSetToString(types);
   UpdateNudgeTimeRecords(types);
   base::TimeDelta nudge_delay = nudge_tracker_.RecordLocalChange(types);
   ScheduleNudgeImpl(nudge_delay, nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleLocalRefreshRequest(
     ModelTypeSet types,
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
   DCHECK(!types.Empty());
@@ skipping 35 matching lines @@
     const tracked_objects::Location& nudge_location) {
   DCHECK(CalledOnValidThread());
   CHECK(!syncer_->IsSyncing());
 
   if (!started_) {
     SDVLOG_LOC(nudge_location, 2)
         << "Dropping nudge, scheduler is not running.";
     return;
   }
 
-  SDVLOG_LOC(nudge_location, 2)
-      << "In ScheduleNudgeImpl with delay "
-      << delay.InMilliseconds() << " ms";
+  SDVLOG_LOC(nudge_location, 2) << "In ScheduleNudgeImpl with delay "
+                                << delay.InMilliseconds() << " ms";
 
   if (!CanRunNudgeJobNow(NORMAL_PRIORITY))
     return;
 
   TimeTicks incoming_run_time = TimeTicks::Now() + delay;
   if (!scheduled_nudge_time_.is_null() &&
-    (scheduled_nudge_time_ < incoming_run_time)) {
+      (scheduled_nudge_time_ < incoming_run_time)) {
     // Old job arrives sooner than this one.  Don't reschedule it.
     return;
   }
 
   // Either there is no existing nudge in flight or the incoming nudge should be
   // made to arrive first (preempt) the existing nudge.  We reschedule in either
   // case.
-  SDVLOG_LOC(nudge_location, 2)
-      << "Scheduling a nudge with "
-      << delay.InMilliseconds() << " ms delay";
+  SDVLOG_LOC(nudge_location, 2) << "Scheduling a nudge with "
+                                << delay.InMilliseconds() << " ms delay";
   scheduled_nudge_time_ = incoming_run_time;
   pending_wakeup_timer_.Start(
-      nudge_location,
-      delay,
-      base::Bind(&SyncSchedulerImpl::PerformDelayedNudge,
-                 weak_ptr_factory_.GetWeakPtr()));
+      nudge_location, delay, base::Bind(&SyncSchedulerImpl::PerformDelayedNudge,
+                                        weak_ptr_factory_.GetWeakPtr()));
 }
 
 const char* SyncSchedulerImpl::GetModeString(SyncScheduler::Mode mode) {
   switch (mode) {
     ENUM_CASE(CONFIGURATION_MODE);
     ENUM_CASE(CLEAR_SERVER_DATA_MODE);
     ENUM_CASE(NORMAL_MODE);
   }
   return "";
 }
 
 void SyncSchedulerImpl::SetDefaultNudgeDelay(base::TimeDelta delay_ms) {
   DCHECK(CalledOnValidThread());
   nudge_tracker_.SetDefaultNudgeDelay(delay_ms);
 }
 
 void SyncSchedulerImpl::DoNudgeSyncSessionJob(JobPriority priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(CanRunNudgeJobNow(priority));
 
   DVLOG(2) << "Will run normal mode sync cycle with types "
            << ModelTypeSetToString(session_context_->GetEnabledTypes());
   std::unique_ptr<SyncSession> session(
       SyncSession::Build(session_context_, this));
-  bool success = syncer_->NormalSyncShare(
-      GetEnabledAndUnthrottledTypes(), &nudge_tracker_, session.get());
+  bool success = syncer_->NormalSyncShare(GetEnabledAndUnthrottledTypes(),
+                                          &nudge_tracker_, session.get());
 
   if (success) {
     // That cycle took care of any outstanding work we had.
     SDVLOG(2) << "Nudge succeeded.";
     nudge_tracker_.RecordSuccessfulSyncCycle();
     scheduled_nudge_time_ = base::TimeTicks();
     HandleSuccess();
 
     // If this was a canary, we may need to restart the poll timer (the poll
     // timer may have fired while the scheduler was in an error state, ignoring
@@ skipping 17 matching lines @@
     RunAndReset(&pending_configure_params_->retry_task);
     return;
   }
 
   SDVLOG(2) << "Will run configure SyncShare with types "
             << ModelTypeSetToString(session_context_->GetEnabledTypes());
   std::unique_ptr<SyncSession> session(
       SyncSession::Build(session_context_, this));
   bool success = syncer_->ConfigureSyncShare(
       pending_configure_params_->types_to_download,
-      pending_configure_params_->source,
-      session.get());
+      pending_configure_params_->source, session.get());
 
   if (success) {
     SDVLOG(2) << "Configure succeeded.";
     pending_configure_params_->ready_task.Run();
     pending_configure_params_.reset();
     HandleSuccess();
   } else {
     HandleFailure(session->status_controller().model_neutral_state());
     // Sync cycle might receive response from server that causes scheduler to
     // stop and draws pending_configure_params_ invalid.
@@ skipping 36 matching lines @@
     const sessions::ModelNeutralState& model_neutral_state) {
   if (IsCurrentlyThrottled()) {
     SDVLOG(2) << "Was throttled during previous sync cycle.";
   } else if (!IsBackingOff()) {
     // Setup our backoff if this is our first such failure.
     TimeDelta length = delay_provider_->GetDelay(
         delay_provider_->GetInitialDelay(model_neutral_state));
     wait_interval_.reset(
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
-        << wait_interval_->length.InMilliseconds() << "ms.";
+              << wait_interval_->length.InMilliseconds() << "ms.";
   } else {
     // Increase our backoff interval and schedule another retry.
     TimeDelta length = delay_provider_->GetDelay(wait_interval_->length);
     wait_interval_.reset(
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
-        << wait_interval_->length.InMilliseconds() << "ms.";
+              << wait_interval_->length.InMilliseconds() << "ms.";
   }
   RestartWaiting();
 }
 
 void SyncSchedulerImpl::DoPollSyncSessionJob() {
   SDVLOG(2) << "Polling with types "
             << ModelTypeSetToString(GetEnabledAndUnthrottledTypes());
   std::unique_ptr<SyncSession> session(
       SyncSession::Build(session_context_, this));
-  bool success = syncer_->PollSyncShare(
-      GetEnabledAndUnthrottledTypes(),
-      session.get());
+  bool success =
+      syncer_->PollSyncShare(GetEnabledAndUnthrottledTypes(), session.get());
 
   // Only restart the timer if the poll succeeded. Otherwise rely on normal
   // failure handling to retry with backoff.
   if (success) {
     AdjustPolling(FORCE_RESET);
     HandleSuccess();
   } else {
     HandleFailure(session->status_controller().model_neutral_state());
   }
 }
 
 void SyncSchedulerImpl::UpdateNudgeTimeRecords(ModelTypeSet types) {
   DCHECK(CalledOnValidThread());
   base::TimeTicks now = TimeTicks::Now();
   // Update timing information for how often datatypes are triggering nudges.
   for (ModelTypeSet::Iterator iter = types.First(); iter.Good(); iter.Inc()) {
     base::TimeTicks previous = last_local_nudges_by_model_type_[iter.Get()];
     last_local_nudges_by_model_type_[iter.Get()] = now;
     if (previous.is_null())
       continue;
 
 #define PER_DATA_TYPE_MACRO(type_str) \
-    SYNC_FREQ_HISTOGRAM("Sync.Freq" type_str, now - previous);
+  SYNC_FREQ_HISTOGRAM("Sync.Freq" type_str, now - previous);
     SYNC_DATA_TYPE_HISTOGRAM(iter.Get());
 #undef PER_DATA_TYPE_MACRO
   }
 }
 
 TimeDelta SyncSchedulerImpl::GetPollInterval() {
   return (!session_context_->notifications_enabled() ||
-          !session_context_->ShouldFetchUpdatesBeforeCommit()) ?
-      syncer_short_poll_interval_seconds_ :
-      syncer_long_poll_interval_seconds_;
+          !session_context_->ShouldFetchUpdatesBeforeCommit())
+             ? syncer_short_poll_interval_seconds_
+             : syncer_long_poll_interval_seconds_;
 }
 
 void SyncSchedulerImpl::AdjustPolling(PollAdjustType type) {
   DCHECK(CalledOnValidThread());
   if (!started_)
     return;
 
   TimeDelta poll_interval = GetPollInterval();
   TimeDelta poll_delay = poll_interval;
   const TimeTicks now = TimeTicks::Now();
@@ skipping 30 matching lines @@
   // Adjust poll rate. Start will reset the timer if it was already running.
   poll_timer_.Start(FROM_HERE, poll_delay, this,
                     &SyncSchedulerImpl::PollTimerCallback);
 }
 
 void SyncSchedulerImpl::RestartWaiting() {
   CHECK(wait_interval_.get());
   DCHECK(wait_interval_->length >= TimeDelta::FromSeconds(0));
   NotifyRetryTime(base::Time::Now() + wait_interval_->length);
   SDVLOG(2) << "Starting WaitInterval timer of length "
-      << wait_interval_->length.InMilliseconds() << "ms.";
+            << wait_interval_->length.InMilliseconds() << "ms.";
   if (wait_interval_->mode == WaitInterval::THROTTLED) {
-    pending_wakeup_timer_.Start(
-        FROM_HERE,
-        wait_interval_->length,
-        base::Bind(&SyncSchedulerImpl::Unthrottle,
-                   weak_ptr_factory_.GetWeakPtr()));
+    pending_wakeup_timer_.Start(FROM_HERE, wait_interval_->length,
+                                base::Bind(&SyncSchedulerImpl::Unthrottle,
+                                           weak_ptr_factory_.GetWeakPtr()));
   } else {
     pending_wakeup_timer_.Start(
-        FROM_HERE,
-        wait_interval_->length,
+        FROM_HERE, wait_interval_->length,
         base::Bind(&SyncSchedulerImpl::ExponentialBackoffRetry,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
 void SyncSchedulerImpl::Stop() {
   DCHECK(CalledOnValidThread());
   SDVLOG(2) << "Stop called";
 
   // Kill any in-flight method calls.
@@ skipping 57 matching lines @@
   }
 
   if (IsBackingOff() && !pending_wakeup_timer_.IsRunning()) {
     // If we succeeded, our wait interval would have been cleared.  If it hasn't
     // been cleared, then we should increase our backoff interval and schedule
     // another retry.
     TimeDelta length = delay_provider_->GetDelay(wait_interval_->length);
     wait_interval_.reset(
         new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF, length));
     SDVLOG(2) << "Sync cycle failed.  Will back off for "
-        << wait_interval_->length.InMilliseconds() << "ms.";
+              << wait_interval_->length.InMilliseconds() << "ms.";
     RestartWaiting();
   }
 }
 
 void SyncSchedulerImpl::PollTimerCallback() {
   DCHECK(CalledOnValidThread());
   CHECK(!syncer_->IsSyncing());
 
   TrySyncSessionJob();
 }
@@ skipping 21 matching lines @@
 
 void SyncSchedulerImpl::TypeUnthrottle(base::TimeTicks unthrottle_time) {
   DCHECK(CalledOnValidThread());
   nudge_tracker_.UpdateTypeThrottlingState(unthrottle_time);
   NotifyThrottledTypesChanged(nudge_tracker_.GetThrottledTypes());
 
   if (nudge_tracker_.IsAnyTypeThrottled()) {
     const base::TimeTicks now = base::TimeTicks::Now();
     base::TimeDelta time_until_next_unthrottle =
         nudge_tracker_.GetTimeUntilNextUnthrottle(now);
-    type_unthrottle_timer_.Start(
-        FROM_HERE,
-        time_until_next_unthrottle,
-        base::Bind(&SyncSchedulerImpl::TypeUnthrottle,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   now + time_until_next_unthrottle));
+    type_unthrottle_timer_.Start(FROM_HERE, time_until_next_unthrottle,
+                                 base::Bind(&SyncSchedulerImpl::TypeUnthrottle,
+                                            weak_ptr_factory_.GetWeakPtr(),
+                                            now + time_until_next_unthrottle));
   }
 
   // Maybe this is a good time to run a nudge job.  Let's try it.
   if (nudge_tracker_.IsSyncRequired() && CanRunNudgeJobNow(NORMAL_PRIORITY))
     TrySyncSessionJob();
 }
 
 void SyncSchedulerImpl::PerformDelayedNudge() {
   // Circumstances may have changed since we scheduled this delayed nudge.
   // We must check to see if it's OK to run the job before we do so.
   if (CanRunNudgeJobNow(NORMAL_PRIORITY))
     TrySyncSessionJob();
 
   // We're not responsible for setting up any retries here.  The functions that
   // first put us into a state that prevents successful sync cycles (eg. global
   // throttling, type throttling, network errors, transient errors) will also
   // setup the appropriate retry logic (eg. retry after timeout, exponential
   // backoff, retry when the network changes).
 }
 
 void SyncSchedulerImpl::ExponentialBackoffRetry() {
   TryCanaryJob();
 }
 
 void SyncSchedulerImpl::NotifyRetryTime(base::Time retry_time) {
-  FOR_EACH_OBSERVER(SyncEngineEventListener,
-                    *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
                     OnRetryTimeChanged(retry_time));
 }
 
 void SyncSchedulerImpl::NotifyThrottledTypesChanged(ModelTypeSet types) {
-  FOR_EACH_OBSERVER(SyncEngineEventListener,
-                    *session_context_->listeners(),
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
                     OnThrottledTypesChanged(types));
 }
 
 bool SyncSchedulerImpl::IsBackingOff() const {
   DCHECK(CalledOnValidThread());
-  return wait_interval_.get() && wait_interval_->mode ==
-      WaitInterval::EXPONENTIAL_BACKOFF;
+  return wait_interval_.get() &&
+         wait_interval_->mode == WaitInterval::EXPONENTIAL_BACKOFF;
 }
 
 void SyncSchedulerImpl::OnThrottled(const base::TimeDelta& throttle_duration) {
   DCHECK(CalledOnValidThread());
-  wait_interval_.reset(new WaitInterval(WaitInterval::THROTTLED,
-                                        throttle_duration));
+  wait_interval_.reset(
+      new WaitInterval(WaitInterval::THROTTLED, throttle_duration));
   NotifyRetryTime(base::Time::Now() + wait_interval_->length);
   NotifyThrottledTypesChanged(ModelTypeSet::All());
 }
 
 void SyncSchedulerImpl::OnTypesThrottled(
     ModelTypeSet types,
     const base::TimeDelta& throttle_duration) {
   base::TimeTicks now = base::TimeTicks::Now();
 
   SDVLOG(1) << "Throttling " << ModelTypeSetToString(types) << " for "
             << throttle_duration.InMinutes() << " minutes.";
 
   nudge_tracker_.SetTypesThrottledUntil(types, throttle_duration, now);
   base::TimeDelta time_until_next_unthrottle =
       nudge_tracker_.GetTimeUntilNextUnthrottle(now);
-  type_unthrottle_timer_.Start(
-      FROM_HERE,
-      time_until_next_unthrottle,
-      base::Bind(&SyncSchedulerImpl::TypeUnthrottle,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 now + time_until_next_unthrottle));
+  type_unthrottle_timer_.Start(FROM_HERE, time_until_next_unthrottle,
+                               base::Bind(&SyncSchedulerImpl::TypeUnthrottle,
+                                          weak_ptr_factory_.GetWeakPtr(),
+                                          now + time_until_next_unthrottle));
   NotifyThrottledTypesChanged(nudge_tracker_.GetThrottledTypes());
 }
 
 bool SyncSchedulerImpl::IsCurrentlyThrottled() {
   DCHECK(CalledOnValidThread());
-  return wait_interval_.get() && wait_interval_->mode ==
-      WaitInterval::THROTTLED;
+  return wait_interval_.get() &&
+         wait_interval_->mode == WaitInterval::THROTTLED;
 }
 
 void SyncSchedulerImpl::OnReceivedShortPollIntervalUpdate(
     const base::TimeDelta& new_interval) {
   DCHECK(CalledOnValidThread());
   if (new_interval == syncer_short_poll_interval_seconds_)
     return;
   SDVLOG(1) << "Updating short poll interval to " << new_interval.InMinutes()
             << " minutes.";
   syncer_short_poll_interval_seconds_ = new_interval;
@@ skipping 26 matching lines @@
 
 void SyncSchedulerImpl::OnSyncProtocolError(
     const SyncProtocolError& sync_protocol_error) {
   DCHECK(CalledOnValidThread());
   if (ShouldRequestEarlyExit(sync_protocol_error)) {
     SDVLOG(2) << "Sync Scheduler requesting early exit.";
     Stop();
   }
   if (IsActionableError(sync_protocol_error)) {
     SDVLOG(2) << "OnActionableError";
-    FOR_EACH_OBSERVER(SyncEngineEventListener,
-                      *session_context_->listeners(),
+    FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
                       OnActionableError(sync_protocol_error));
   }
 }
 
 void SyncSchedulerImpl::OnReceivedGuRetryDelay(const base::TimeDelta& delay) {
   nudge_tracker_.SetNextRetryTime(TimeTicks::Now() + delay);
   retry_timer_.Start(FROM_HERE, delay, this,
                      &SyncSchedulerImpl::RetryTimerCallback);
 }
 
 void SyncSchedulerImpl::OnReceivedMigrationRequest(ModelTypeSet types) {
-    FOR_EACH_OBSERVER(SyncEngineEventListener,
-                      *session_context_->listeners(),
-                      OnMigrationRequested(types));
+  FOR_EACH_OBSERVER(SyncEngineEventListener, *session_context_->listeners(),
+                    OnMigrationRequested(types));
 }
 
 void SyncSchedulerImpl::SetNotificationsEnabled(bool notifications_enabled) {
   DCHECK(CalledOnValidThread());
   session_context_->set_notifications_enabled(notifications_enabled);
   if (notifications_enabled)
     nudge_tracker_.OnInvalidationsEnabled();
   else
     nudge_tracker_.OnInvalidationsDisabled();
 }
 
 #undef SDVLOG_LOC
 
 #undef SDVLOG
 
 #undef SLOG
 
 #undef ENUM_CASE
 
 }  // namespace syncer