Make use of InvalidationService

sync/notifier/invalidator_registrar.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/notifier/invalidator_registrar.h"
 
 #include <cstddef>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 45 matching lines @@
         << ObjectIdToString(insert_it->first) << " for "
         << handler << " when it's already registered for "
         << insert_it->second;
   }
 }
 
 void InvalidatorRegistrar::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK(thread_checker_.CalledOnValidThread());
   CHECK(handler);
   CHECK(handlers_.HasObserver(handler));
+  UpdateRegisteredIds(handler, ObjectIdSet());
   handlers_.RemoveObserver(handler);
 }
 
 ObjectIdSet InvalidatorRegistrar::GetRegisteredIds(
     InvalidationHandler* handler) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   ObjectIdSet registered_ids;
   for (IdHandlerMap::const_iterator it = id_to_handler_map_.begin();
        it != id_to_handler_map_.end(); ++it) {
     if (it->second == handler) {
@@ skipping 36 matching lines @@
   InvalidationHandler* handler = NULL;
   while ((handler = it.GetNext()) != NULL) {
     DispatchMap::const_iterator dispatch_it = dispatch_map.find(handler);
     if (dispatch_it != dispatch_map.end())
       handler->OnIncomingInvalidation(dispatch_it->second);
   }
 }
 
 void InvalidatorRegistrar::UpdateInvalidatorState(InvalidatorState state) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DVLOG(1) << "New invalidator state: " << InvalidatorStateToString(state_);
+  DVLOG(1) << "New invalidator state: " << InvalidatorStateToString(state_)
+      << " -> " << InvalidatorStateToString(state);
   state_ = state;
   FOR_EACH_OBSERVER(InvalidationHandler, handlers_,
                     OnInvalidatorStateChange(state));
 }
 
 InvalidatorState InvalidatorRegistrar::GetInvalidatorState() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return state_;
 }
 
 bool InvalidatorRegistrar::IsHandlerRegisteredForTest(
     InvalidationHandler* handler) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return handlers_.HasObserver(handler);
 }
 
 void InvalidatorRegistrar::DetachFromThreadForTest() {
   DCHECK(thread_checker_.CalledOnValidThread());
   thread_checker_.DetachFromThread();
 }
 
 InvalidationHandler* InvalidatorRegistrar::ObjectIdToHandler(
     const invalidation::ObjectId& id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   IdHandlerMap::const_iterator it = id_to_handler_map_.find(id);
   return (it == id_to_handler_map_.end()) ? NULL : it->second;
 }
 
 }  // namespace syncer