[Sync] Avoid unregistering object IDs on shutdown

sync/internal_api/sync_manager_impl.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 "sync/internal_api/sync_manager_impl.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 45 matching lines @@
 using sync_pb::GetUpdatesCallerInfo;
 
 namespace syncer {
 
 using sessions::SyncSessionContext;
 using syncable::ImmutableWriteTransactionInfo;
 using syncable::SPECIFICS;
 
 namespace {
 
+const char kHandlerName[] = "SyncManagerImpl";
+
 // Delays for syncer nudges.
 static const int kDefaultNudgeDelayMilliseconds = 200;
 static const int kPreferencesNudgeDelayMilliseconds = 2000;
 static const int kSyncRefreshDelayMsec = 500;
 static const int kSyncSchedulerDelayMsec = 250;
 
 // The maximum number of times we will automatically overwrite the nigori node
 // because the encryption keys don't match (per chrome instantiation).
 static const int kNigoriOverwriteLimit = 10;
 
@@ skipping 313 matching lines @@
   DCHECK(!credentials.sync_token.empty());
   DVLOG(1) << "SyncManager starting Init...";
 
   weak_handle_this_ = MakeWeakHandle(weak_ptr_factory_.GetWeakPtr());
 
   blocking_task_runner_ = blocking_task_runner;
 
   change_delegate_ = change_delegate;
 
   sync_notifier_ = sync_notifier.Pass();
+  if (sync_notifier_.get())
+    sync_notifier_->SetHandler(kHandlerName, this);
 
   AddObserver(&js_sync_manager_observer_);
   SetJsEventHandler(event_handler);
 
   AddObserver(&debug_info_event_listener_);
 
   database_path_ = database_location.Append(
       syncable::Directory::kSyncDatabaseFilename);
   encryptor_ = encryptor;
   unrecoverable_error_handler_ = unrecoverable_error_handler;
@@ skipping 317 matching lines @@
   if (!connection_manager_->set_auth_token(credentials.sync_token))
     return;  // Auth token is known to be invalid, so exit early.
 
   sync_notifier_->UpdateCredentials(credentials.email, credentials.sync_token);
   scheduler_->OnCredentialsUpdated();
 }
 
 void SyncManagerImpl::UpdateEnabledTypes(
     const ModelTypeSet& enabled_types) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(initialized_);
   sync_notifier_->UpdateRegisteredIds(
-      this,
+      kHandlerName,
       ModelTypeSetToObjectIdSet(enabled_types));
 }
 
+void SyncManagerImpl::SetInvalidationHandler(
+    const std::string& handler_name,
+    SyncNotifierObserver* handler) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  // We may be called when initialization fails, so |initialized_| may
+  // be false.
+  sync_notifier_->SetHandler(handler_name, handler);
+}
+
 void SyncManagerImpl::UpdateRegisteredInvalidationIds(
-    SyncNotifierObserver* handler,
+    const std::string& handler_name,
     const ObjectIdSet& ids) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  sync_notifier_->UpdateRegisteredIds(handler, ids);
+  DCHECK(initialized_);
+  sync_notifier_->UpdateRegisteredIds(handler_name, ids);
 }
 
 void SyncManagerImpl::SetEncryptionPassphrase(
     const std::string& passphrase,
     bool is_explicit) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // We do not accept empty passphrases.
   if (passphrase.empty()) {
     NOTREACHED() << "Cannot encrypt with an empty passphrase.";
     return;
@@ skipping 454 matching lines @@
 
   scheduler_.reset();
   session_context_.reset();
 
   SetJsEventHandler(WeakHandle<JsEventHandler>());
   RemoveObserver(&js_sync_manager_observer_);
 
   RemoveObserver(&debug_info_event_listener_);
 
   if (sync_notifier_.get()) {
-    sync_notifier_->UpdateRegisteredIds(this, ObjectIdSet());
+    sync_notifier_->SetHandler(kHandlerName, NULL);
   }
   sync_notifier_.reset();
 
   if (connection_manager_.get()) {
     connection_manager_->RemoveListener(this);
   }
   connection_manager_.reset();
 
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
   observing_ip_address_changes_ = false;
@@ skipping 656 matching lines @@
 int SyncManagerImpl::GetDefaultNudgeDelay() {
   return kDefaultNudgeDelayMilliseconds;
 }
 
 // static.
 int SyncManagerImpl::GetPreferencesNudgeDelay() {
   return kPreferencesNudgeDelayMilliseconds;
 }
 
 }  // namespace syncer