Part 2 of repairing regressions to my old clang check plugins so Nico can

chrome/browser/sync/engine/syncer_thread2.cc

 // Copyright (c) 2011 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 "chrome/browser/sync/engine/syncer_thread2.h"
 
 #include <algorithm>
 
 #include "base/rand_util.h"
 #include "chrome/browser/sync/engine/syncer.h"
@@ skipping 24 matching lines @@
   Mode mode;
 
   // This bool is set to true if we have observed a nudge during this
   // interval and mode == EXPONENTIAL_BACKOFF.
   bool had_nudge;
   base::TimeDelta length;
   base::OneShotTimer<SyncerThread> timer;
   WaitInterval(Mode mode, base::TimeDelta length);
 };
 
+struct SyncerThread::SyncSessionJob {
+  SyncSessionJobPurpose purpose;
+  base::TimeTicks scheduled_start;
+  linked_ptr<sessions::SyncSession> session;
+};
+
 SyncerThread::DelayProvider::DelayProvider() {}
 SyncerThread::DelayProvider::~DelayProvider() {}
 
 TimeDelta SyncerThread::DelayProvider::GetDelay(
     const base::TimeDelta& last_delay) {
   return SyncerThread::GetRecommendedDelay(last_delay);
 }
 
 SyncerThread::WaitInterval::WaitInterval(Mode mode, TimeDelta length)
     : mode(mode), had_nudge(false), length(length) { }
@@ skipping 26 matching lines @@
 }
 
 void SyncerThread::StartImpl(Mode mode) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   DCHECK(!session_context_->account_name().empty());
   DCHECK(syncer_.get());
   mode_ = mode;
   AdjustPolling(NULL);  // Will kick start poll timer if needed.
 }
 
