sync: add a SyncSessionJobPurpose for clearing sync user data.

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"
 #include "base/observer_list.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "chrome/browser/sync/engine/nudge_source.h"
 #include "chrome/browser/sync/engine/polling_constants.h"
+#include "chrome/browser/sync/engine/syncer.h"
 #include "chrome/browser/sync/sessions/sync_session.h"
 #include "chrome/browser/sync/sessions/sync_session_context.h"
 
 namespace browser_sync {
 
 struct ServerConnectionEvent;
-class Syncer;
 
 namespace s3 {
 
 class SyncerThread : public sessions::SyncSession::Delegate {
  public:
   enum Mode {
     // In this mode, the thread only performs configuration tasks.  This is
     // designed to make the case where we want to download updates for a
     // specific type only, and not continue syncing until we are moved into
     // normal mode.
@@ skipping 22 matching lines @@
   void Stop();
 
   // The meat and potatoes.
   void ScheduleNudge(const base::TimeDelta& delay, NudgeSource source,
                      const syncable::ModelTypeBitSet& types);
   void ScheduleNudgeWithPayloads(
       const base::TimeDelta& delay, NudgeSource source,
       const sessions::TypePayloadMap& types_with_payloads);
   void ScheduleConfig(const base::TimeDelta& delay,
                       const syncable::ModelTypeBitSet& types);
+  void ScheduleClearUserData();
 
   // Change status of notifications in the SyncSessionContext.
   void set_notifications_enabled(bool notifications_enabled);
 
   // DDOS avoidance function.  Calculates how long we should wait before trying
   // again after a failed sync attempt, where the last delay was |base_delay|.
   // TODO(tim): Look at URLRequestThrottlerEntryInterface.
   static base::TimeDelta GetRecommendedDelay(const base::TimeDelta& base_delay);
 
   // SyncSession::Delegate implementation.
@@ skipping 12 matching lines @@
   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,
+    // The user invoked a function in the UI to clear their entire account
+    // and stop syncing (globally).
+    CLEAR_USER_DATA,
     // 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;
 
   // A component used to get time delays associated with exponential backoff.
@@ skipping 36 matching lines @@
 
   // '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 sessions::TypePayloadMap& types_with_payloads);
   void ScheduleConfigImpl(const base::TimeDelta& delay,
                           const ModelSafeRoutingInfo& routing_info,
                           const std::vector<ModelSafeWorker*>& workers);
+  void ScheduleClearUserDataImpl();
 
   // Returns true if the client is currently in exponential backoff.
   bool IsBackingOff() const;
 
   // Helper to signal all listeners registered with |session_context_|.
   void Notify(SyncEngineEvent::EventCause cause);
 
   // ServerConnectionEventListener implementation.
   // TODO(tim): schedule a nudge when valid connection detected? in 1 minute?
   virtual void OnServerConnectionEvent(const ServerConnectionEvent& event);
 
   // Callback to change backoff state.
   void DoCanaryJob();
   void Unthrottle();
 
   // Creates a session for a poll and performs the sync.
   void PollTimerCallback();
 
+  // Assign |start| and |end| to appropriate SyncerStep values for the
+  // specified |purpose|.
+  void SetSyncerStepsForPurpose(SyncSessionJobPurpose purpose,
+                                SyncerStep* start,
+                                SyncerStep* end);
+
   base::Thread thread_;
 
   // Modifiable versions of kDefaultLongPollIntervalSeconds which can be
   // updated by the server.
   base::TimeDelta syncer_short_poll_interval_seconds_;
   base::TimeDelta syncer_long_poll_interval_seconds_;
 
   // Periodic timer for polling.  See AdjustPolling.
   base::RepeatingTimer<SyncerThread> poll_timer_;
 
@@ skipping 25 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_