[Invalidations] Require there to be no registered handlers on Invalidator destruction

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 49 matching lines @@
 #include "google_apis/gaia/gaia_constants.h"
 #include "grit/generated_resources.h"
 #include "net/cookies/cookie_monster.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/sync_encryption_handler.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/internal_api/public/util/sync_string_conversions.h"
 #include "sync/js/js_arg_list.h"
 #include "sync/js/js_event_details.h"
+#include "sync/notifier/invalidator_registrar.h"
 #include "sync/util/cryptographer.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using browser_sync::ChangeProcessor;
 using browser_sync::DataTypeController;
 using browser_sync::DataTypeManager;
 using browser_sync::SyncBackendHost;
 using syncer::ModelType;
 using syncer::ModelTypeSet;
 using syncer::JsBackend;
@@ skipping 102 matching lines @@
 }
 
 bool ProfileSyncService::IsSyncTokenAvailable() {
   TokenService* token_service = TokenServiceFactory::GetForProfile(profile_);
   if (!token_service)
     return false;
   return token_service->HasTokenForService(GaiaConstants::kSyncService);
 }
 
 void ProfileSyncService::Initialize() {
+  DCHECK(!invalidator_registrar_.get());
+  invalidator_registrar_.reset(new syncer::InvalidatorRegistrar());
+
   InitSettings();
 
   // We clear this here (vs Shutdown) because we want to remember that an error
   // happened on shutdown so we can display details (message, location) about it
   // in about:sync.
   ClearStaleErrors();
 
   sync_prefs_.AddSyncPrefObserver(this);
 
   // For now, the only thing we can do through policy is to turn sync off.
@@ skipping 226 matching lines @@
   // be there.
   InitializeBackend(!HasSyncSetupCompleted());
 
   // |backend_| may end up being NULL here in tests (in synchronous
   // initialization mode).
   //
   // TODO(akalin): Fix this horribly non-intuitive behavior (see
   // http://crbug.com/140354).
   if (backend_.get()) {
     backend_->UpdateRegisteredInvalidationIds(
-        invalidator_registrar_.GetAllRegisteredIds());
+        invalidator_registrar_->GetAllRegisteredIds());
   }
 
   if (!sync_global_error_.get()) {
 #if !defined(OS_ANDROID)
     sync_global_error_.reset(new SyncGlobalError(this, signin()));
 #endif
     GlobalErrorServiceFactory::GetForProfile(profile_)->AddGlobalError(
         sync_global_error_.get());
     AddObserver(sync_global_error_.get());
   }
 }
 
 void ProfileSyncService::RegisterInvalidationHandler(
     syncer::InvalidationHandler* handler) {
-  invalidator_registrar_.RegisterHandler(handler);
+  invalidator_registrar_->RegisterHandler(handler);
 }
 
 void ProfileSyncService::UpdateRegisteredInvalidationIds(
     syncer::InvalidationHandler* handler,
     const syncer::ObjectIdSet& ids) {
-  invalidator_registrar_.UpdateRegisteredIds(handler, ids);
+  invalidator_registrar_->UpdateRegisteredIds(handler, ids);
 
   // If |backend_| is NULL, its registered IDs will be updated when
   // it's created and initialized.
   if (backend_.get()) {
     backend_->UpdateRegisteredInvalidationIds(
-        invalidator_registrar_.GetAllRegisteredIds());
+        invalidator_registrar_->GetAllRegisteredIds());
   }
 }
 
 void ProfileSyncService::UnregisterInvalidationHandler(
     syncer::InvalidationHandler* handler) {
-  invalidator_registrar_.UnregisterHandler(handler);
+  invalidator_registrar_->UnregisterHandler(handler);
 }
 
 syncer::InvalidatorState ProfileSyncService::GetInvalidatorState() const {
-  return invalidator_registrar_.GetInvalidatorState();
+  return invalidator_registrar_->GetInvalidatorState();
 }
 
 void ProfileSyncService::EmitInvalidationForTest(
     const invalidation::ObjectId& id,
     const std::string& payload) {
   syncer::ObjectIdSet notify_ids;
   notify_ids.insert(id);
 
   const syncer::ObjectIdInvalidationMap& invalidation_map =
       ObjectIdSetToInvalidationMap(notify_ids, payload);
   OnIncomingInvalidation(invalidation_map, syncer::REMOTE_INVALIDATION);
 }
 
 void ProfileSyncService::Shutdown() {
+  DCHECK(invalidator_registrar_.get());
   // TODO(akalin): Remove this once http://crbug.com/153827 is fixed.
   ExtensionService* const extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   // |extension_service| may be NULL if it was never initialized
   // (e.g., extension sync wasn't enabled in tests).
   if (extension_service)
     extension_service->OnProfileSyncServiceShutdown();
 
+  // Reset |invalidator_registrar_| first so that ShutdownImpl cannot
+  // use it.
+  invalidator_registrar_.reset();
+
   ShutdownImpl(false);
 }
 
 void ProfileSyncService::ShutdownImpl(bool sync_disabled) {
   // First, we spin down the backend and wait for it to stop syncing completely
   // before we Stop the data type manager.  This is to avoid a late sync cycle
   // applying changes to the sync db that wouldn't get applied via
   // ChangeProcessors, leading to back-from-the-dead bugs.
   base::Time shutdown_start_time = base::Time::Now();
   if (backend_.get()) {
@@ skipping 173 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_registrar_->UpdateInvalidatorState(state);
 }
 
 void ProfileSyncService::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
-  invalidator_registrar_.DispatchInvalidationsToHandlers(invalidation_map,
-                                                         source);
+  invalidator_registrar_->DispatchInvalidationsToHandlers(invalidation_map,
+                                                          source);
 }
 
 void ProfileSyncService::OnBackendInitialized(
     const syncer::WeakHandle<syncer::JsBackend>& js_backend, bool success) {
   is_first_time_sync_configure_ = !HasSyncSetupCompleted();
 
   if (is_first_time_sync_configure_) {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeFirstTimeSuccess", success);
   } else {
     UMA_HISTOGRAM_BOOLEAN("Sync.BackendInitializeRestoreSuccess", success);
@@ skipping 1124 matching lines @@
   // 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);
 }