-bool SyncerThread::ShouldRunJob(SyncSessionJob::Purpose purpose,
+bool SyncerThread::ShouldRunJob(SyncSessionJobPurpose purpose,
     const TimeTicks& scheduled_start) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
 
   // Check wait interval.
   if (wait_interval_.get()) {
     if (wait_interval_->mode == WaitInterval::THROTTLED)
       return false;
 
     DCHECK_EQ(wait_interval_->mode, WaitInterval::EXPONENTIAL_BACKOFF);
-    DCHECK(purpose == SyncSessionJob::POLL ||
-           purpose == SyncSessionJob::NUDGE);
-    if ((purpose != SyncSessionJob::NUDGE) || wait_interval_->had_nudge)
+    DCHECK(purpose == POLL ||
+           purpose == NUDGE);
+    if ((purpose != NUDGE) || wait_interval_->had_nudge)
       return false;
   }
 
   // Mode / purpose contract (See 'Mode' enum in header). Don't run jobs that
   // were intended for a normal sync if we are in configuration mode, and vice
   // versa.
   switch (mode_) {
     case CONFIGURATION_MODE:
-      if (purpose != SyncSessionJob::CONFIGURATION)
+      if (purpose != CONFIGURATION)
         return false;
       break;
     case NORMAL_MODE:
-      if (purpose != SyncSessionJob::POLL && purpose != SyncSessionJob::NUDGE)
+      if (purpose != POLL && purpose != NUDGE)
         return false;
       break;
     default:
       NOTREACHED() << "Unknown SyncerThread Mode: " << mode_;
       return false;
   }
 
   // Continuation NUDGE tasks have priority over POLLs because they are the
   // only tasks that trigger exponential backoff, so this prevents them from
   // being starved from running (e.g. due to a very, very low poll interval,
   // such as 0ms). It's rare that this would ever matter in practice.
-  if (purpose == SyncSessionJob::POLL && (pending_nudge_.get() &&
+  if (purpose == POLL && (pending_nudge_.get() &&
       pending_nudge_->session->source().first ==
           GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION)) {
     return false;
   }
 
   // Freshness condition.
-  if (purpose == SyncSessionJob::NUDGE &&
+  if (purpose == NUDGE &&
       (scheduled_start < last_sync_session_end_time_)) {
     return false;
   }
 
   return server_connection_ok_;
 }
 
 namespace {
 GetUpdatesCallerInfo::GetUpdatesSource GetUpdatesFromNudgeSource(
     NudgeSource source) {
@@ skipping 30 matching lines @@
   }
 
   thread_.message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
       this, &SyncerThread::ScheduleNudgeImpl, delay, source, types));
 }
 
 void SyncerThread::ScheduleNudgeImpl(const TimeDelta& delay,
     NudgeSource source, const ModelTypeBitSet& model_types) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   TimeTicks rough_start = TimeTicks::Now() + delay;
-  if (!ShouldRunJob(SyncSessionJob::NUDGE, rough_start))
+  if (!ShouldRunJob(NUDGE, rough_start))
     return;
 
   // Note we currently nudge for all types regardless of the ones incurring
   // the nudge.  Doing different would throw off some syncer commands like
   // CleanupDisabledTypes.  We may want to change this in the future.
   ModelSafeRoutingInfo routes;
   std::vector<ModelSafeWorker*> workers;
   session_context_->registrar()->GetModelSafeRoutingInfo(&routes);
   session_context_->registrar()->GetWorkers(&workers);
   SyncSourceInfo info(GetUpdatesFromNudgeSource(source), model_types);
 
   scoped_ptr<SyncSession> session(new SyncSession(
       session_context_.get(), this, info, routes, workers));
 
   if (pending_nudge_.get()) {
     if (IsBackingOff() && delay > TimeDelta::FromSeconds(1))
       return;
 
     pending_nudge_->session->Coalesce(*session.get());
     if (!IsBackingOff()) {
       return;
     } else {
       // Re-schedule the current pending nudge.
       SyncSession* s = pending_nudge_->session.get();
       session.reset(new SyncSession(s->context(), s->delegate(), s->source(),
           s->routing_info(), s->workers()));
       pending_nudge_.reset();
     }
   }
-  ScheduleSyncSessionJob(delay, SyncSessionJob::NUDGE, session.release());
+  ScheduleSyncSessionJob(delay, NUDGE, session.release());
 }
 
 // Helper to extract the routing info and workers corresponding to types in
 // |types| from |registrar|.
 void GetModelSafeParamsForTypes(const ModelTypeBitSet& types,
     ModelSafeWorkerRegistrar* registrar, ModelSafeRoutingInfo* routes,
     std::vector<ModelSafeWorker*>* workers) {
   ModelSafeRoutingInfo r_tmp;
   std::vector<ModelSafeWorker*> w_tmp;
   registrar->GetModelSafeRoutingInfo(&r_tmp);
@@ skipping 38 matching lines @@
 }
 
 void SyncerThread::ScheduleConfigImpl(const TimeDelta& delay,
     const ModelSafeRoutingInfo& routing_info,
     const std::vector<ModelSafeWorker*>& workers) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   NOTIMPLEMENTED() << "TODO(tim)";
 }
 
 void SyncerThread::ScheduleSyncSessionJob(const base::TimeDelta& delay,
-    SyncSessionJob::Purpose purpose, sessions::SyncSession* session) {
+    SyncSessionJobPurpose purpose, sessions::SyncSession* session) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   SyncSessionJob job = {purpose, TimeTicks::Now() + delay,
                         make_linked_ptr(session)};
-  if (purpose == SyncSessionJob::NUDGE) {
+  if (purpose == NUDGE) {
     DCHECK(!pending_nudge_.get() || pending_nudge_->session.get() == session);
     pending_nudge_.reset(new SyncSessionJob(job));
   }
   MessageLoop::current()->PostDelayedTask(FROM_HERE, NewRunnableMethod(this,
       &SyncerThread::DoSyncSessionJob, job), delay.InMilliseconds());
 }
 
 void SyncerThread::DoSyncSessionJob(const SyncSessionJob& job) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
 
