Handle birthday errors by disabling sync and deleting sync data.

chrome/browser/sync/engine/syncer_thread.h

 // Copyright (c) 2009 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.
 // This is the default implementation of SyncerThread whose Stop implementation
 // does not support a timeout, but is greatly simplified.
 #ifndef CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 #define CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_
 
@@ skipping 39 matching lines @@
                      public ChannelEventHandler<SyncerEvent> {
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadTest, CalculateSyncWaitTime);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadTest, CalculatePollingWaitTime);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Polling);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Nudge);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Throttling);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, AuthInvalid);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, Pause);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, StartWhenNotConnected);
   FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, PauseWhenNotConnected);
+  FRIEND_TEST_ALL_PREFIXES(SyncerThreadWithSyncerTest, StopSyncPermanently);
   friend class SyncerThreadWithSyncerTest;
   friend class SyncerThreadFactory;
  public:
   // Encapsulates the parameters that make up an interval on which the
   // syncer thread is sleeping.
   struct WaitInterval {
     enum Mode {
       // A wait interval whose duration has not been affected by exponential
       // backoff.  The base case for exponential backoff falls in to this case
       // (e.g when the exponent is 1).  So far, we don't need a separate case.
@@ skipping 159 matching lines @@
       const syncable::DirectoryManagerEvent& event);
   void HandleChannelEvent(const SyncerEvent& event);
 
   // SyncSession::Delegate implementation.
   virtual void OnSilencedUntil(const base::TimeTicks& silenced_until);
   virtual bool IsSyncingCurrentlySilenced();
   virtual void OnReceivedShortPollIntervalUpdate(
       const base::TimeDelta& new_interval);
   virtual void OnReceivedLongPollIntervalUpdate(
       const base::TimeDelta& new_interval);
+  virtual void OnShouldStopSyncingPermanently();
 
   void HandleServerConnectionEvent(const ServerConnectionEvent& event);
 
   void SyncMain(Syncer* syncer);
 
   // Calculates the next sync wait time and exponential backoff state.
   // last_poll_wait is the time duration of the previous polling timeout which
   // was used. user_idle_milliseconds is updated by this method, and is a report
   // of the full amount of time since the last period of activity for the user.
   // The continue_sync_cycle parameter is used to determine whether or not we
@@ skipping 32 matching lines @@
   // or shutdown is started.
   void PauseUntilResumedOrQuit();
 
   void EnterPausedState();
 
   void ExitPausedState();
 
   // For unit tests only.
   virtual void DisableIdleDetection() { disable_idle_detection_ = true; }
 
+  // This sets all conditions for syncer thread termination but does not
+  // actually join threads.  It is expected that Stop will be called at some
+  // time after to fully stop and clean up.
+  void RequestSyncerExitAndSetThreadStopConditions();
+
   // State of the notification framework is tracked by these values.
   bool p2p_authenticated_;
   bool p2p_subscribed_;
 
   scoped_ptr<EventListenerHookup> conn_mgr_hookup_;
   const AllStatus* allstatus_;
 
   // Modifiable versions of kDefaultLongPollIntervalSeconds which can be
   // updated by the server.
   int syncer_short_poll_interval_seconds_;
@@ skipping 38 matching lines @@
 
   // Useful for unit tests
   bool disable_idle_detection_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncerThread);
 };
 
 }  // namespace browser_sync
 
 #endif  // CHROME_BROWSER_SYNC_ENGINE_SYNCER_THREAD_H_