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

chrome/browser/sync/engine/syncer_thread2.h

 // 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.
 //
 // A class to run the syncer on a thread.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD2_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD2_H_
 #pragma once
 
 #include "base/linked_ptr.h"
@@ skipping 68 matching lines @@
   virtual void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval);
   virtual void OnShouldStopSyncingPermanently();
 
  private:
   friend class SyncerThread2Test;
 
   // State pertaining to exponential backoff or throttling periods.
   struct WaitInterval;
 
+  // An enum used to describe jobs for scheduling purposes.
+  enum SyncSessionJobPurpose {
+    // Our poll timer schedules POLL jobs periodically based on a server
+    // assigned poll interval.
+    POLL,
+    // A nudge task can come from a variety of components needing to force
+    // a sync.  The source is inferable from |session.source()|.
+    NUDGE,
+    // Typically used for fetching updates for a subset of the enabled types
+    // during initial sync or reconfiguration.  We don't run all steps of
+    // the sync cycle for these (e.g. CleanupDisabledTypes is skipped).
+    CONFIGURATION,
+  };
+
   // Internal state for every sync task that is scheduled.
-  struct SyncSessionJob {
-    // An enum used to describe jobs for scheduling purposes.
-    enum Purpose {
-      // Our poll timer schedules POLL jobs periodically based on a server
-      // assigned poll interval.
-      POLL,
-      // A nudge task can come from a variety of components needing to force
-      // a sync.  The source is inferable from |session.source()|.
-      NUDGE,
-      // Typically used for fetching updates for a subset of the enabled types
-      // during initial sync or reconfiguration.  We don't run all steps of
-      // the sync cycle for these (e.g. CleanupDisabledTypes is skipped).
-      CONFIGURATION,
-    };
-
-    Purpose purpose;
-    base::TimeTicks scheduled_start;
-    linked_ptr<sessions::SyncSession> session;
-  };
+  struct SyncSessionJob;
 
   // A component used to get time delays associated with exponential backoff.
   // Encapsulated into a class to facilitate testing.
   class DelayProvider {
    public:
     DelayProvider();
     virtual base::TimeDelta GetDelay(const base::TimeDelta& last_delay);
     virtual ~DelayProvider();
    private:
     DISALLOW_COPY_AND_ASSIGN(DelayProvider);
   };
 
   // Helper to assemble a job and post a delayed task to sync.
   void ScheduleSyncSessionJob(const base::TimeDelta& delay,
-                              SyncSessionJob::Purpose purpose,
+                              SyncSessionJobPurpose purpose,
                               sessions::SyncSession* session);
 
   // Invoke the Syncer to perform a sync.
   void DoSyncSessionJob(const SyncSessionJob& job);
 
   // Called after the Syncer has performed the sync represented by |job|, to
   // reset our state.
   void FinishSyncSessionJob(const SyncSessionJob& job);
 
   // Helper to FinishSyncSessionJob to schedule the next sync operation.
   void ScheduleNextSync(const SyncSessionJob& old_job);
 
   // Helper to configure polling intervals. Used by Start and ScheduleNextSync.
   void AdjustPolling(const SyncSessionJob* old_job);
 
   // Helper to ScheduleNextSync in case of consecutive sync errors.
   void HandleConsecutiveContinuationError(const SyncSessionJob& old_job);
 
   // Determines if it is legal to run a sync job for |purpose| at
   // |scheduled_start|.  This checks current operational mode, backoff or
   // throttling, freshness (so we don't make redundant syncs), and connection.
-  bool ShouldRunJob(SyncSessionJob::Purpose purpose,
+  bool ShouldRunJob(SyncSessionJobPurpose purpose,
                     const base::TimeTicks& scheduled_start);
 
   // 'Impl' here refers to real implementation of public functions, running on
   // |thread_|.
   void StartImpl(Mode mode);
   void ScheduleNudgeImpl(const base::TimeDelta& delay,
                          NudgeSource source,
                          const syncable::ModelTypeBitSet& model_types);
   void ScheduleConfigImpl(const base::TimeDelta& delay,
                           const ModelSafeRoutingInfo& routing_info,
@@ skipping 54 matching lines @@
 
 }  // namespace s3
 
 }  // namespace browser_sync
 
 // The SyncerThread manages its own internal thread and thus outlives it. We
 // don't need refcounting for posting tasks to this internal thread.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(browser_sync::s3::SyncerThread);
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD2_H_