-  if (job.purpose == SyncSessionJob::NUDGE) {
+  if (job.purpose == NUDGE) {
     DCHECK(pending_nudge_.get());
     if (pending_nudge_->session != job.session)
       return;  // Another nudge must have been scheduled in in the meantime.
     pending_nudge_.reset();
-  } else if (job.purpose == SyncSessionJob::CONFIGURATION) {
+  } else if (job.purpose == CONFIGURATION) {
     NOTIMPLEMENTED() << "TODO(tim): SyncShare [DOWNLOAD_UPDATES,APPLY_UPDATES]";
   }
 
   bool has_more_to_sync = true;
   bool did_job = false;
   while (ShouldRunJob(job.purpose, job.scheduled_start) && has_more_to_sync) {
     VLOG(1) << "SyncerThread: Calling SyncShare.";
     did_job = true;
     // Synchronously perform the sync session from this thread.
     syncer_->SyncShare(job.session.get());
@@ skipping 48 matching lines @@
     wait_interval_.reset();  // Success implies backoff relief.
     return;
   }
 
   if (old_job.session->source().first ==
       GetUpdatesCallerInfo::SYNC_CYCLE_CONTINUATION) {
     // We don't seem to have made forward progress. Start or extend backoff.
     HandleConsecutiveContinuationError(old_job);
   } else if (IsBackingOff()) {
     // We weren't continuing but we're in backoff; must have been a nudge.
-    DCHECK_EQ(SyncSessionJob::NUDGE, old_job.purpose);
+    DCHECK_EQ(NUDGE, old_job.purpose);
     DCHECK(!wait_interval_->had_nudge);
     wait_interval_->had_nudge = true;
     wait_interval_->timer.Reset();
   } else {
     // We weren't continuing and we aren't in backoff.  Schedule a normal
     // continuation.
     ScheduleNudgeImpl(TimeDelta::FromSeconds(0), NUDGE_SOURCE_CONTINUATION,
                       old_job.session->source().second);
   }
 }
 
 void SyncerThread::AdjustPolling(const SyncSessionJob* old_job) {
   DCHECK(thread_.IsRunning());
   DCHECK_EQ(MessageLoop::current(), thread_.message_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)
+  if (old_job && old_job->purpose != POLL && !rate_changed)
     poll_timer_.Reset();
 
   if (!rate_changed)
     return;
 
   // Adjust poll rate.
   poll_timer_.Stop();
   poll_timer_.Start(poll, this, &SyncerThread::PollTimerCallback);
 }
 
 void SyncerThread::HandleConsecutiveContinuationError(
     const SyncSessionJob& old_job) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   DCHECK(!IsBackingOff() || !wait_interval_->timer.IsRunning());
   SyncSession* old = old_job.session.get();
   SyncSession* s(new SyncSession(session_context_.get(), this,
       old->source(), old->routing_info(), old->workers()));
   TimeDelta length = delay_provider_->GetDelay(
       IsBackingOff() ? wait_interval_->length : TimeDelta::FromSeconds(1));
   wait_interval_.reset(new WaitInterval(WaitInterval::EXPONENTIAL_BACKOFF,
                                         length));
-  SyncSessionJob job = {SyncSessionJob::NUDGE, TimeTicks::Now() + length,
+  SyncSessionJob job = {NUDGE, TimeTicks::Now() + length,
                         make_linked_ptr(s)};
   pending_nudge_.reset(new SyncSessionJob(job));
   wait_interval_->timer.Start(length, this, &SyncerThread::DoCanaryJob);
 }
 
 // static
 TimeDelta SyncerThread::GetRecommendedDelay(const TimeDelta& last_delay) {
   if (last_delay.InSeconds() >= kMaxBackoffSeconds)
     return TimeDelta::FromSeconds(kMaxBackoffSeconds);
 
@@ skipping 32 matching lines @@
 }
 
 void SyncerThread::PollTimerCallback() {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   ModelSafeRoutingInfo r;
   std::vector<ModelSafeWorker*> w;
   session_context_->registrar()->GetModelSafeRoutingInfo(&r);
   session_context_->registrar()->GetWorkers(&w);
   SyncSourceInfo info(GetUpdatesCallerInfo::PERIODIC, ModelTypeBitSet());
   SyncSession* s = new SyncSession(session_context_.get(), this, info, r, w);
-  ScheduleSyncSessionJob(TimeDelta::FromSeconds(0), SyncSessionJob::POLL, s);
+  ScheduleSyncSessionJob(TimeDelta::FromSeconds(0), POLL, s);
 }
 
 void SyncerThread::Unthrottle() {
   DCHECK_EQ(WaitInterval::THROTTLED, wait_interval_->mode);
   wait_interval_.reset();
 }
 
 void SyncerThread::Notify(SyncEngineEvent::EventCause cause) {
   DCHECK_EQ(MessageLoop::current(), thread_.message_loop());
   session_context_->NotifyListeners(SyncEngineEvent(cause));
@@ skipping 37 matching lines @@
     const ServerConnectionEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void SyncerThread::set_notifications_enabled(bool notifications_enabled) {
   session_context_->set_notifications_enabled(notifications_enabled);
 }
 
 }  // s3
 }  // browser_sync