[Sync] Notify invalidation handlers when sync is disabled/enabled

chrome/browser/sync/profile_sync_service.cc

 // Copyright (c) 2012 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/profile_sync_service.h"
 
 #include <cstddef>
 #include <map>
 #include <set>
 #include <utility>
@@ skipping 127 matching lines @@
       signin_(signin_manager),
       unrecoverable_error_reason_(ERROR_REASON_UNSET),
       weak_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       expect_sync_configuration_aborted_(false),
       encrypted_types_(syncer::SyncEncryptionHandler::SensitiveTypes()),
       encrypt_everything_(false),
       encryption_pending_(false),
       auto_start_enabled_(start_behavior == AUTO_START),
       failed_datatypes_handler_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       configure_status_(DataTypeManager::UNKNOWN),
-      setup_in_progress_(false) {
+      setup_in_progress_(false),
+      invalidator_state_(syncer::DEFAULT_INVALIDATION_ERROR) {
 #if defined(OS_ANDROID)
   chrome::VersionInfo version_info;
   if (version_info.IsOfficialBuild()) {
     sync_service_url_ = GURL(kSyncServerUrl);
   }
 #else
   // By default, dev, canary, and unbranded Chromium users will go to the
   // development servers. Development servers have more features than standard
   // sync servers. Users with officially-branded Chrome stable and beta builds
   // will go to the standard sync servers.
@@ skipping 388 matching lines @@
   }
   base::TimeDelta shutdown_time = base::Time::Now() - shutdown_start_time;
   UMA_HISTOGRAM_TIMES("Sync.Shutdown.BackendDestroyedTime", shutdown_time);
 
   weak_factory_.InvalidateWeakPtrs();
 
   // Clear various flags.
   expect_sync_configuration_aborted_ = false;
   is_auth_in_progress_ = false;
   backend_initialized_ = false;
+  // NULL if we're called from Shutdown().
+  if (invalidator_registrar_.get())
+    UpdateInvalidatorRegistrarState();
   cached_passphrase_.clear();
   encryption_pending_ = false;
   encrypt_everything_ = false;
   encrypted_types_ = syncer::SyncEncryptionHandler::SensitiveTypes();
   passphrase_required_reason_ = syncer::REASON_PASSPHRASE_NOT_REQUIRED;
   last_auth_error_ = AuthError::None();
 
   if (sync_global_error_.get()) {
     GlobalErrorServiceFactory::GetForProfile(profile_)->RemoveGlobalError(
         sync_global_error_.get());
@@ skipping 123 matching lines @@
   failed_datatypes_handler_.UpdateFailedDatatypes(errors,
       FailedDatatypesHandler::RUNTIME);
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnInvalidatorStateChange(
     syncer::InvalidatorState state) {
-  invalidator_registrar_->UpdateInvalidatorState(state);
+  invalidator_state_ = state;
+  UpdateInvalidatorRegistrarState();
 }
 
 void ProfileSyncService::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
   invalidator_registrar_->DispatchInvalidationsToHandlers(invalidation_map,
                                                           source);
 }
 
 void ProfileSyncService::OnBackendInitialized(
@@ skipping 31 matching lines @@
     // we get here, we will have already tried and failed to delete the
     // directory.  It would be no big deal if we tried to delete it again.
     OnInternalUnrecoverableError(FROM_HERE,
                                  "BackendInitialize failure",
                                  false,
                                  ERROR_REASON_BACKEND_INIT_FAILURE);
     return;
   }
 
   backend_initialized_ = true;
+  UpdateInvalidatorRegistrarState();
 
   sync_js_controller_.AttachJsBackend(js_backend);
 
   // If we have a cached passphrase use it to decrypt/encrypt data now that the
   // backend is initialized. We want to call this before notifying observers in
   // case this operation affects the "passphrase required" status.
   ConsumeCachedPassphraseIfPossible();
 
   // The very first time the backend initializes is effectively the first time
   // we can say we successfully "synced".  last_synced_time_ will only be null
@@ skipping 1059 matching lines @@
 void ProfileSyncService::OnInternalUnrecoverableError(
     const tracked_objects::Location& from_here,
     const std::string& message,
     bool delete_sync_database,
     UnrecoverableErrorReason reason) {
   DCHECK(!HasUnrecoverableError());
   unrecoverable_error_reason_ = reason;
   OnUnrecoverableErrorImpl(from_here, message, delete_sync_database);
 }
 
+void ProfileSyncService::UpdateInvalidatorRegistrarState() {
+  const syncer::InvalidatorState effective_state =
+      backend_initialized_ ?
+      invalidator_state_ : syncer::TRANSIENT_INVALIDATION_ERROR;
+  invalidator_registrar_->UpdateInvalidatorState(effective_state);
+}
+
 void ProfileSyncService::ResetForTest() {
   Profile* profile = profile_;
   SigninManager* signin = SigninManagerFactory::GetForProfile(profile);
   ProfileSyncService::StartBehavior behavior =
       browser_defaults::kSyncAutoStarts ? ProfileSyncService::AUTO_START
                                         : ProfileSyncService::MANUAL_START;
 
   // We call the destructor and placement new here because we want to explicitly
   // recreate a new ProfileSyncService instance at the same memory location as
   // the old one. Doing so is fine because this code is run only from within
   // integration tests, and the message loop is not running at this point.
   // See http://stackoverflow.com/questions/6224121/is-new-this-myclass-undefined-behaviour-after-directly-calling-the-destru.
   ProfileSyncService* old_this = this;
   this->~ProfileSyncService();
   new(old_this) ProfileSyncService(
       new ProfileSyncComponentsFactoryImpl(profile,
                                            CommandLine::ForCurrentProcess()),
       profile,
       signin,
       behavior);
 }