Handle birthday errors by disabling sync and deleting sync data.

chrome/browser/sync/engine/syncer_thread.cc

 // 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.
 #include "chrome/browser/sync/engine/syncer_thread.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_MACOSX)
 #include <CoreFoundation/CFNumber.h>
 #include <IOKit/IOTypes.h>
@@ skipping 110 matching lines @@
   // actually up and running.  This is for consistency with the old pthread
   // impl because pthread_create would do this in one step.
   thread_main_started_.Wait();
   LOG(INFO) << "SyncerThread started.";
   return true;
 }
 
 // Stop processing. A max wait of at least 2*server RTT time is recommended.
 // Returns true if we stopped, false otherwise.
 bool SyncerThread::Stop(int max_wait) {
+  RequestSyncerExitAndSetThreadStopConditions();
+
+  // This will join, and finish when ThreadMain terminates.
+  thread_.Stop();
+  return true;
+}
+
+void SyncerThread::RequestSyncerExitAndSetThreadStopConditions() {
   {
     AutoLock lock(lock_);
     // If the thread has been started, then we either already have or are about
     // to enter ThreadMainLoop so we have to proceed with shutdown and wait for
     // it to finish.  If the thread has not been started --and we now own the
     // lock-- then we can early out because the caller has not called Start().
     if (!thread_.IsRunning())
-      return true;
+      return;
 
     LOG(INFO) << "SyncerThread::Stop - setting ThreadMain exit condition to "
               << "true (vault_.stop_syncer_thread_)";
     // Exit the ThreadMainLoop once the syncer finishes (we tell it to exit
     // below).
     vault_.stop_syncer_thread_ = true;
     if (NULL != vault_.syncer_) {
       // Try to early exit the syncer itself, which could be looping inside
       // SyncShare.
       vault_.syncer_->RequestEarlyExit();
     }
 
     // stop_syncer_thread_ is now true and the Syncer has been told to exit.
     // We want to wake up all waiters so they can re-examine state. We signal,
     // causing all waiters to try to re-acquire the lock, and then we release
     // the lock, and join on our internal thread which should soon run off the
     // end of ThreadMain.
     vault_field_changed_.Broadcast();
   }
-
-  // This will join, and finish when ThreadMain terminates.
-  thread_.Stop();
-  return true;
 }
 
 bool SyncerThread::RequestPause() {
   AutoLock lock(lock_);
   if (vault_.pause_requested_ || vault_.paused_)
     return false;
 
   if (thread_.IsRunning()) {
     // Set the pause request.  The syncer thread will read this
     // request, enter the paused state, and send the PAUSED
@@ skipping 54 matching lines @@
 
 bool SyncerThread::IsSyncingCurrentlySilenced() {
   // We should ignore reads from silenced_until_ under ThreadSanitizer
   // since this is a benign race.
   ANNOTATE_IGNORE_READS_BEGIN();
   bool ret = (silenced_until_ - TimeTicks::Now()) >= TimeDelta::FromSeconds(0);
   ANNOTATE_IGNORE_READS_END();
   return ret;
 }
 
+void SyncerThread::OnShouldStopSyncingPermanently() {
+  RequestSyncerExitAndSetThreadStopConditions();
+
+  SyncerEvent event(SyncerEvent::STOP_SYNCING_PERMANENTLY);
+  relay_channel()->Notify(event);
+}
+
 void SyncerThread::ThreadMainLoop() {
   // This is called with lock_ acquired.
   lock_.AssertAcquired();
   LOG(INFO) << "In thread main loop.";
 
   // Use the short poll value by default.
   vault_.current_wait_interval_.poll_delta =
       TimeDelta::FromSeconds(syncer_short_poll_interval_seconds_);
   int user_idle_milliseconds = 0;
   TimeTicks last_sync_time;
@@ skipping 133 matching lines @@
     vault_field_changed_.Wait();
 
   // Notify that we have resumed if we are not shutting down.
   if (!vault_.stop_syncer_thread_)
     ExitPausedState();
 
   LOG(INFO) << "Syncer thread exiting pause.";
 }
 
 void SyncerThread::EnterPausedState() {
+  lock_.AssertAcquired();
   vault_.pause_requested_ = false;
   vault_.paused_ = true;
+  vault_field_changed_.Broadcast();
   SyncerEvent event(SyncerEvent::PAUSED);
   relay_channel()->Notify(event);
 }
 
 void SyncerThread::ExitPausedState() {
+  lock_.AssertAcquired();
   vault_.paused_ = false;
+  vault_field_changed_.Broadcast();
   SyncerEvent event(SyncerEvent::RESUMED);
   relay_channel()->Notify(event);
 }
 
 // We check how long the user's been idle and sync less often if the machine is
 // not in use. The aim is to reduce server load.
 // TODO(timsteele): Should use Time(Delta).
 SyncerThread::WaitInterval SyncerThread::CalculatePollingWaitTime(
     const AllStatus::Status& status,
     int last_poll_wait,  // Time in seconds.
@@ skipping 74 matching lines @@
   return return_interval;
 }
 
 void SyncerThread::ThreadMain() {
   AutoLock lock(lock_);
   // Signal Start() to let it know we've made it safely onto the message loop,
   // and unblock it's caller.
   thread_main_started_.Signal();
   ThreadMainLoop();
   LOG(INFO) << "Syncer thread ThreadMain is done.";
+  SyncerEvent event(SyncerEvent::SYNCER_THREAD_EXITING);
+  relay_channel()->Notify(event);
 }
 
 void SyncerThread::SyncMain(Syncer* syncer) {
   CHECK(syncer);
 
   // Since we are initiating a new session for which we are the delegate, we
   // are not currently silenced so reset this state for the next session which
   // may need to use it.
   silenced_until_ = base::TimeTicks();
 
@@ skipping 249 matching lines @@
     was_logged = true;
     LOG(INFO) << "UserIdleTime unimplemented on this platform, "
         "synchronization will not throttle when user idle";
   }
 #endif
 
   return 0;
 }
 
 }  // namespace browser_sync