Rename ModelType/ObjectIdStateMap to InvalidationMap.

sync/notifier/non_blocking_invalidator.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/non_blocking_invalidator.h"
 
 #include <cstddef>
 
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 26 matching lines @@
   void Teardown();
   void UpdateRegisteredIds(const ObjectIdSet& ids);
   void SetUniqueId(const std::string& unique_id);
   void SetStateDeprecated(const std::string& state);
   void UpdateCredentials(const std::string& email, const std::string& token);
 
   // InvalidationHandler implementation (all called on I/O thread by
   // InvalidationNotifier).
   virtual void OnInvalidatorStateChange(InvalidatorState reason) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) OVERRIDE;
 
  private:
   friend class
       base::RefCountedThreadSafe<NonBlockingInvalidator::Core>;
   // Called on parent or I/O thread.
   ~Core();
 
   // The variables below should be used only on the I/O thread.
   const WeakHandle<InvalidationHandler> delegate_observer_;
@@ skipping 64 matching lines @@
 }
 
 void NonBlockingInvalidator::Core::OnInvalidatorStateChange(
     InvalidatorState reason) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(
       FROM_HERE, &InvalidationHandler::OnInvalidatorStateChange, reason);
 }
 
 void NonBlockingInvalidator::Core::OnIncomingInvalidation(
-    const ObjectIdStateMap& id_state_map, IncomingInvalidationSource source) {
+    const ObjectIdInvalidationMap& invalidation_map,
+    IncomingInvalidationSource source) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
   delegate_observer_.Call(FROM_HERE,
                           &InvalidationHandler::OnIncomingInvalidation,
-                          id_state_map,
+                          invalidation_map,
                           source);
 }
 
 NonBlockingInvalidator::NonBlockingInvalidator(
     const notifier::NotifierOptions& notifier_options,
     const InvalidationVersionMap& initial_max_invalidation_versions,
     const std::string& invalidation_bootstrap_data,
     const WeakHandle<InvalidationStateTracker>&
         invalidation_state_tracker,
     const std::string& client_info)
@@ skipping 83 matching lines @@
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   if (!network_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&NonBlockingInvalidator::Core::UpdateCredentials,
                      core_.get(), email, token))) {
     NOTREACHED();
   }
 }
 
 void NonBlockingInvalidator::SendInvalidation(
-    const ObjectIdStateMap& id_state_map) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  // InvalidationClient doesn't implement SendInvalidation(), so no
+  // InvalidationNotifier doesn't implement SendInvalidation(), so no
   // need to forward on the call.
 }
 
 void NonBlockingInvalidator::OnInvalidatorStateChange(InvalidatorState state) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.UpdateInvalidatorState(state);
 }
 
 void NonBlockingInvalidator::OnIncomingInvalidation(
-        const ObjectIdStateMap& id_state_map,
+        const ObjectIdInvalidationMap& invalidation_map,
         IncomingInvalidationSource source) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
-  registrar_.DispatchInvalidationsToHandlers(id_state_map, source);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map, source);
 }
 
 }  // namespace syncer