Revert 150990 - [Sync] Avoid unregistering object IDs on shutdown

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 410 matching lines @@
   // we'll want to start from a fresh SyncDB, so delete any old one that might
   // 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(
-        notifier_registrar_.GetAllRegisteredIds());
+    backend_->UpdateRegisteredInvalidationIds(all_registered_ids_);
   }
 
   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::SyncNotifierObserver* handler) {
-  notifier_registrar_.RegisterHandler(handler);
-}
-
 void ProfileSyncService::UpdateRegisteredInvalidationIds(
     syncer::SyncNotifierObserver* handler,
     const syncer::ObjectIdSet& ids) {
-  notifier_registrar_.UpdateRegisteredIds(handler, ids);
-
+  all_registered_ids_ = notifier_helper_.UpdateRegisteredIds(handler, ids);
   // If |backend_| is NULL, its registered IDs will be updated when
   // it's created and initialized.
   if (backend_.get()) {
-    backend_->UpdateRegisteredInvalidationIds(
-        notifier_registrar_.GetAllRegisteredIds());
+    backend_->UpdateRegisteredInvalidationIds(all_registered_ids_);
   }
 }
 
-void ProfileSyncService::UnregisterInvalidationHandler(
-    syncer::SyncNotifierObserver* handler) {
-  notifier_registrar_.UnregisterHandler(handler);
-}
-
 void ProfileSyncService::Shutdown() {
   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()) {
     backend_->StopSyncingForShutdown();
+    backend_->UpdateRegisteredInvalidationIds(syncer::ObjectIdSet());
   }
 
   // Stop all data type controllers, if needed.  Note that until Stop
   // completes, it is possible in theory to have a ChangeProcessor apply a
   // change from a native model.  In that case, it will get applied to the sync
   // database (which doesn't get destroyed until we destroy the backend below)
   // as an unsynced change.  That will be persisted, and committed on restart.
   if (data_type_manager_.get()) {
     if (data_type_manager_->state() != DataTypeManager::STOPPED) {
       // When aborting as part of shutdown, we should expect an aborted sync
@@ skipping 174 matching lines @@
   // the task that we are going to post, this type would still be disabled.
   failed_datatypes_handler_.UpdateFailedDatatypes(errors,
       FailedDatatypesHandler::RUNTIME);
 
   MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&ProfileSyncService::ReconfigureDatatypeManager,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ProfileSyncService::OnNotificationsEnabled() {
-  notifier_registrar_.EmitOnNotificationsEnabled();
+  notifier_helper_.EmitOnNotificationsEnabled();
 }
 
 void ProfileSyncService::OnNotificationsDisabled(
     syncer::NotificationsDisabledReason reason) {
-  notifier_registrar_.EmitOnNotificationsDisabled(reason);
+  notifier_helper_.EmitOnNotificationsDisabled(reason);
 }
 
 void ProfileSyncService::OnIncomingNotification(
     const syncer::ObjectIdPayloadMap& id_payloads,
     syncer::IncomingNotificationSource source) {
-  notifier_registrar_.DispatchInvalidationsToHandlers(id_payloads, source);
+  notifier_helper_.DispatchInvalidationsToHandlers(id_payloads, 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 1115 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);
 }