Rename ModelType/ObjectIdStateMap to InvalidationMap.

BUG=none
TBR=sky


Review URL: https://chromiumcodereview.appspot.com/11052007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@160073 0039d316-1c4b-4281-b951-d872f2087c98

94 files changed, 918 insertions, 873 deletions

diff --git a/chrome/browser/chrome_to_mobile_service.cc b/chrome/browser/chrome_to_mobile_service.cc
index 9aec57a..7061628 100644
--- a/chrome/browser/chrome_to_mobile_service.cc
+++ b/chrome/browser/chrome_to_mobile_service.cc
@@ -425,10 +425,10 @@ void ChromeToMobileService::OnInvalidatorStateChange(
 }
 
 void ChromeToMobileService::OnIncomingInvalidation(
-    const syncer::ObjectIdStateMap& id_state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
-  DCHECK_EQ(1U, id_state_map.size());
-  DCHECK_EQ(1U, id_state_map.count(invalidation::ObjectId(
+  DCHECK_EQ(1U, invalidation_map.size());
+  DCHECK_EQ(1U, invalidation_map.count(invalidation::ObjectId(
       ipc::invalidation::ObjectSource::CHROME_COMPONENTS,
       kSyncInvalidationObjectIdChromeToMobileDeviceList)));
   RequestDeviceSearch();
diff --git a/chrome/browser/chrome_to_mobile_service.h b/chrome/browser/chrome_to_mobile_service.h
index 4fd2472..191e8b7 100644
--- a/chrome/browser/chrome_to_mobile_service.h
+++ b/chrome/browser/chrome_to_mobile_service.h
@@ -173,7 +173,7 @@ class ChromeToMobileService : public ProfileKeyedService,
   virtual void OnInvalidatorStateChange(
       syncer::InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source) OVERRIDE;
 
   // Expose access token accessors for test purposes.
diff --git a/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.cc b/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.cc
index 882dfe8..cee8305e 100644
--- a/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.cc
+++ b/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.cc
@@ -119,11 +119,11 @@ void PushMessagingInvalidationHandler::OnInvalidatorStateChange(
 }
 
 void PushMessagingInvalidationHandler::OnIncomingInvalidation(
-    const syncer::ObjectIdStateMap& id_state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  for (syncer::ObjectIdStateMap::const_iterator it = id_state_map.begin();
-       it != id_state_map.end(); ++it) {
+  for (syncer::ObjectIdInvalidationMap::const_iterator it =
+           invalidation_map.begin(); it != invalidation_map.end(); ++it) {
     std::string extension_id;
     int subchannel;
     if (ObjectIdToExtensionAndSubchannel(it->first,
diff --git a/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.h b/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.h
index 52ec385..7d61598 100644
--- a/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.h
+++ b/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler.h
@@ -43,7 +43,7 @@ class PushMessagingInvalidationHandler : public PushMessagingInvalidationMapper,
   virtual void OnInvalidatorStateChange(
       syncer::InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source) OVERRIDE;
 
   const std::set<std::string>& GetRegisteredExtensionsForTest() const {
diff --git a/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_unittest.cc b/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_unittest.cc
index 1db7eaf..599998b 100644
--- a/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_unittest.cc
+++ b/chrome/browser/extensions/api/push_messaging/push_messaging_invalidation_handler_unittest.cc
@@ -164,7 +164,7 @@ TEST_F(PushMessagingInvalidationHandlerTest, Dispatch) {
               OnMessage("dddddddddddddddddddddddddddddddd", 0, "payload"));
   EXPECT_CALL(delegate_,
               OnMessage("dddddddddddddddddddddddddddddddd", 3, "payload"));
-  handler_->OnIncomingInvalidation(ObjectIdSetToStateMap(ids, "payload"),
+  handler_->OnIncomingInvalidation(ObjectIdSetToInvalidationMap(ids, "payload"),
                                    syncer::REMOTE_INVALIDATION);
 }
 
@@ -195,7 +195,7 @@ TEST_F(PushMessagingInvalidationHandlerTest, DispatchInvalidObjectIds) {
   ids.insert(invalidation::ObjectId(
       kSourceId,
       "U/dddddddddddddddddddddddddddddddd/4"));
-  handler_->OnIncomingInvalidation(ObjectIdSetToStateMap(ids, "payload"),
+  handler_->OnIncomingInvalidation(ObjectIdSetToInvalidationMap(ids, "payload"),
                                    syncer::REMOTE_INVALIDATION);
 }
 
diff --git a/chrome/browser/sync/glue/bridged_invalidator.cc b/chrome/browser/sync/glue/bridged_invalidator.cc
index 0146ad4..a0e1c2a 100644
--- a/chrome/browser/sync/glue/bridged_invalidator.cc
+++ b/chrome/browser/sync/glue/bridged_invalidator.cc
@@ -67,9 +67,9 @@ void BridgedInvalidator::UpdateCredentials(
 }
 
 void BridgedInvalidator::SendInvalidation(
-    const syncer::ObjectIdStateMap& id_state_map) {
+    const syncer::ObjectIdInvalidationMap& invalidation_map) {
   if (delegate_.get())
-    delegate_->SendInvalidation(id_state_map);
+    delegate_->SendInvalidation(invalidation_map);
 }
 
 }  // namespace browser_sync
diff --git a/chrome/browser/sync/glue/bridged_invalidator.h b/chrome/browser/sync/glue/bridged_invalidator.h
index 63d0ea4..b8c47ba 100644
--- a/chrome/browser/sync/glue/bridged_invalidator.h
+++ b/chrome/browser/sync/glue/bridged_invalidator.h
@@ -43,7 +43,7 @@ class BridgedInvalidator : public syncer::Invalidator {
   virtual void UpdateCredentials(
       const std::string& email, const std::string& token) OVERRIDE;
   virtual void SendInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map) OVERRIDE;
+      const syncer::ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
  private:
   // The notification bridge that we register the observers with.
diff --git a/chrome/browser/sync/glue/bridged_invalidator_unittest.cc b/chrome/browser/sync/glue/bridged_invalidator_unittest.cc
index ecd8084..966f387 100644
--- a/chrome/browser/sync/glue/bridged_invalidator_unittest.cc
+++ b/chrome/browser/sync/glue/bridged_invalidator_unittest.cc
@@ -19,7 +19,7 @@
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/fake_invalidator.h"
 #include "sync/notifier/invalidator_test_template.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -84,9 +84,9 @@ class BridgedInvalidatorTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source) {
-    fake_delegate_->EmitOnIncomingInvalidation(id_state_map, source);
+    fake_delegate_->EmitOnIncomingInvalidation(invalidation_map, source);
   }
 
   static bool InvalidatorHandlesDeprecatedState() {
@@ -170,11 +170,11 @@ TEST_F(BridgedInvalidatorTest, SendInvalidation) {
   syncer::ObjectIdSet ids;
   ids.insert(invalidation::ObjectId(1, "id1"));
   ids.insert(invalidation::ObjectId(2, "id2"));
-  const syncer::ObjectIdStateMap& id_state_map =
-      syncer::ObjectIdSetToStateMap(ids, "payload");
-  delegate_.GetInvalidator()->SendInvalidation(id_state_map);
-  EXPECT_THAT(id_state_map,
-              Eq(delegate_.GetFakeDelegate()->GetLastSentIdStateMap()));
+  const syncer::ObjectIdInvalidationMap& invalidation_map =
+      syncer::ObjectIdSetToInvalidationMap(ids, "payload");
+  delegate_.GetInvalidator()->SendInvalidation(invalidation_map);
+  EXPECT_THAT(invalidation_map,
+              Eq(delegate_.GetFakeDelegate()->GetLastSentInvalidationMap()));
 }
 
 }  // namespace
diff --git a/chrome/browser/sync/glue/chrome_sync_notification_bridge.cc b/chrome/browser/sync/glue/chrome_sync_notification_bridge.cc
index 933cbc9..9b35858 100644
--- a/chrome/browser/sync/glue/chrome_sync_notification_bridge.cc
+++ b/chrome/browser/sync/glue/chrome_sync_notification_bridge.cc
@@ -37,7 +37,7 @@ class ChromeSyncNotificationBridge::Core
   void UnregisterHandler(syncer::InvalidationHandler* handler);
 
   void EmitInvalidation(
-      const syncer::ObjectIdStateMap& state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource invalidation_source);
 
   bool IsHandlerRegisteredForTest(syncer::InvalidationHandler* handler) const;
@@ -97,17 +97,17 @@ void ChromeSyncNotificationBridge::Core::UnregisterHandler(
 }
 
 void ChromeSyncNotificationBridge::Core::EmitInvalidation(
-    const syncer::ObjectIdStateMap& state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource invalidation_source) {
   DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
-  const syncer::ObjectIdStateMap& effective_state_map =
-      state_map.empty() ?
-      ObjectIdSetToStateMap(
+  const syncer::ObjectIdInvalidationMap& effective_invalidation_map =
+      invalidation_map.empty() ?
+      ObjectIdSetToInvalidationMap(
           invalidator_registrar_->GetAllRegisteredIds(), std::string()) :
-      state_map;
+      invalidation_map;
 
   invalidator_registrar_->DispatchInvalidationsToHandlers(
-      effective_state_map, invalidation_source);
+      effective_invalidation_map, invalidation_source);
 }
 
 bool ChromeSyncNotificationBridge::Core::IsHandlerRegisteredForTest(
@@ -197,17 +197,19 @@ void ChromeSyncNotificationBridge::Observe(
     return;
   }
 
-  // TODO(akalin): Use ObjectIdStateMap here instead.  We'll have to
+  // TODO(akalin): Use ObjectIdInvalidationMap here instead.  We'll have to
   // make sure all emitters of the relevant notifications also use
-  // ObjectIdStateMap.
-  content::Details<const syncer::ModelTypeStateMap>
+  // ObjectIdInvalidationMap.
+  content::Details<const syncer::ModelTypeInvalidationMap>
       state_details(details);
-  const syncer::ModelTypeStateMap& state_map = *(state_details.ptr());
+  const syncer::ModelTypeInvalidationMap& invalidation_map =
+      *(state_details.ptr());
   if (!sync_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&Core::EmitInvalidation,
                      core_,
-                     ModelTypeStateMapToObjectIdStateMap(state_map),
+                     ModelTypeInvalidationMapToObjectIdInvalidationMap(
+                         invalidation_map),
                      invalidation_source))) {
     NOTREACHED();
   }
diff --git a/chrome/browser/sync/glue/chrome_sync_notification_bridge_unittest.cc b/chrome/browser/sync/glue/chrome_sync_notification_bridge_unittest.cc
index 382e63c..1fabd18 100644
--- a/chrome/browser/sync/glue/chrome_sync_notification_bridge_unittest.cc
+++ b/chrome/browser/sync/glue/chrome_sync_notification_bridge_unittest.cc
@@ -22,9 +22,9 @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/test/test_browser_thread.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/notifier/fake_invalidation_handler.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -68,14 +68,14 @@ class ChromeSyncNotificationBridgeTest : public testing::Test {
   }
 
   void VerifyAndDestroyObserver(
-      const syncer::ModelTypeStateMap& expected_states,
+      const syncer::ModelTypeInvalidationMap& expected_invalidations,
       syncer::IncomingInvalidationSource expected_source) {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&ChromeSyncNotificationBridgeTest::
                        VerifyAndDestroyObserverOnSyncThread,
                    base::Unretained(this),
-                   expected_states,
+                   expected_invalidations,
                    expected_source)));
     BlockForSyncThread();
   }
@@ -102,25 +102,27 @@ class ChromeSyncNotificationBridgeTest : public testing::Test {
 
   void TriggerRefreshNotification(
       int type,
-      const syncer::ModelTypeStateMap& state_map) {
+      const syncer::ModelTypeInvalidationMap& invalidation_map) {
     content::NotificationService::current()->Notify(
         type,
         content::Source<Profile>(&mock_profile_),
-        content::Details<const syncer::ModelTypeStateMap>(&state_map));
+        content::Details<const syncer::ModelTypeInvalidationMap>(
+            &invalidation_map));
     BlockForSyncThread();
   }
 
  private:
   void VerifyAndDestroyObserverOnSyncThread(
-      const syncer::ModelTypeStateMap& expected_states,
+      const syncer::ModelTypeInvalidationMap& expected_invalidations,
       syncer::IncomingInvalidationSource expected_source) {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     if (sync_handler_.get()) {
       sync_handler_notification_success_ =
           (sync_handler_->GetInvalidationCount() == 1) &&
-          ObjectIdStateMapEquals(
-              sync_handler_->GetLastInvalidationIdStateMap(),
-              syncer::ModelTypeStateMapToObjectIdStateMap(expected_states)) &&
+          ObjectIdInvalidationMapEquals(
+              sync_handler_->GetLastInvalidationMap(),
+              syncer::ModelTypeInvalidationMapToObjectIdInvalidationMap(
+                  expected_invalidations)) &&
           (sync_handler_->GetLastInvalidationSource() == expected_source);
       bridge_->UnregisterHandler(sync_handler_.get());
     } else {
@@ -167,28 +169,28 @@ class ChromeSyncNotificationBridgeTest : public testing::Test {
 // invalidation, and ensures the bridge posts a LOCAL_INVALIDATION
 // with the proper state to it.
 TEST_F(ChromeSyncNotificationBridgeTest, LocalNotification) {
-  syncer::ModelTypeStateMap state_map;
-  state_map.insert(
-      std::make_pair(syncer::SESSIONS, syncer::InvalidationState()));
+  const syncer::ModelTypeSet types(syncer::SESSIONS);
+  const syncer::ModelTypeInvalidationMap& invalidation_map =
+      ModelTypeSetToInvalidationMap(types, std::string());
   CreateObserver();
   UpdateEnabledTypes(syncer::ModelTypeSet(syncer::SESSIONS));
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
-                             state_map);
-  VerifyAndDestroyObserver(state_map, syncer::LOCAL_INVALIDATION);
+                             invalidation_map);
+  VerifyAndDestroyObserver(invalidation_map, syncer::LOCAL_INVALIDATION);
 }
 
 // Adds an observer on the sync thread, triggers a remote refresh
 // invalidation, and ensures the bridge posts a REMOTE_INVALIDATION
 // with the proper state to it.
 TEST_F(ChromeSyncNotificationBridgeTest, RemoteNotification) {
-  syncer::ModelTypeStateMap state_map;
-  state_map.insert(
-      std::make_pair(syncer::SESSIONS, syncer::InvalidationState()));
+  const syncer::ModelTypeSet types(syncer::SESSIONS);
+  const syncer::ModelTypeInvalidationMap& invalidation_map =
+      ModelTypeSetToInvalidationMap(types, std::string());
   CreateObserver();
   UpdateEnabledTypes(syncer::ModelTypeSet(syncer::SESSIONS));
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
-                             state_map);
-  VerifyAndDestroyObserver(state_map, syncer::REMOTE_INVALIDATION);
+                             invalidation_map);
+  VerifyAndDestroyObserver(invalidation_map, syncer::REMOTE_INVALIDATION);
 }
 
 // Adds an observer on the sync thread, triggers a local refresh
@@ -197,14 +199,14 @@ TEST_F(ChromeSyncNotificationBridgeTest, RemoteNotification) {
 TEST_F(ChromeSyncNotificationBridgeTest, LocalNotificationEmptyPayloadMap) {
   const syncer::ModelTypeSet enabled_types(
       syncer::BOOKMARKS, syncer::PASSWORDS);
-  const syncer::ModelTypeStateMap enabled_types_state_map =
-      syncer::ModelTypeSetToStateMap(enabled_types, std::string());
+  const syncer::ModelTypeInvalidationMap enabled_types_invalidation_map =
+      syncer::ModelTypeSetToInvalidationMap(enabled_types, std::string());
   CreateObserver();
   UpdateEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
-                             syncer::ModelTypeStateMap());
+                             syncer::ModelTypeInvalidationMap());
   VerifyAndDestroyObserver(
-      enabled_types_state_map, syncer::LOCAL_INVALIDATION);
+      enabled_types_invalidation_map, syncer::LOCAL_INVALIDATION);
 }
 
 // Adds an observer on the sync thread, triggers a remote refresh
@@ -213,14 +215,14 @@ TEST_F(ChromeSyncNotificationBridgeTest, LocalNotificationEmptyPayloadMap) {
 TEST_F(ChromeSyncNotificationBridgeTest, RemoteNotificationEmptyPayloadMap) {
   const syncer::ModelTypeSet enabled_types(
       syncer::BOOKMARKS, syncer::TYPED_URLS);
-  const syncer::ModelTypeStateMap enabled_types_state_map =
-      syncer::ModelTypeSetToStateMap(enabled_types, std::string());
+  const syncer::ModelTypeInvalidationMap enabled_types_invalidation_map =
+      syncer::ModelTypeSetToInvalidationMap(enabled_types, std::string());
   CreateObserver();
   UpdateEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
-                             syncer::ModelTypeStateMap());
+                             syncer::ModelTypeInvalidationMap());
   VerifyAndDestroyObserver(
-      enabled_types_state_map, syncer::REMOTE_INVALIDATION);
+      enabled_types_invalidation_map, syncer::REMOTE_INVALIDATION);
 }
 
 }  // namespace
diff --git a/chrome/browser/sync/glue/session_change_processor.cc b/chrome/browser/sync/glue/session_change_processor.cc
index c95e21e..a79c5d1 100644
--- a/chrome/browser/sync/glue/session_change_processor.cc
+++ b/chrome/browser/sync/glue/session_change_processor.cc
@@ -24,7 +24,7 @@
 #include "content/public/browser/web_contents.h"
 #include "sync/api/sync_error.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/change_record.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/protocol/session_specifics.pb.h"
@@ -212,13 +212,14 @@ void SessionChangeProcessor::Observe(
         entry->GetVirtualURL().is_valid() &&
         entry->GetVirtualURL().spec() == kNTPOpenTabSyncURL) {
       DVLOG(1) << "Triggering sync refresh for sessions datatype.";
-      const syncer::ModelType type = syncer::SESSIONS;
-      syncer::ModelTypeStateMap state_map;
-      state_map.insert(std::make_pair(type, syncer::InvalidationState()));
+      const syncer::ModelTypeSet types(syncer::SESSIONS);
+      const syncer::ModelTypeInvalidationMap& invalidation_map =
+          ModelTypeSetToInvalidationMap(types, std::string());
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
           content::Source<Profile>(profile_),
-          content::Details<const syncer::ModelTypeStateMap>(&state_map));
+          content::Details<const syncer::ModelTypeInvalidationMap>(
+              &invalidation_map));
     }
   }
 
diff --git a/chrome/browser/sync/glue/session_model_associator.cc b/chrome/browser/sync/glue/session_model_associator.cc
index cf37a0d..cbc143e9 100644
--- a/chrome/browser/sync/glue/session_model_associator.cc
+++ b/chrome/browser/sync/glue/session_model_associator.cc
@@ -32,7 +32,7 @@
 #include "sync/api/sync_error.h"
 #include "sync/api/time.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/read_node.h"
 #include "sync/internal_api/public/read_transaction.h"
 #include "sync/internal_api/public/write_node.h"
@@ -1153,13 +1153,14 @@ void SessionModelAssociator::TabNodePool::FreeTabNode(int64 sync_id) {
 
 void SessionModelAssociator::AttemptSessionsDataRefresh() const {
   DVLOG(1) << "Triggering sync refresh for sessions datatype.";
-  const syncer::ModelType type = syncer::SESSIONS;
-  syncer::ModelTypeStateMap state_map;
-  state_map.insert(std::make_pair(type, syncer::InvalidationState()));
+  const syncer::ModelTypeSet types(syncer::SESSIONS);
+  const syncer::ModelTypeInvalidationMap& invalidation_map =
+      ModelTypeSetToInvalidationMap(types, std::string());
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
       content::Source<Profile>(profile_),
-      content::Details<const syncer::ModelTypeStateMap>(&state_map));
+      content::Details<const syncer::ModelTypeInvalidationMap>(
+          &invalidation_map));
 }
 
 bool SessionModelAssociator::GetLocalSession(
diff --git a/chrome/browser/sync/glue/sync_backend_host.cc b/chrome/browser/sync/glue/sync_backend_host.cc
index e235cf7..76b1397 100644
--- a/chrome/browser/sync/glue/sync_backend_host.cc
+++ b/chrome/browser/sync/glue/sync_backend_host.cc
@@ -125,7 +125,7 @@ class SyncBackendHost::Core
   virtual void OnInvalidatorStateChange(
       syncer::InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source) OVERRIDE;
 
   // Note:
@@ -1052,14 +1052,14 @@ void SyncBackendHost::Core::OnInvalidatorStateChange(
 }
 
 void SyncBackendHost::Core::OnIncomingInvalidation(
-    const syncer::ObjectIdStateMap& id_state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
   if (!sync_loop_)
     return;
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   host_.Call(FROM_HERE,
              &SyncBackendHost::HandleIncomingInvalidationOnFrontendLoop,
-             id_state_map, source);
+             invalidation_map, source);
 }
 
 void SyncBackendHost::Core::DoInitialize(const DoInitializeOptions& options) {
@@ -1444,12 +1444,12 @@ void SyncBackendHost::HandleInvalidatorStateChangeOnFrontendLoop(
 }
 
 void SyncBackendHost::HandleIncomingInvalidationOnFrontendLoop(
-    const syncer::ObjectIdStateMap& id_state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
   if (!frontend_)
     return;
   DCHECK_EQ(MessageLoop::current(), frontend_loop_);
-  frontend_->OnIncomingInvalidation(id_state_map, source);
+  frontend_->OnIncomingInvalidation(invalidation_map, source);
 }
 
 bool SyncBackendHost::CheckPassphraseAgainstCachedPendingKeys(
diff --git a/chrome/browser/sync/glue/sync_backend_host.h b/chrome/browser/sync/glue/sync_backend_host.h
index 43730c9..5a237da 100644
--- a/chrome/browser/sync/glue/sync_backend_host.h
+++ b/chrome/browser/sync/glue/sync_backend_host.h
@@ -469,7 +469,7 @@ class SyncBackendHost : public BackendDataTypeConfigurer {
   void HandleInvalidatorStateChangeOnFrontendLoop(
       syncer::InvalidatorState state);
   void HandleIncomingInvalidationOnFrontendLoop(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source);
 
   // Handles stopping the core's SyncManager, accounting for whether
diff --git a/chrome/browser/sync/glue/sync_backend_host_unittest.cc b/chrome/browser/sync/glue/sync_backend_host_unittest.cc
index d912d33..f28d88f 100644
--- a/chrome/browser/sync/glue/sync_backend_host_unittest.cc
+++ b/chrome/browser/sync/glue/sync_backend_host_unittest.cc
@@ -24,7 +24,7 @@
 #include "sync/internal_api/public/test/fake_sync_manager.h"
 #include "sync/internal_api/public/util/experiments.h"
 #include "sync/notifier/invalidator_state.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "sync/protocol/encryption.pb.h"
 #include "sync/protocol/sync_protocol_error.h"
 #include "sync/util/test_unrecoverable_error_handler.h"
@@ -57,7 +57,7 @@ class MockSyncFrontend : public SyncFrontend {
   MOCK_METHOD1(OnInvalidatorStateChange,
                void(syncer::InvalidatorState));
   MOCK_METHOD2(OnIncomingInvalidation,
-               void(const syncer::ObjectIdStateMap&,
+               void(const syncer::ObjectIdInvalidationMap&,
                     syncer::IncomingInvalidationSource));
   MOCK_METHOD2(OnBackendInitialized,
                void(const syncer::WeakHandle<syncer::JsBackend>&, bool));
@@ -566,16 +566,16 @@ TEST_F(SyncBackendHostTest, Invalidate) {
   syncer::ObjectIdSet ids;
   ids.insert(invalidation::ObjectId(1, "id1"));
   ids.insert(invalidation::ObjectId(2, "id2"));
-  const syncer::ObjectIdStateMap& id_state_map =
-      syncer::ObjectIdSetToStateMap(ids, "payload");
+  const syncer::ObjectIdInvalidationMap& invalidation_map =
+      syncer::ObjectIdSetToInvalidationMap(ids, "payload");
 
   EXPECT_CALL(
       mock_frontend_,
-      OnIncomingInvalidation(id_state_map, syncer::REMOTE_INVALIDATION))
+      OnIncomingInvalidation(invalidation_map, syncer::REMOTE_INVALIDATION))
       .WillOnce(InvokeWithoutArgs(QuitMessageLoop));
 
   backend_->UpdateRegisteredInvalidationIds(ids);
-  fake_manager_->Invalidate(id_state_map, syncer::REMOTE_INVALIDATION);
+  fake_manager_->Invalidate(invalidation_map, syncer::REMOTE_INVALIDATION);
   ui_loop_.PostDelayedTask(
       FROM_HERE, ui_loop_.QuitClosure(), TestTimeouts::action_timeout());
   ui_loop_.Run();
@@ -614,9 +614,9 @@ TEST_F(SyncBackendHostTest, InvalidationsAfterStopSyncingForShutdown) {
   // Should not trigger anything.
   fake_manager_->UpdateInvalidatorState(syncer::TRANSIENT_INVALIDATION_ERROR);
   fake_manager_->UpdateInvalidatorState(syncer::INVALIDATIONS_ENABLED);
-  const syncer::ObjectIdStateMap& id_state_map =
-      syncer::ObjectIdSetToStateMap(ids, "payload");
-  fake_manager_->Invalidate(id_state_map, syncer::REMOTE_INVALIDATION);
+  const syncer::ObjectIdInvalidationMap& invalidation_map =
+      syncer::ObjectIdSetToInvalidationMap(ids, "payload");
+  fake_manager_->Invalidate(invalidation_map, syncer::REMOTE_INVALIDATION);
 
   // Make sure the above calls take effect before we continue.
   fake_manager_->WaitForSyncThread();
diff --git a/chrome/browser/sync/profile_sync_service.cc b/chrome/browser/sync/profile_sync_service.cc
index 95f53af..4dc2b1b 100644
--- a/chrome/browser/sync/profile_sync_service.cc
+++ b/chrome/browser/sync/profile_sync_service.cc
@@ -479,9 +479,9 @@ void ProfileSyncService::EmitInvalidationForTest(
   syncer::ObjectIdSet notify_ids;
   notify_ids.insert(id);
 
-  const syncer::ObjectIdStateMap& id_state_map =
-      ObjectIdSetToStateMap(notify_ids, payload);
-  OnIncomingInvalidation(id_state_map, syncer::REMOTE_INVALIDATION);
+  const syncer::ObjectIdInvalidationMap& invalidation_map =
+      ObjectIdSetToInvalidationMap(notify_ids, payload);
+  OnIncomingInvalidation(invalidation_map, syncer::REMOTE_INVALIDATION);
 }
 
 void ProfileSyncService::Shutdown() {
@@ -682,9 +682,10 @@ void ProfileSyncService::OnInvalidatorStateChange(
 }
 
 void ProfileSyncService::OnIncomingInvalidation(
-    const syncer::ObjectIdStateMap& id_state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     syncer::IncomingInvalidationSource source) {
-  invalidator_registrar_.DispatchInvalidationsToHandlers(id_state_map, source);
+  invalidator_registrar_.DispatchInvalidationsToHandlers(invalidation_map,
+                                                         source);
 }
 
 void ProfileSyncService::OnBackendInitialized(
diff --git a/chrome/browser/sync/profile_sync_service.h b/chrome/browser/sync/profile_sync_service.h
index 17e9a63..4ab847b 100644
--- a/chrome/browser/sync/profile_sync_service.h
+++ b/chrome/browser/sync/profile_sync_service.h
@@ -269,7 +269,7 @@ class ProfileSyncService : public ProfileSyncServiceBase,
   virtual void OnInvalidatorStateChange(
       syncer::InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source) OVERRIDE;
 
   // SyncFrontend implementation.
diff --git a/chrome/browser/sync/profile_sync_service_unittest.cc b/chrome/browser/sync/profile_sync_service_unittest.cc
index 6eacdeb..788d425 100644
--- a/chrome/browser/sync/profile_sync_service_unittest.cc
+++ b/chrome/browser/sync/profile_sync_service_unittest.cc
@@ -30,7 +30,7 @@
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/invalidator.h"
 #include "sync/notifier/invalidator_test_template.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/user_agent/user_agent.h"
@@ -406,8 +406,8 @@ TEST_F(ProfileSyncServiceTest, UpdateRegisteredInvalidationIdsPersistence) {
 
   syncer::ObjectIdSet ids;
   ids.insert(invalidation::ObjectId(3, "id3"));
-  const syncer::ObjectIdStateMap& states =
-      syncer::ObjectIdSetToStateMap(ids, "payload");
+  const syncer::ObjectIdInvalidationMap& states =
+      syncer::ObjectIdSetToInvalidationMap(ids, "payload");
 
   syncer::FakeInvalidationHandler handler;
 
@@ -424,7 +424,7 @@ TEST_F(ProfileSyncServiceTest, UpdateRegisteredInvalidationIdsPersistence) {
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
 
   backend->EmitOnIncomingInvalidation(states, syncer::REMOTE_INVALIDATION);
-  EXPECT_THAT(states, Eq(handler.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(states, Eq(handler.GetLastInvalidationMap()));
   EXPECT_EQ(syncer::REMOTE_INVALIDATION, handler.GetLastInvalidationSource());
 
   backend->EmitOnInvalidatorStateChange(syncer::TRANSIENT_INVALIDATION_ERROR);
@@ -473,7 +473,7 @@ class ProfileSyncServiceInvalidator : public syncer::Invalidator {
   }
 
   virtual void SendInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map) OVERRIDE {
+      const syncer::ObjectIdInvalidationMap& invalidation_map) OVERRIDE {
     // Do nothing.
   }
 
@@ -525,10 +525,10 @@ class ProfileSyncServiceInvalidatorTestDelegate {
   }
 
   void TriggerOnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       syncer::IncomingInvalidationSource source) {
     harness_.service->GetBackendForTest()->EmitOnIncomingInvalidation(
-        id_state_map, source);
+        invalidation_map, source);
   }
 
   static bool InvalidatorHandlesDeprecatedState() {
diff --git a/chrome/browser/sync/test/integration/sync_test.cc b/chrome/browser/sync/test/integration/sync_test.cc
index 6fab4d3..d64411c 100644
--- a/chrome/browser/sync/test/integration/sync_test.cc
+++ b/chrome/browser/sync/test/integration/sync_test.cc
@@ -674,8 +674,8 @@ void SyncTest::TriggerNotification(syncer::ModelTypeSet changed_types) {
       syncer::P2PNotificationData(
           "from_server",
           syncer::NOTIFY_ALL,
-          syncer::ObjectIdSetToStateMap(
-              syncer::ModelTypeSetToObjectIdSet(changed_types), ""),
+          syncer::ObjectIdSetToInvalidationMap(
+              syncer::ModelTypeSetToObjectIdSet(changed_types), std::string()),
           syncer::REMOTE_INVALIDATION).ToString();
   const std::string& path =
       std::string("chromiumsync/sendnotification?channel=") +
diff --git a/chrome/browser/sync/test_profile_sync_service.cc b/chrome/browser/sync/test_profile_sync_service.cc
index dd88ee9..ab926e7 100644
--- a/chrome/browser/sync/test_profile_sync_service.cc
+++ b/chrome/browser/sync/test_profile_sync_service.cc
@@ -152,9 +152,9 @@ void SyncBackendHostForProfileSyncTest::EmitOnInvalidatorStateChange(
 }
 
 void SyncBackendHostForProfileSyncTest::EmitOnIncomingInvalidation(
-    const syncer::ObjectIdStateMap& id_state_map,
+    const syncer::ObjectIdInvalidationMap& invalidation_map,
     const syncer::IncomingInvalidationSource source) {
-  frontend()->OnIncomingInvalidation(id_state_map, source);
+  frontend()->OnIncomingInvalidation(invalidation_map, source);
 }
 
 }  // namespace browser_sync
diff --git a/chrome/browser/sync/test_profile_sync_service.h b/chrome/browser/sync/test_profile_sync_service.h
index 7bd5fac..6b6059e 100644
--- a/chrome/browser/sync/test_profile_sync_service.h
+++ b/chrome/browser/sync/test_profile_sync_service.h
@@ -66,7 +66,7 @@ class SyncBackendHostForProfileSyncTest : public SyncBackendHost {
 
   void EmitOnInvalidatorStateChange(syncer::InvalidatorState state);
   void EmitOnIncomingInvalidation(
-      const syncer::ObjectIdStateMap& id_state_map,
+      const syncer::ObjectIdInvalidationMap& invalidation_map,
       const syncer::IncomingInvalidationSource source);
 
  protected:
diff --git a/sync/engine/download_updates_command.cc b/sync/engine/download_updates_command.cc
index 50ad8a0..61b6a6e 100644
--- a/sync/engine/download_updates_command.cc
+++ b/sync/engine/download_updates_command.cc
@@ -9,7 +9,7 @@
 #include "base/command_line.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/syncer_proto_util.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/syncable/directory.h"
 #include "sync/syncable/nigori_handler.h"
 #include "sync/syncable/read_transaction.h"
@@ -73,7 +73,8 @@ SyncerError DownloadUpdatesCommand::ExecuteImpl(SyncSession* session) {
            << ModelTypeSetToString(enabled_types);
   DCHECK(!enabled_types.Empty());
 
-  const ModelTypeStateMap& type_state_map = session->source().types;
+  const ModelTypeInvalidationMap& invalidation_map =
+      session->source().types;
   for (ModelTypeSet::Iterator it = enabled_types.First();
        it.Good(); it.Inc()) {
     sync_pb::DataTypeProgressMarker* progress_marker =
@@ -81,10 +82,10 @@ SyncerError DownloadUpdatesCommand::ExecuteImpl(SyncSession* session) {
     dir->GetDownloadProgress(it.Get(), progress_marker);
 
     // Set notification hint if present.
-    ModelTypeStateMap::const_iterator type_state =
-        type_state_map.find(it.Get());
-    if (type_state != type_state_map.end()) {
-      progress_marker->set_notification_hint(type_state->second.payload);
+    ModelTypeInvalidationMap::const_iterator find_it =
+        invalidation_map.find(it.Get());
+    if (find_it != invalidation_map.end()) {
+      progress_marker->set_notification_hint(find_it->second.payload);
     }
   }
 
diff --git a/sync/engine/sync_scheduler.h b/sync/engine/sync_scheduler.h
index d251b98..b9c1ed3 100644
--- a/sync/engine/sync_scheduler.h
+++ b/sync/engine/sync_scheduler.h
@@ -12,7 +12,7 @@
 #include "base/compiler_specific.h"
 #include "base/time.h"
 #include "sync/engine/nudge_source.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/sessions/sync_session.h"
 
 class MessageLoop;
@@ -92,7 +92,7 @@ class SyncScheduler : public sessions::SyncSession::Delegate {
       const tracked_objects::Location& nudge_location) = 0;
   virtual void ScheduleNudgeWithStatesAsync(
       const base::TimeDelta& delay, NudgeSource source,
-      const ModelTypeStateMap& type_state_map,
+      const ModelTypeInvalidationMap& invalidation_map,
       const tracked_objects::Location& nudge_location) = 0;
 
   // Change status of notifications in the SyncSessionContext.
diff --git a/sync/engine/sync_scheduler_impl.cc b/sync/engine/sync_scheduler_impl.cc
index 82cdcce..b2180fb 100644
--- a/sync/engine/sync_scheduler_impl.cc
+++ b/sync/engine/sync_scheduler_impl.cc
@@ -343,7 +343,7 @@ bool SyncSchedulerImpl::ScheduleConfiguration(
         session_context_,
         this,
         SyncSourceInfo(params.source,
-                       ModelSafeRoutingInfoToStateMap(
+                       ModelSafeRoutingInfoToInvalidationMap(
                            restricted_routes,
                            std::string())),
         restricted_routes,
@@ -415,7 +415,7 @@ SyncSchedulerImpl::JobProcessDecision SyncSchedulerImpl::DecideOnJob(
   if (job.purpose == SyncSessionJob::NUDGE &&
       job.session->source().updates_source == GetUpdatesCallerInfo::LOCAL) {
     ModelTypeSet requested_types;
-    for (ModelTypeStateMap::const_iterator i =
+    for (ModelTypeInvalidationMap::const_iterator i =
          job.session->source().types.begin();
          i != job.session->source().types.end();
          ++i) {
@@ -579,29 +579,29 @@ void SyncSchedulerImpl::ScheduleNudgeAsync(
       << "source " << GetNudgeSourceString(source) << ", "
       << "types " << ModelTypeSetToString(types);
 
-  ModelTypeStateMap type_state_map =
-      ModelTypeSetToStateMap(types, std::string());
+  ModelTypeInvalidationMap invalidation_map =
+      ModelTypeSetToInvalidationMap(types, std::string());
   SyncSchedulerImpl::ScheduleNudgeImpl(delay,
                                        GetUpdatesFromNudgeSource(source),
-                                       type_state_map,
+                                       invalidation_map,
                                        false,
                                        nudge_location);
 }
 
 void SyncSchedulerImpl::ScheduleNudgeWithStatesAsync(
     const TimeDelta& delay,
-    NudgeSource source, const ModelTypeStateMap& type_state_map,
+    NudgeSource source, const ModelTypeInvalidationMap& invalidation_map,
     const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   SDVLOG_LOC(nudge_location, 2)
       << "Nudge scheduled with delay " << delay.InMilliseconds() << " ms, "
       << "source " << GetNudgeSourceString(source) << ", "
       << "payloads "
-      << ModelTypeStateMapToString(type_state_map);
+      << ModelTypeInvalidationMapToString(invalidation_map);
 
   SyncSchedulerImpl::ScheduleNudgeImpl(delay,
                                        GetUpdatesFromNudgeSource(source),
-                                       type_state_map,
+                                       invalidation_map,
                                        false,
                                        nudge_location);
 }
@@ -609,20 +609,20 @@ void SyncSchedulerImpl::ScheduleNudgeWithStatesAsync(
 void SyncSchedulerImpl::ScheduleNudgeImpl(
     const TimeDelta& delay,
     GetUpdatesCallerInfo::GetUpdatesSource source,
-    const ModelTypeStateMap& type_state_map,
+    const ModelTypeInvalidationMap& invalidation_map,
     bool is_canary_job, const tracked_objects::Location& nudge_location) {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
-  DCHECK(!type_state_map.empty()) << "Nudge scheduled for no types!";
+  DCHECK(!invalidation_map.empty()) << "Nudge scheduled for no types!";
 
   SDVLOG_LOC(nudge_location, 2)
       << "In ScheduleNudgeImpl with delay "
       << delay.InMilliseconds() << " ms, "
       << "source " << GetUpdatesSourceString(source) << ", "
       << "payloads "
-      << ModelTypeStateMapToString(type_state_map)
+      << ModelTypeInvalidationMapToString(invalidation_map)
       << (is_canary_job ? " (canary)" : "");
 
-  SyncSourceInfo info(source, type_state_map);
+  SyncSourceInfo info(source, invalidation_map);
   UpdateNudgeTimeRecords(info);
 
   SyncSession* session(CreateSyncSession(info));
@@ -813,7 +813,7 @@ void SyncSchedulerImpl::UpdateNudgeTimeRecords(const SyncSourceInfo& info) {
 
   base::TimeTicks now = TimeTicks::Now();
   // Update timing information for how often datatypes are triggering nudges.
-  for (ModelTypeStateMap::const_iterator iter = info.types.begin();
+  for (ModelTypeInvalidationMap::const_iterator iter = info.types.begin();
        iter != info.types.end();
        ++iter) {
     base::TimeTicks previous = last_local_nudges_by_model_type_[iter->first];
@@ -1053,9 +1053,9 @@ SyncSession* SyncSchedulerImpl::CreateSyncSession(
 void SyncSchedulerImpl::PollTimerCallback() {
   DCHECK_EQ(MessageLoop::current(), sync_loop_);
   ModelSafeRoutingInfo r;
-  ModelTypeStateMap type_state_map =
-      ModelSafeRoutingInfoToStateMap(r, std::string());
-  SyncSourceInfo info(GetUpdatesCallerInfo::PERIODIC, type_state_map);
+  ModelTypeInvalidationMap invalidation_map =
+      ModelSafeRoutingInfoToInvalidationMap(r, std::string());
+  SyncSourceInfo info(GetUpdatesCallerInfo::PERIODIC, invalidation_map);
   SyncSession* s = CreateSyncSession(info);
 
   SyncSessionJob job(SyncSessionJob::POLL, TimeTicks::Now(),
diff --git a/sync/engine/sync_scheduler_impl.h b/sync/engine/sync_scheduler_impl.h
index cf5e24c..90ce57c 100644
--- a/sync/engine/sync_scheduler_impl.h
+++ b/sync/engine/sync_scheduler_impl.h
@@ -21,7 +21,7 @@
 #include "sync/engine/nudge_source.h"
 #include "sync/engine/sync_scheduler.h"
 #include "sync/engine/syncer.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/sessions/sync_session.h"
@@ -54,7 +54,7 @@ class SyncSchedulerImpl : public SyncScheduler {
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual void ScheduleNudgeWithStatesAsync(
       const base::TimeDelta& delay, NudgeSource source,
-      const ModelTypeStateMap& type_state_map,
+      const ModelTypeInvalidationMap& invalidation_map,
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual void SetNotificationsEnabled(bool notifications_enabled) OVERRIDE;
 
@@ -242,7 +242,7 @@ class SyncSchedulerImpl : public SyncScheduler {
   void ScheduleNudgeImpl(
       const base::TimeDelta& delay,
       sync_pb::GetUpdatesCallerInfo::GetUpdatesSource source,
-      const ModelTypeStateMap& type_state_map,
+      const ModelTypeInvalidationMap& invalidation_map,
       bool is_canary_job, const tracked_objects::Location& nudge_location);
 
   // Returns true if the client is currently in exponential backoff.
diff --git a/sync/engine/sync_scheduler_unittest.cc b/sync/engine/sync_scheduler_unittest.cc
index 63dc3c3..1bb5245 100644
--- a/sync/engine/sync_scheduler_unittest.cc
+++ b/sync/engine/sync_scheduler_unittest.cc
@@ -12,7 +12,7 @@
 #include "sync/engine/sync_scheduler_impl.h"
 #include "sync/engine/syncer.h"
 #include "sync/engine/throttled_data_type_tracker.h"
-#include "sync/internal_api/public/base/model_type_state_map_test_util.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map_test_util.h"
 #include "sync/sessions/test_util.h"
 #include "sync/test/callback_counter.h"
 #include "sync/test/engine/fake_model_worker.h"
@@ -199,13 +199,13 @@ class SyncSchedulerTest : public testing::Test {
     scheduler_->delay_provider_.reset(delay_);
   }
 
-  // Compare a ModelTypeSet to a ModelTypeStateMap, ignoring
+  // Compare a ModelTypeSet to a ModelTypeInvalidationMap, ignoring
   // state values.
-  bool CompareModelTypeSetToModelTypeStateMap(
+  bool CompareModelTypeSetToModelTypeInvalidationMap(
       ModelTypeSet lhs,
-      const ModelTypeStateMap& rhs) {
+      const ModelTypeInvalidationMap& rhs) {
     size_t count = 0;
-    for (ModelTypeStateMap::const_iterator i = rhs.begin();
+    for (ModelTypeInvalidationMap::const_iterator i = rhs.begin();
          i != rhs.end(); ++i, ++count) {
       if (!lhs.Has(i->first))
         return false;
@@ -282,7 +282,7 @@ TEST_F(SyncSchedulerTest, Nudge) {
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
       records.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records.snapshots[0].source().updates_source);
@@ -301,7 +301,7 @@ TEST_F(SyncSchedulerTest, Nudge) {
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
       records2.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records2.snapshots[0].source().updates_source);
@@ -329,7 +329,7 @@ TEST_F(SyncSchedulerTest, Config) {
   ASSERT_EQ(1, counter.times_called());
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
       records.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[0].source().updates_source);
@@ -366,7 +366,7 @@ TEST_F(SyncSchedulerTest, ConfigWithBackingOff) {
 
   ASSERT_EQ(2U, records.snapshots.size());
   ASSERT_EQ(1, counter.times_called());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
       records.snapshots[1].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[1].source().updates_source);
@@ -425,12 +425,12 @@ TEST_F(SyncSchedulerTest, NudgeWithConfigWithBackingOff) {
 
   ASSERT_EQ(4U, records.snapshots.size());
 
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
       records.snapshots[2].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::RECONFIGURATION,
             records.snapshots[2].source().updates_source);
 
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(model_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(model_types,
       records.snapshots[3].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records.snapshots[3].source().updates_source);
@@ -456,7 +456,7 @@ TEST_F(SyncSchedulerTest, NudgeCoalescing) {
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(
       Union(types1, types2), r.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             r.snapshots[0].source().updates_source);
@@ -472,7 +472,7 @@ TEST_F(SyncSchedulerTest, NudgeCoalescing) {
   RunLoop();
 
   ASSERT_EQ(1U, r2.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(types3,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(types3,
       r2.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::NOTIFICATION,
             r2.snapshots[0].source().updates_source);
@@ -504,7 +504,7 @@ TEST_F(SyncSchedulerTest, NudgeCoalescingWithDifferentTimings) {
 
   // Make sure the sync has happened.
   ASSERT_EQ(1U, r.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(
       Union(types1, types2), r.snapshots[0].source().types));
 
   // Make sure the sync happened at the right time.
@@ -517,19 +517,20 @@ TEST_F(SyncSchedulerTest, NudgeWithStates) {
   StartSyncScheduler(SyncScheduler::NORMAL_MODE);
 
   SyncShareRecords records;
-  ModelTypeStateMap type_state_map;
-  type_state_map[BOOKMARKS].payload = "test";
+  const ModelTypeSet types(BOOKMARKS);
+  ModelTypeInvalidationMap invalidation_map =
+      ModelTypeSetToInvalidationMap(types, "test");
 
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records))))
       .RetiresOnSaturation();
   scheduler()->ScheduleNudgeWithStatesAsync(
-      zero(), NUDGE_SOURCE_LOCAL, type_state_map, FROM_HERE);
+      zero(), NUDGE_SOURCE_LOCAL, invalidation_map, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_THAT(type_state_map, Eq(records.snapshots[0].source().types));
+  EXPECT_THAT(invalidation_map, Eq(records.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records.snapshots[0].source().updates_source);
 
@@ -537,17 +538,17 @@ TEST_F(SyncSchedulerTest, NudgeWithStates) {
 
   // Make sure a second, later, nudge is unaffected by first (no coalescing).
   SyncShareRecords records2;
-  type_state_map.erase(BOOKMARKS);
-  type_state_map[AUTOFILL].payload = "test2";
+  invalidation_map.erase(BOOKMARKS);
+  invalidation_map[AUTOFILL].payload = "test2";
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&records2))));
   scheduler()->ScheduleNudgeWithStatesAsync(
-      zero(), NUDGE_SOURCE_LOCAL, type_state_map, FROM_HERE);
+      zero(), NUDGE_SOURCE_LOCAL, invalidation_map, FROM_HERE);
   RunLoop();
 
   ASSERT_EQ(1U, records2.snapshots.size());
-  EXPECT_THAT(type_state_map, Eq(records2.snapshots[0].source().types));
+  EXPECT_THAT(invalidation_map, Eq(records2.snapshots[0].source().types));
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records2.snapshots[0].source().updates_source);
 }
@@ -560,7 +561,7 @@ TEST_F(SyncSchedulerTest, NudgeWithStatesCoalescing) {
   EXPECT_CALL(*syncer(), SyncShare(_,_,_))
       .WillOnce(DoAll(Invoke(sessions::test_util::SimulateSuccess),
                       WithArg<0>(RecordSyncShare(&r))));
-  ModelTypeStateMap types1, types2, types3;
+  ModelTypeInvalidationMap types1, types2, types3;
   types1[BOOKMARKS].payload = "test1";
   types2[AUTOFILL].payload = "test2";
   types3[THEMES].payload = "test3";
@@ -574,7 +575,7 @@ TEST_F(SyncSchedulerTest, NudgeWithStatesCoalescing) {
 
   ASSERT_EQ(1U, r.snapshots.size());
   EXPECT_GE(r.times[0], optimal_time);
-  ModelTypeStateMap coalesced_types;
+  ModelTypeInvalidationMap coalesced_types;
   CoalesceStates(&coalesced_types, types1);
   CoalesceStates(&coalesced_types, types2);
   EXPECT_THAT(coalesced_types, Eq(r.snapshots[0].source().types));
@@ -804,7 +805,7 @@ TEST_F(SyncSchedulerTest, ConfigurationMode) {
   ASSERT_EQ(1, counter.times_called());
 
   ASSERT_EQ(1U, records.snapshots.size());
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(config_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(config_types,
       records.snapshots[0].source().types));
 
   // Switch to NORMAL_MODE to ensure NUDGES were properly saved and run.
@@ -824,7 +825,7 @@ TEST_F(SyncSchedulerTest, ConfigurationMode) {
   ASSERT_EQ(1U, records2.snapshots.size());
   EXPECT_EQ(GetUpdatesCallerInfo::LOCAL,
             records2.snapshots[0].source().updates_source);
-  EXPECT_TRUE(CompareModelTypeSetToModelTypeStateMap(nudge_types,
+  EXPECT_TRUE(CompareModelTypeSetToModelTypeInvalidationMap(nudge_types,
       records2.snapshots[0].source().types));
   PumpLoop();
 }
diff --git a/sync/engine/sync_scheduler_whitebox_unittest.cc b/sync/engine/sync_scheduler_whitebox_unittest.cc
index 0a9c73e..8cf4a37 100644
--- a/sync/engine/sync_scheduler_whitebox_unittest.cc
+++ b/sync/engine/sync_scheduler_whitebox_unittest.cc
@@ -143,17 +143,16 @@ TEST_F(SyncSchedulerWhiteboxTest, SaveNudge) {
 TEST_F(SyncSchedulerWhiteboxTest, SaveNudgeWhileTypeThrottled) {
   InitializeSyncerOnNormalMode();
 
-  ModelTypeSet types;
-  types.Put(BOOKMARKS);
+  const ModelTypeSet types(BOOKMARKS);
 
   // Mark bookmarks as throttled.
   context()->throttled_data_type_tracker()->SetUnthrottleTime(
       types, base::TimeTicks::Now() + base::TimeDelta::FromHours(2));
 
-  ModelTypeStateMap type_state_map;
-  type_state_map.insert(std::make_pair(BOOKMARKS, InvalidationState()));
+  const ModelTypeInvalidationMap& invalidation_map =
+      ModelTypeSetToInvalidationMap(types, std::string());
 
-  SyncSourceInfo info(GetUpdatesCallerInfo::LOCAL, type_state_map);
+  SyncSourceInfo info(GetUpdatesCallerInfo::LOCAL, invalidation_map);
   SyncSession* s = scheduler_->CreateSyncSession(info);
 
   // Now schedule a nudge with just bookmarks and the change is local.
diff --git a/sync/engine/syncer_unittest.cc b/sync/engine/syncer_unittest.cc
index 28650a6..da4f01c0 100644
--- a/sync/engine/syncer_unittest.cc
+++ b/sync/engine/syncer_unittest.cc
@@ -178,10 +178,11 @@ class SyncerTest : public testing::Test,
     std::vector<ModelSafeWorker*> workers;
     GetModelSafeRoutingInfo(&info);
     GetWorkers(&workers);
-    ModelTypeStateMap types =
-        ModelSafeRoutingInfoToStateMap(info, std::string());
+    ModelTypeInvalidationMap invalidation_map =
+        ModelSafeRoutingInfoToInvalidationMap(info, std::string());
     return new SyncSession(context_.get(), this,
-        sessions::SyncSourceInfo(sync_pb::GetUpdatesCallerInfo::UNKNOWN, types),
+        sessions::SyncSourceInfo(sync_pb::GetUpdatesCallerInfo::UNKNOWN,
+                                 invalidation_map),
         info, workers);
   }
 
diff --git a/sync/internal_api/debug_info_event_listener.cc b/sync/internal_api/debug_info_event_listener.cc
index 5f06954..58eba87 100644
--- a/sync/internal_api/debug_info_event_listener.cc
+++ b/sync/internal_api/debug_info_event_listener.cc
@@ -118,9 +118,9 @@ void DebugInfoEventListener::OnNudgeFromDatatype(ModelType datatype) {
 }
 
 void DebugInfoEventListener::OnIncomingNotification(
-     const ModelTypeStateMap& type_state_map) {
+     const ModelTypeInvalidationMap& invalidation_map) {
   sync_pb::DebugEventInfo event_info;
-  ModelTypeSet types = ModelTypeStateMapToSet(type_state_map);
+  ModelTypeSet types = ModelTypeInvalidationMapToSet(invalidation_map);
 
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     event_info.add_datatypes_notified_from_server(
diff --git a/sync/internal_api/debug_info_event_listener.h b/sync/internal_api/debug_info_event_listener.h
index 50b474e..451d23a9 100644
--- a/sync/internal_api/debug_info_event_listener.h
+++ b/sync/internal_api/debug_info_event_listener.h
@@ -62,7 +62,8 @@ class DebugInfoEventListener : public SyncManager::Observer,
 
   // Sync manager events.
   void OnNudgeFromDatatype(ModelType datatype);
-  void OnIncomingNotification(const ModelTypeStateMap& type_state_map);
+  void OnIncomingNotification(
+      const ModelTypeInvalidationMap& invalidation_map);
 
   // DebugInfoGetter Implementation.
   virtual void GetAndClearDebugInfo(sync_pb::DebugInfo* debug_info) OVERRIDE;
diff --git a/sync/internal_api/js_sync_manager_observer_unittest.cc b/sync/internal_api/js_sync_manager_observer_unittest.cc
index 6d8c9be8..5745a0f 100644
--- a/sync/internal_api/js_sync_manager_observer_unittest.cc
+++ b/sync/internal_api/js_sync_manager_observer_unittest.cc
@@ -72,7 +72,7 @@ TEST_F(JsSyncManagerObserverTest, OnInitializationComplete) {
 }
 
 TEST_F(JsSyncManagerObserverTest, OnSyncCycleCompleted) {
-  ModelTypeStateMap download_progress_markers;
+  ModelTypeInvalidationMap download_progress_markers;
   sessions::SyncSessionSnapshot snapshot(sessions::ModelNeutralState(),
                                          false,
                                          ModelTypeSet(),
diff --git a/sync/internal_api/public/base/invalidation_state.cc b/sync/internal_api/public/base/invalidation.cc
index 6f71351..2ddaa63 100644
--- a/sync/internal_api/public/base/invalidation_state.cc
+++ b/sync/internal_api/public/base/invalidation.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/internal_api/public/base/invalidation_state.h"
+#include "sync/internal_api/public/base/invalidation.h"
 
 #include "base/values.h"
 
@@ -20,18 +20,18 @@ bool AckHandle::ResetFromValue(const base::Value& value) {
   return true;
 }
 
-bool InvalidationState::Equals(const InvalidationState& other) const {
+bool Invalidation::Equals(const Invalidation& other) const {
   return (payload == other.payload) && ack_handle.Equals(other.ack_handle);
 }
 
-scoped_ptr<base::DictionaryValue> InvalidationState::ToValue() const {
+scoped_ptr<base::DictionaryValue> Invalidation::ToValue() const {
   scoped_ptr<DictionaryValue> value(new DictionaryValue());
   value->SetString("payload", payload);
   value->Set("ackHandle", ack_handle.ToValue().release());
   return value.Pass();
 }
 
-bool InvalidationState::ResetFromValue(const base::DictionaryValue& value) {
+bool Invalidation::ResetFromValue(const base::DictionaryValue& value) {
   const base::Value* ack_handle_value = NULL;
   return
       value.GetString("payload", &payload) &&
diff --git a/sync/internal_api/public/base/invalidation_state.h b/sync/internal_api/public/base/invalidation.h
index 8c811af..fc8c361c 100644
--- a/sync/internal_api/public/base/invalidation_state.h
+++ b/sync/internal_api/public/base/invalidation.h
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_STATE_H_
-#define SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_STATE_H_
+#ifndef SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_H_
+#define SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_H_
 
 #include <string>
 
@@ -28,11 +28,16 @@ class AckHandle {
   bool ResetFromValue(const base::Value& value);
 };
 
-struct InvalidationState {
+// Represents a local invalidation, and is roughly analogous to
+// invalidation::Invalidation. It contains a payload (which may be empty) and an
+// associated ack handle that an InvalidationHandler implementation can use to
+// acknowledge receipt of the invalidation. It does not embed the object ID,
+// since it is typically associated with it through ObjectIdInvalidationMap.
+struct Invalidation {
   std::string payload;
   AckHandle ack_handle;
 
-  bool Equals(const InvalidationState& other) const;
+  bool Equals(const Invalidation& other) const;
 
   // Caller owns the returned DictionaryValue.
   scoped_ptr<base::DictionaryValue> ToValue() const;
@@ -42,4 +47,4 @@ struct InvalidationState {
 
 }  // namespace syncer
 
-#endif  // SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_STATE_H_
+#endif  // SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_H_
diff --git a/sync/internal_api/public/base/invalidation_state_test_util.cc b/sync/internal_api/public/base/invalidation_state_test_util.cc
deleted file mode 100644
index a27d045..0000000
--- a/sync/internal_api/public/base/invalidation_state_test_util.cc
+++ /dev/null
@@ -1,63 +0,0 @@
-// 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/public/base/invalidation_state_test_util.h"
-
-#include "base/basictypes.h"
-#include "sync/internal_api/public/base/invalidation_state.h"
-
-namespace syncer {
-
-using ::testing::MakeMatcher;
-using ::testing::MatchResultListener;
-using ::testing::Matcher;
-using ::testing::MatcherInterface;
-using ::testing::PrintToString;
-
-namespace {
-
-class InvalidationStateEqMatcher
-    : public MatcherInterface<const InvalidationState&> {
- public:
-  explicit InvalidationStateEqMatcher(const InvalidationState& expected);
-
-  virtual bool MatchAndExplain(const InvalidationState& actual,
-                               MatchResultListener* listener) const;
-  virtual void DescribeTo(::std::ostream* os) const;
-  virtual void DescribeNegationTo(::std::ostream* os) const;
-
- private:
-  const InvalidationState expected_;
-
-  DISALLOW_COPY_AND_ASSIGN(InvalidationStateEqMatcher);
-};
-
-InvalidationStateEqMatcher::InvalidationStateEqMatcher(
-    const InvalidationState& expected) : expected_(expected) {
-}
-
-bool InvalidationStateEqMatcher::MatchAndExplain(
-    const InvalidationState& actual, MatchResultListener* listener) const {
-  return expected_.payload == actual.payload;
-}
-
-void InvalidationStateEqMatcher::DescribeTo(::std::ostream* os) const {
-  *os << " is equal to " << PrintToString(expected_);
-}
-
-void InvalidationStateEqMatcher::DescribeNegationTo(::std::ostream* os) const {
-  *os << " isn't equal to " << PrintToString(expected_);
-}
-
-}  // namespace
-
-void PrintTo(const InvalidationState& state, ::std::ostream* os) {
-  *os << "{ payload: " << state.payload << " }";
-}
-
-Matcher<const InvalidationState&> Eq(const InvalidationState& expected) {
-  return MakeMatcher(new InvalidationStateEqMatcher(expected));
-}
-
-}  // namespace syncer
diff --git a/sync/internal_api/public/base/invalidation_state_test_util.h b/sync/internal_api/public/base/invalidation_state_test_util.h
deleted file mode 100644
index 77baccb..0000000
--- a/sync/internal_api/public/base/invalidation_state_test_util.h
+++ /dev/null
@@ -1,23 +0,0 @@
-// 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.
-
-#ifndef SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_STATE_TEST_UTIL_H_
-#define SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_STATE_TEST_UTIL_H_
-
-#include <iosfwd>
-
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace syncer {
-
-struct InvalidationState;
-
-void PrintTo(const InvalidationState& state, ::std::ostream* os);
-
-::testing::Matcher<const InvalidationState&> Eq(
-    const InvalidationState& expected);
-
-}  // namespace syncer
-
-#endif  // SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_STATE_TEST_UTIL_H_
diff --git a/sync/internal_api/public/base/invalidation_test_util.cc b/sync/internal_api/public/base/invalidation_test_util.cc
new file mode 100644
index 0000000..a95b657
--- /dev/null
+++ b/sync/internal_api/public/base/invalidation_test_util.cc
@@ -0,0 +1,63 @@
+// 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/public/base/invalidation_test_util.h"
+
+#include "base/basictypes.h"
+#include "sync/internal_api/public/base/invalidation.h"
+
+namespace syncer {
+
+using ::testing::MakeMatcher;
+using ::testing::MatchResultListener;
+using ::testing::Matcher;
+using ::testing::MatcherInterface;
+using ::testing::PrintToString;
+
+namespace {
+
+class InvalidationEqMatcher
+    : public MatcherInterface<const Invalidation&> {
+ public:
+  explicit InvalidationEqMatcher(const Invalidation& expected);
+
+  virtual bool MatchAndExplain(const Invalidation& actual,
+                               MatchResultListener* listener) const;
+  virtual void DescribeTo(::std::ostream* os) const;
+  virtual void DescribeNegationTo(::std::ostream* os) const;
+
+ private:
+  const Invalidation expected_;
+
+  DISALLOW_COPY_AND_ASSIGN(InvalidationEqMatcher);
+};
+
+InvalidationEqMatcher::InvalidationEqMatcher(
+    const Invalidation& expected) : expected_(expected) {
+}
+
+bool InvalidationEqMatcher::MatchAndExplain(
+    const Invalidation& actual, MatchResultListener* listener) const {
+  return expected_.payload == actual.payload;
+}
+
+void InvalidationEqMatcher::DescribeTo(::std::ostream* os) const {
+  *os << " is equal to " << PrintToString(expected_);
+}
+
+void InvalidationEqMatcher::DescribeNegationTo(::std::ostream* os) const {
+  *os << " isn't equal to " << PrintToString(expected_);
+}
+
+}  // namespace
+
+void PrintTo(const Invalidation& invalidation, ::std::ostream* os) {
+  *os << "{ payload: " << invalidation.payload << " }";
+}
+
+Matcher<const Invalidation&> Eq(const Invalidation& expected) {
+  return MakeMatcher(new InvalidationEqMatcher(expected));
+}
+
+}  // namespace syncer
diff --git a/sync/internal_api/public/base/invalidation_test_util.h b/sync/internal_api/public/base/invalidation_test_util.h
new file mode 100644
index 0000000..694081d
--- /dev/null
+++ b/sync/internal_api/public/base/invalidation_test_util.h
@@ -0,0 +1,22 @@
+// 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.
+
+#ifndef SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_TEST_UTIL_H_
+#define SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_TEST_UTIL_H_
+
+#include <iosfwd>
+
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace syncer {
+
+struct Invalidation;
+
+void PrintTo(const Invalidation& invalidation, ::std::ostream* os);
+
+::testing::Matcher<const Invalidation&> Eq(const Invalidation& expected);
+
+}  // namespace syncer
+
+#endif  // SYNC_INTERNAL_API_PUBLIC_BASE_INVALIDATION_TEST_UTIL_H_
diff --git a/sync/internal_api/public/base/model_type_state_map.cc b/sync/internal_api/public/base/model_type_invalidation_map.cc
index fbdff7d..1084947 100644
--- a/sync/internal_api/public/base/model_type_state_map.cc
+++ b/sync/internal_api/public/base/model_type_invalidation_map.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 
 #include <vector>
 
@@ -13,38 +13,40 @@
 
 namespace syncer {
 
-ModelTypeStateMap ModelTypeSetToStateMap(ModelTypeSet types,
-                                         const std::string& payload) {
-  ModelTypeStateMap type_state_map;
+ModelTypeInvalidationMap ModelTypeSetToInvalidationMap(
+    ModelTypeSet types, const std::string& payload) {
+  ModelTypeInvalidationMap invalidation_map;
   for (ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
     // TODO(dcheng): Do we need to set ack_handle?
-    type_state_map[it.Get()].payload = payload;
+    invalidation_map[it.Get()].payload = payload;
   }
-  return type_state_map;
+  return invalidation_map;
 }
 
-ModelTypeSet ModelTypeStateMapToSet(
-    const ModelTypeStateMap& type_state_map) {
+ModelTypeSet ModelTypeInvalidationMapToSet(
+    const ModelTypeInvalidationMap& invalidation_map) {
   ModelTypeSet types;
-  for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
-       it != type_state_map.end(); ++it) {
+  for (ModelTypeInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
     types.Put(it->first);
   }
   return types;
 }
 
-std::string ModelTypeStateMapToString(const ModelTypeStateMap& type_state_map) {
-  scoped_ptr<DictionaryValue> value(ModelTypeStateMapToValue(type_state_map));
+std::string ModelTypeInvalidationMapToString(
+    const ModelTypeInvalidationMap& invalidation_map) {
+  scoped_ptr<DictionaryValue> value(
+      ModelTypeInvalidationMapToValue(invalidation_map));
   std::string json;
   base::JSONWriter::Write(value.get(), &json);
   return json;
 }
 
-DictionaryValue* ModelTypeStateMapToValue(
-    const ModelTypeStateMap& type_state_map) {
+DictionaryValue* ModelTypeInvalidationMapToValue(
+    const ModelTypeInvalidationMap& invalidation_map) {
   DictionaryValue* value = new DictionaryValue();
-  for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
-       it != type_state_map.end(); ++it) {
+  for (ModelTypeInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
     std::string printable_payload;
     base::JsonDoubleQuote(it->second.payload,
                           false /* put_in_quotes */,
@@ -54,12 +56,12 @@ DictionaryValue* ModelTypeStateMapToValue(
   return value;
 }
 
-void CoalesceStates(ModelTypeStateMap* original,
-                    const ModelTypeStateMap& update) {
+void CoalesceStates(ModelTypeInvalidationMap* original,
+                    const ModelTypeInvalidationMap& update) {
   // TODO(dcheng): Where is this called? Do we need to add more clever logic for
   // handling ack_handle? We probably want to always use the "latest"
   // ack_handle, which might imply always using the one in update?
-  for (ModelTypeStateMap::const_iterator i = update.begin();
+  for (ModelTypeInvalidationMap::const_iterator i = update.begin();
        i != update.end(); ++i) {
     if (original->count(i->first) == 0) {
       // If this datatype isn't already in our map, add it with
diff --git a/sync/internal_api/public/base/model_type_invalidation_map.h b/sync/internal_api/public/base/model_type_invalidation_map.h
new file mode 100644
index 0000000..7cc4a14
--- /dev/null
+++ b/sync/internal_api/public/base/model_type_invalidation_map.h
@@ -0,0 +1,53 @@
+// 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.
+//
+// Definition of ModelTypeInvalidationMap and various utility functions.
+
+#ifndef SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_INVALIDATION_MAP_H_
+#define SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_INVALIDATION_MAP_H_
+
+#include <map>
+#include <string>
+
+#include "sync/base/sync_export.h"
+#include "sync/internal_api/public/base/invalidation.h"
+#include "sync/internal_api/public/base/model_type.h"
+
+// TODO(akalin): Move the non-exported functions in this file to a
+// private header.
+
+namespace base {
+class DictionaryValue;
+}
+
+namespace syncer {
+
+// A map between sync data types and their associated invalidation.
+typedef std::map<ModelType, Invalidation> ModelTypeInvalidationMap;
+
+// Helper functions for building ModelTypeInvalidationMaps.
+
+// Make a ModelTypeInvalidationMap from all the types in a ModelTypeSet using a
+// default payload.
+SYNC_EXPORT ModelTypeInvalidationMap ModelTypeSetToInvalidationMap(
+    ModelTypeSet model_types, const std::string& payload);
+
+ModelTypeSet ModelTypeInvalidationMapToSet(
+    const ModelTypeInvalidationMap& invalidation_map);
+
+std::string ModelTypeInvalidationMapToString(
+    const ModelTypeInvalidationMap& invalidation_map);
+
+// Caller takes ownership of the returned dictionary.
+base::DictionaryValue* ModelTypeInvalidationMapToValue(
+    const ModelTypeInvalidationMap& invalidation_map);
+
+// Coalesce |update| into |original|, overwriting only when |update| has
+// a non-empty payload.
+void CoalesceStates(ModelTypeInvalidationMap* original,
+                    const ModelTypeInvalidationMap& update);
+
+}  // namespace syncer
+
+#endif  // SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_INVALIDATION_MAP_H_
diff --git a/sync/internal_api/public/base/model_type_state_map_test_util.cc b/sync/internal_api/public/base/model_type_invalidation_map_test_util.cc
index 3b975f8..991a6e1 100644
--- a/sync/internal_api/public/base/model_type_state_map_test_util.cc
+++ b/sync/internal_api/public/base/model_type_invalidation_map_test_util.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/internal_api/public/base/model_type_state_map_test_util.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map_test_util.h"
 
 #include <algorithm>
 
@@ -19,32 +19,33 @@ using ::testing::PrintToString;
 
 namespace {
 
-class ModelTypeStateMapEqMatcher
-    : public MatcherInterface<const ModelTypeStateMap&> {
+class ModelTypeInvalidationMapEqMatcher
+    : public MatcherInterface<const ModelTypeInvalidationMap&> {
  public:
-  explicit ModelTypeStateMapEqMatcher(const ModelTypeStateMap& expected);
+  explicit ModelTypeInvalidationMapEqMatcher(
+      const ModelTypeInvalidationMap& expected);
 
-  virtual bool MatchAndExplain(const ModelTypeStateMap& lhs,
+  virtual bool MatchAndExplain(const ModelTypeInvalidationMap& lhs,
                                MatchResultListener* listener) const;
   virtual void DescribeTo(::std::ostream* os) const;
   virtual void DescribeNegationTo(::std::ostream* os) const;
 
  private:
-  const ModelTypeStateMap expected_;
+  const ModelTypeInvalidationMap expected_;
 
-  DISALLOW_COPY_AND_ASSIGN(ModelTypeStateMapEqMatcher);
+  DISALLOW_COPY_AND_ASSIGN(ModelTypeInvalidationMapEqMatcher);
 };
 
-ModelTypeStateMapEqMatcher::ModelTypeStateMapEqMatcher(
-    const ModelTypeStateMap& expected) : expected_(expected) {
+ModelTypeInvalidationMapEqMatcher::ModelTypeInvalidationMapEqMatcher(
+    const ModelTypeInvalidationMap& expected) : expected_(expected) {
 }
 
-bool ModelTypeStateMapEqMatcher::MatchAndExplain(
-    const ModelTypeStateMap& actual, MatchResultListener* listener) const {
-  ModelTypeStateMap expected_only;
-  ModelTypeStateMap actual_only;
-  typedef std::pair<ModelType,
-                    std::pair<InvalidationState, InvalidationState> >
+bool ModelTypeInvalidationMapEqMatcher::MatchAndExplain(
+    const ModelTypeInvalidationMap& actual,
+    MatchResultListener* listener) const {
+  ModelTypeInvalidationMap expected_only;
+  ModelTypeInvalidationMap actual_only;
+  typedef std::pair<ModelType, std::pair<Invalidation, Invalidation> >
       ValueDifference;
   std::vector<ValueDifference> value_differences;
 
@@ -57,9 +58,9 @@ bool ModelTypeStateMapEqMatcher::MatchAndExplain(
                       std::inserter(actual_only, actual_only.begin()),
                       actual.value_comp());
 
-  for (ModelTypeStateMap::const_iterator it = expected_.begin();
+  for (ModelTypeInvalidationMap::const_iterator it = expected_.begin();
        it != expected_.end(); ++it) {
-    ModelTypeStateMap::const_iterator find_it =
+    ModelTypeInvalidationMap::const_iterator find_it =
         actual.find(it->first);
     if (find_it != actual.end() &&
         !Matches(Eq(it->second))(find_it->second)) {
@@ -94,18 +95,20 @@ bool ModelTypeStateMapEqMatcher::MatchAndExplain(
   return false;
 }
 
-void ModelTypeStateMapEqMatcher::DescribeTo(::std::ostream* os) const {
+void ModelTypeInvalidationMapEqMatcher::DescribeTo(::std::ostream* os) const {
   *os << " is equal to " << PrintToString(expected_);
 }
 
-void ModelTypeStateMapEqMatcher::DescribeNegationTo(::std::ostream* os) const {
+void ModelTypeInvalidationMapEqMatcher::DescribeNegationTo(
+    ::std::ostream* os) const {
   *os << " isn't equal to " << PrintToString(expected_);
 }
 
 }  // namespace
 
-Matcher<const ModelTypeStateMap&> Eq(const ModelTypeStateMap& expected) {
-  return MakeMatcher(new ModelTypeStateMapEqMatcher(expected));
+Matcher<const ModelTypeInvalidationMap&> Eq(
+    const ModelTypeInvalidationMap& expected) {
+  return MakeMatcher(new ModelTypeInvalidationMapEqMatcher(expected));
 }
 
 }  // namespace syncer
diff --git a/sync/internal_api/public/base/model_type_state_map_test_util.h b/sync/internal_api/public/base/model_type_invalidation_map_test_util.h
index 3538816..20a2819 100644
--- a/sync/internal_api/public/base/model_type_state_map_test_util.h
+++ b/sync/internal_api/public/base/model_type_invalidation_map_test_util.h
@@ -6,14 +6,14 @@
 #define SYNC_INTERNAL_API_PUBLIC_BASE_MODEL_TYPE_STATE_MAP_TEST_UTIL_H_
 
 // Convince googletest to use the correct overload for PrintTo().
-#include "sync/internal_api/public/base/invalidation_state_test_util.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/invalidation_test_util.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 namespace syncer {
 
-::testing::Matcher<const ModelTypeStateMap&> Eq(
-    const ModelTypeStateMap& expected);
+::testing::Matcher<const ModelTypeInvalidationMap&> Eq(
+    const ModelTypeInvalidationMap& expected);
 
 }  // namespace syncer
 
diff --git a/sync/internal_api/public/base/model_type_state_map_unittest.cc b/sync/internal_api/public/base/model_type_invalidation_map_unittest.cc
index 1981f3d..2b1049b 100644
--- a/sync/internal_api/public/base/model_type_state_map_unittest.cc
+++ b/sync/internal_api/public/base/model_type_invalidation_map_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 
 #include <string>
 
@@ -16,31 +16,31 @@ namespace {
 
 using base::ExpectDictStringValue;
 
-class ModelTypeStateMapTest : public testing::Test {};
+class ModelTypeInvalidationMapTest : public testing::Test {};
 
-TEST_F(ModelTypeStateMapTest, TypeStateMapToSet) {
-  ModelTypeStateMap states;
+TEST_F(ModelTypeInvalidationMapTest, TypeInvalidationMapToSet) {
+  ModelTypeInvalidationMap states;
   states[BOOKMARKS].payload = "bookmarkpayload";
   states[APPS].payload = "";
 
   const ModelTypeSet types(BOOKMARKS, APPS);
-  EXPECT_TRUE(ModelTypeStateMapToSet(states).Equals(types));
+  EXPECT_TRUE(ModelTypeInvalidationMapToSet(states).Equals(types));
 }
 
-TEST_F(ModelTypeStateMapTest, TypeStateMapToValue) {
-  ModelTypeStateMap states;
+TEST_F(ModelTypeInvalidationMapTest, TypeInvalidationMapToValue) {
+  ModelTypeInvalidationMap states;
   states[BOOKMARKS].payload = "bookmarkpayload";
   states[APPS].payload = "";
 
-  scoped_ptr<DictionaryValue> value(ModelTypeStateMapToValue(states));
+  scoped_ptr<DictionaryValue> value(ModelTypeInvalidationMapToValue(states));
   EXPECT_EQ(2u, value->size());
   ExpectDictStringValue(states[BOOKMARKS].payload, *value, "Bookmarks");
   ExpectDictStringValue("", *value, "Apps");
   EXPECT_FALSE(value->HasKey("Preferences"));
 }
 
-TEST_F(ModelTypeStateMapTest, CoalesceStates) {
-  ModelTypeStateMap original;
+TEST_F(ModelTypeInvalidationMapTest, CoalesceStates) {
+  ModelTypeInvalidationMap original;
   std::string empty_payload;
   std::string payload1 = "payload1";
   std::string payload2 = "payload2";
@@ -50,7 +50,7 @@ TEST_F(ModelTypeStateMapTest, CoalesceStates) {
   original[AUTOFILL].payload = payload2;
   original[THEMES].payload = payload3;
 
-  ModelTypeStateMap update;
+  ModelTypeInvalidationMap update;
   update[BOOKMARKS].payload = empty_payload;  // Same.
   update[PASSWORDS].payload = empty_payload;  // Overwrite with empty.
   update[AUTOFILL].payload = payload1;        // Overwrite with non-empty.
diff --git a/sync/internal_api/public/base/model_type_state_map.h b/sync/internal_api/public/base/model_type_state_map.h
deleted file mode 100644
index 5a9f84d..0000000
--- a/sync/internal_api/public/base/model_type_state_map.h
+++ /dev/null
@@ -1,54 +0,0 @@
-// 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.
-//
-// Definition of ModelTypeStateMap and various utility functions.
-
-#ifndef SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_STATE_MAP_H_
-#define SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_STATE_MAP_H_
-
-#include <map>
-#include <string>
-
-#include "sync/base/sync_export.h"
-#include "sync/internal_api/public/base/invalidation_state.h"
-#include "sync/internal_api/public/base/model_type.h"
-
-// TODO(akalin): Move the non-exported functions in this file to a
-// private header.
-
-namespace base {
-class DictionaryValue;
-}
-
-namespace syncer {
-
-// A container that contains a set of datatypes with possible string
-// payloads.
-typedef std::map<ModelType, InvalidationState> ModelTypeStateMap;
-
-// Helper functions for building ModelTypeStateMaps.
-
-// Make a TypeStateMap from all the types in a ModelTypeSet using a
-// default payload.
-SYNC_EXPORT ModelTypeStateMap ModelTypeSetToStateMap(
-    ModelTypeSet model_types, const std::string& payload);
-
-ModelTypeSet ModelTypeStateMapToSet(
-    const ModelTypeStateMap& type_state_map);
-
-std::string ModelTypeStateMapToString(
-    const ModelTypeStateMap& type_state_map);
-
-// Caller takes ownership of the returned dictionary.
-base::DictionaryValue* ModelTypeStateMapToValue(
-    const ModelTypeStateMap& type_state_map);
-
-// Coalesce |update| into |original|, overwriting only when |update| has
-// a non-empty payload.
-void CoalesceStates(ModelTypeStateMap* original,
-                    const ModelTypeStateMap& update);
-
-}  // namespace syncer
-
-#endif  // SYNC_INTERNAL_PUBLIC_API_BASE_MODEL_TYPE_STATE_MAP_H_
diff --git a/sync/internal_api/public/engine/model_safe_worker.cc b/sync/internal_api/public/engine/model_safe_worker.cc
index 2212a41..d7bf906 100644
--- a/sync/internal_api/public/engine/model_safe_worker.cc
+++ b/sync/internal_api/public/engine/model_safe_worker.cc
@@ -29,15 +29,15 @@ std::string ModelSafeRoutingInfoToString(
   return json;
 }
 
-ModelTypeStateMap ModelSafeRoutingInfoToStateMap(
+ModelTypeInvalidationMap ModelSafeRoutingInfoToInvalidationMap(
     const ModelSafeRoutingInfo& routes,
     const std::string& payload) {
-  ModelTypeStateMap type_state_map;
+  ModelTypeInvalidationMap invalidation_map;
   for (ModelSafeRoutingInfo::const_iterator i = routes.begin();
        i != routes.end(); ++i) {
-    type_state_map[i->first].payload = payload;
+    invalidation_map[i->first].payload = payload;
   }
-  return type_state_map;
+  return invalidation_map;
 }
 
 ModelTypeSet GetRoutingInfoTypes(const ModelSafeRoutingInfo& routing_info) {
diff --git a/sync/internal_api/public/engine/model_safe_worker.h b/sync/internal_api/public/engine/model_safe_worker.h
index d76ddb9..380beda 100644
--- a/sync/internal_api/public/engine/model_safe_worker.h
+++ b/sync/internal_api/public/engine/model_safe_worker.h
@@ -13,7 +13,7 @@
 #include "base/memory/ref_counted.h"
 #include "sync/base/sync_export.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/util/syncer_error.h"
 
 namespace base {
@@ -80,9 +80,9 @@ base::DictionaryValue* ModelSafeRoutingInfoToValue(
 SYNC_EXPORT std::string ModelSafeRoutingInfoToString(
     const ModelSafeRoutingInfo& routing_info);
 
-// Make a ModelTypeStateMap for all the enabled types in a
+// Make a ModelTypeInvalidationMap for all the enabled types in a
 // ModelSafeRoutingInfo using a default payload.
-ModelTypeStateMap ModelSafeRoutingInfoToStateMap(
+ModelTypeInvalidationMap ModelSafeRoutingInfoToInvalidationMap(
     const ModelSafeRoutingInfo& routes,
     const std::string& payload);
 
diff --git a/sync/internal_api/public/engine/model_safe_worker_unittest.cc b/sync/internal_api/public/engine/model_safe_worker_unittest.cc
index 9c65894..f879109 100644
--- a/sync/internal_api/public/engine/model_safe_worker_unittest.cc
+++ b/sync/internal_api/public/engine/model_safe_worker_unittest.cc
@@ -48,19 +48,19 @@ TEST_F(ModelSafeWorkerTest, GetRoutingInfoTypes) {
   EXPECT_TRUE(GetRoutingInfoTypes(routing_info).Equals(expected_types));
 }
 
-TEST_F(ModelSafeWorkerTest, ModelSafeRoutingInfoToStateMap) {
+TEST_F(ModelSafeWorkerTest, ModelSafeRoutingInfoToInvalidationMap) {
   std::string payload = "test";
   ModelSafeRoutingInfo routing_info;
   routing_info[BOOKMARKS] = GROUP_PASSIVE;
   routing_info[NIGORI] = GROUP_UI;
   routing_info[PREFERENCES] = GROUP_DB;
-  ModelTypeStateMap type_state_map =
-      ModelSafeRoutingInfoToStateMap(routing_info, payload);
-  ASSERT_EQ(routing_info.size(), type_state_map.size());
+  ModelTypeInvalidationMap invalidation_map =
+      ModelSafeRoutingInfoToInvalidationMap(routing_info, payload);
+  ASSERT_EQ(routing_info.size(), invalidation_map.size());
   for (ModelSafeRoutingInfo::iterator iter = routing_info.begin();
        iter != routing_info.end();
        ++iter) {
-    EXPECT_EQ(payload, type_state_map[iter->first].payload);
+    EXPECT_EQ(payload, invalidation_map[iter->first].payload);
   }
 }
 
diff --git a/sync/internal_api/public/sessions/sync_session_snapshot.cc b/sync/internal_api/public/sessions/sync_session_snapshot.cc
index 9e7a3b1..15e8893 100644
--- a/sync/internal_api/public/sessions/sync_session_snapshot.cc
+++ b/sync/internal_api/public/sessions/sync_session_snapshot.cc
@@ -29,7 +29,7 @@ SyncSessionSnapshot::SyncSessionSnapshot(
     const ModelNeutralState& model_neutral_state,
     bool is_share_usable,
     ModelTypeSet initial_sync_ended,
-    const ModelTypeStateMap& download_progress_markers,
+    const ModelTypeInvalidationMap& download_progress_markers,
     bool more_to_sync,
     bool is_silenced,
     int num_encryption_conflicts,
@@ -84,7 +84,7 @@ DictionaryValue* SyncSessionSnapshot::ToValue() const {
   value->Set("initialSyncEnded",
              ModelTypeSetToValue(initial_sync_ended_));
   value->Set("downloadProgressMarkers",
-             ModelTypeStateMapToValue(download_progress_markers_));
+             ModelTypeInvalidationMapToValue(download_progress_markers_));
   value->SetBoolean("hasMoreToSync", has_more_to_sync_);
   value->SetBoolean("isSilenced", is_silenced_);
   // We don't care too much if we lose precision here, also.
@@ -123,7 +123,8 @@ ModelTypeSet SyncSessionSnapshot::initial_sync_ended() const {
   return initial_sync_ended_;
 }
 
-ModelTypeStateMap SyncSessionSnapshot::download_progress_markers() const {
+ModelTypeInvalidationMap
+SyncSessionSnapshot::download_progress_markers() const {
   return download_progress_markers_;
 }
 
diff --git a/sync/internal_api/public/sessions/sync_session_snapshot.h b/sync/internal_api/public/sessions/sync_session_snapshot.h
index 74e972b..1cc250f 100644
--- a/sync/internal_api/public/sessions/sync_session_snapshot.h
+++ b/sync/internal_api/public/sessions/sync_session_snapshot.h
@@ -10,7 +10,7 @@
 #include "base/basictypes.h"
 #include "base/time.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/sessions/model_neutral_state.h"
 #include "sync/internal_api/public/sessions/sync_source_info.h"
 
@@ -33,7 +33,7 @@ class SyncSessionSnapshot {
       const ModelNeutralState& model_neutral_state,
       bool is_share_usable,
       ModelTypeSet initial_sync_ended,
-      const ModelTypeStateMap& download_progress_markers,
+      const ModelTypeInvalidationMap& download_progress_markers,
       bool more_to_sync,
       bool is_silenced,
       int num_encryption_conflicts,
@@ -58,7 +58,7 @@ class SyncSessionSnapshot {
   int64 num_server_changes_remaining() const;
   bool is_share_usable() const;
   ModelTypeSet initial_sync_ended() const;
-  ModelTypeStateMap download_progress_markers() const;
+  ModelTypeInvalidationMap download_progress_markers() const;
   bool has_more_to_sync() const;
   bool is_silenced() const;
   int num_encryption_conflicts() const;
@@ -78,7 +78,7 @@ class SyncSessionSnapshot {
   ModelNeutralState model_neutral_state_;
   bool is_share_usable_;
   ModelTypeSet initial_sync_ended_;
-  ModelTypeStateMap download_progress_markers_;
+  ModelTypeInvalidationMap download_progress_markers_;
   bool has_more_to_sync_;
   bool is_silenced_;
   int num_encryption_conflicts_;
diff --git a/sync/internal_api/public/sessions/sync_source_info.cc b/sync/internal_api/public/sessions/sync_source_info.cc
index 8a64c8a..c3b08d1 100644
--- a/sync/internal_api/public/sessions/sync_source_info.cc
+++ b/sync/internal_api/public/sessions/sync_source_info.cc
@@ -13,12 +13,12 @@ namespace sessions {
 SyncSourceInfo::SyncSourceInfo()
     : updates_source(sync_pb::GetUpdatesCallerInfo::UNKNOWN) {}
 
-SyncSourceInfo::SyncSourceInfo(const ModelTypeStateMap& t)
+SyncSourceInfo::SyncSourceInfo(const ModelTypeInvalidationMap& t)
     : updates_source(sync_pb::GetUpdatesCallerInfo::UNKNOWN), types(t) {}
 
 SyncSourceInfo::SyncSourceInfo(
     const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& u,
-    const ModelTypeStateMap& t)
+    const ModelTypeInvalidationMap& t)
     : updates_source(u), types(t) {}
 
 SyncSourceInfo::~SyncSourceInfo() {}
@@ -27,7 +27,7 @@ DictionaryValue* SyncSourceInfo::ToValue() const {
   DictionaryValue* value = new DictionaryValue();
   value->SetString("updatesSource",
                    GetUpdatesSourceString(updates_source));
-  value->Set("types", ModelTypeStateMapToValue(types));
+  value->Set("types", ModelTypeInvalidationMapToValue(types));
   return value;
 }
 
diff --git a/sync/internal_api/public/sessions/sync_source_info.h b/sync/internal_api/public/sessions/sync_source_info.h
index 619fc57..f1f0920 100644
--- a/sync/internal_api/public/sessions/sync_source_info.h
+++ b/sync/internal_api/public/sessions/sync_source_info.h
@@ -7,7 +7,7 @@
 
 #include "base/basictypes.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace base {
@@ -22,17 +22,17 @@ namespace sessions {
 // specific payloads which should be sent to the server.
 struct SyncSourceInfo {
   SyncSourceInfo();
-  explicit SyncSourceInfo(const ModelTypeStateMap& t);
+  explicit SyncSourceInfo(const ModelTypeInvalidationMap& t);
   SyncSourceInfo(
       const sync_pb::GetUpdatesCallerInfo::GetUpdatesSource& u,
-      const ModelTypeStateMap& t);
+      const ModelTypeInvalidationMap& t);
   ~SyncSourceInfo();
 
   // Caller takes ownership of the returned dictionary.
   base::DictionaryValue* ToValue() const;
 
   sync_pb::GetUpdatesCallerInfo::GetUpdatesSource updates_source;
-  ModelTypeStateMap types;
+  ModelTypeInvalidationMap types;
 };
 
 }  // namespace sessions
diff --git a/sync/internal_api/public/test/fake_sync_manager.h b/sync/internal_api/public/test/fake_sync_manager.h
index b050aca..826753d 100644
--- a/sync/internal_api/public/test/fake_sync_manager.h
+++ b/sync/internal_api/public/test/fake_sync_manager.h
@@ -54,7 +54,7 @@ class FakeSyncManager : public SyncManager {
   ModelTypeSet GetAndResetEnabledTypes();
 
   // Posts a method to invalidate the given IDs on the sync thread.
-  void Invalidate(const ObjectIdStateMap& id_state_map,
+  void Invalidate(const ObjectIdInvalidationMap& invalidation_map,
                   IncomingInvalidationSource source);
 
   // Posts a method to update the invalidator state on the sync thread.
@@ -121,7 +121,7 @@ class FakeSyncManager : public SyncManager {
 
  private:
   void InvalidateOnSyncThread(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source);
   void UpdateInvalidatorStateOnSyncThread(InvalidatorState state);
 
diff --git a/sync/internal_api/sync_manager_impl.cc b/sync/internal_api/sync_manager_impl.cc
index 8a53d78..b5ee26b 100644
--- a/sync/internal_api/sync_manager_impl.cc
+++ b/sync/internal_api/sync_manager_impl.cc
@@ -21,7 +21,7 @@
 #include "sync/engine/syncer_types.h"
 #include "sync/internal_api/change_reorder_buffer.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/base_node.h"
 #include "sync/internal_api/public/configure_reason.h"
 #include "sync/internal_api/public/engine/polling_constants.h"
@@ -1016,9 +1016,10 @@ void SyncManagerImpl::OnSyncEngineEvent(const SyncEngineEvent& event) {
         (event.snapshot.model_neutral_state().num_successful_commits > 0);
     if (is_notifiable_commit) {
       if (invalidator_.get()) {
-        const ObjectIdStateMap& id_state_map =
-            ModelTypeStateMapToObjectIdStateMap(event.snapshot.source().types);
-        invalidator_->SendInvalidation(id_state_map);
+        const ObjectIdInvalidationMap& invalidation_map =
+            ModelTypeInvalidationMapToObjectIdInvalidationMap(
+                event.snapshot.source().types);
+        invalidator_->SendInvalidation(invalidation_map);
       } else {
         DVLOG(1) << "Not sending invalidation: invalidator_ is NULL";
       }
@@ -1236,9 +1237,9 @@ JsArgList SyncManagerImpl::GetChildNodeIds(const JsArgList& args) {
 }
 
 void SyncManagerImpl::UpdateNotificationInfo(
-    const ModelTypeStateMap& type_state_map) {
-  for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
-       it != type_state_map.end(); ++it) {
+    const ModelTypeInvalidationMap& invalidation_map) {
+  for (ModelTypeInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
     NotificationInfo* info = &notification_info_map_[it->first];
     info->total_count++;
     info->payload = it->second.payload;
@@ -1268,26 +1269,26 @@ void SyncManagerImpl::OnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void SyncManagerImpl::OnIncomingInvalidation(
-    const ObjectIdStateMap& id_state_map,
+    const ObjectIdInvalidationMap& invalidation_map,
     IncomingInvalidationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  const ModelTypeStateMap& type_state_map =
-      ObjectIdStateMapToModelTypeStateMap(id_state_map);
+  const ModelTypeInvalidationMap& type_invalidation_map =
+      ObjectIdInvalidationMapToModelTypeInvalidationMap(invalidation_map);
   if (source == LOCAL_INVALIDATION) {
     allstatus_.IncrementNudgeCounter(NUDGE_SOURCE_LOCAL_REFRESH);
     scheduler_->ScheduleNudgeWithStatesAsync(
         TimeDelta::FromMilliseconds(kSyncRefreshDelayMsec),
         NUDGE_SOURCE_LOCAL_REFRESH,
-        type_state_map, FROM_HERE);
-  } else if (!type_state_map.empty()) {
+        type_invalidation_map, FROM_HERE);
+  } else if (!type_invalidation_map.empty()) {
     allstatus_.IncrementNudgeCounter(NUDGE_SOURCE_NOTIFICATION);
     scheduler_->ScheduleNudgeWithStatesAsync(
         TimeDelta::FromMilliseconds(kSyncSchedulerDelayMsec),
         NUDGE_SOURCE_NOTIFICATION,
-        type_state_map, FROM_HERE);
+        type_invalidation_map, FROM_HERE);
     allstatus_.IncrementNotificationsReceived();
-    UpdateNotificationInfo(type_state_map);
-    debug_info_event_listener_.OnIncomingNotification(type_state_map);
+    UpdateNotificationInfo(type_invalidation_map);
+    debug_info_event_listener_.OnIncomingNotification(type_invalidation_map);
   } else {
     LOG(WARNING) << "Sync received invalidation without any type information.";
   }
@@ -1296,8 +1297,9 @@ void SyncManagerImpl::OnIncomingInvalidation(
     DictionaryValue details;
     ListValue* changed_types = new ListValue();
     details.Set("changedTypes", changed_types);
-    for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
-         it != type_state_map.end(); ++it) {
+    for (ModelTypeInvalidationMap::const_iterator it =
+             type_invalidation_map.begin(); it != type_invalidation_map.end();
+         ++it) {
       const std::string& model_type_str =
           ModelTypeToString(it->first);
       changed_types->Append(Value::CreateStringValue(model_type_str));
diff --git a/sync/internal_api/sync_manager_impl.h b/sync/internal_api/sync_manager_impl.h
index e315b2c..2ead8f4 100644
--- a/sync/internal_api/sync_manager_impl.h
+++ b/sync/internal_api/sync_manager_impl.h
@@ -169,7 +169,7 @@ class SyncManagerImpl : public SyncManager,
   // InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) OVERRIDE;
 
   // Called only by our NetworkChangeNotifier.
@@ -253,7 +253,7 @@ class SyncManagerImpl : public SyncManager,
   // Called for every notification. This updates the notification statistics
   // to be displayed in about:sync.
   void UpdateNotificationInfo(
-      const ModelTypeStateMap& type_state_map);
+      const ModelTypeInvalidationMap& invalidation_map);
 
   // Checks for server reachabilty and requests a nudge.
   void OnIPAddressChangedImpl();
diff --git a/sync/internal_api/sync_manager_impl_unittest.cc b/sync/internal_api/sync_manager_impl_unittest.cc
index 51b6689..362e305 100644
--- a/sync/internal_api/sync_manager_impl_unittest.cc
+++ b/sync/internal_api/sync_manager_impl_unittest.cc
@@ -911,10 +911,11 @@ class SyncManagerTest : public testing::Test,
 
   void TriggerOnIncomingNotificationForTest(ModelTypeSet model_types) {
     DCHECK(sync_manager_.thread_checker_.CalledOnValidThread());
-    ModelTypeStateMap type_state_map =
-        ModelTypeSetToStateMap(model_types, std::string());
+    ModelTypeInvalidationMap invalidation_map =
+        ModelTypeSetToInvalidationMap(model_types, std::string());
     sync_manager_.OnIncomingInvalidation(
-        ModelTypeStateMapToObjectIdStateMap(type_state_map),
+        ModelTypeInvalidationMapToObjectIdInvalidationMap(
+            invalidation_map),
         REMOTE_INVALIDATION);
   }
 
diff --git a/sync/internal_api/test/fake_sync_manager.cc b/sync/internal_api/test/fake_sync_manager.cc
index 15794b0..aeeffb0 100644
--- a/sync/internal_api/test/fake_sync_manager.cc
+++ b/sync/internal_api/test/fake_sync_manager.cc
@@ -18,7 +18,7 @@
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/invalidator.h"
 #include "sync/notifier/invalidator_state.h"
-#include "sync/notifier/object_id_state_map.h"
+#include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/test/fake_sync_encryption_handler.h"
 
 namespace syncer {
@@ -52,12 +52,13 @@ ModelTypeSet FakeSyncManager::GetAndResetEnabledTypes() {
   return enabled_types;
 }
 
-void FakeSyncManager::Invalidate(const ObjectIdStateMap& id_state_map,
-                                 IncomingInvalidationSource source) {
+void FakeSyncManager::Invalidate(
+    const ObjectIdInvalidationMap& invalidation_map,
+    IncomingInvalidationSource source) {
   if (!sync_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&FakeSyncManager::InvalidateOnSyncThread,
-                 base::Unretained(this), id_state_map, source))) {
+                 base::Unretained(this), invalidation_map, source))) {
     NOTREACHED();
   }
 }
@@ -251,10 +252,10 @@ SyncEncryptionHandler* FakeSyncManager::GetEncryptionHandler() {
 }
 
 void FakeSyncManager::InvalidateOnSyncThread(
-    const ObjectIdStateMap& id_state_map,
+    const ObjectIdInvalidationMap& invalidation_map,
     IncomingInvalidationSource source) {
   DCHECK(sync_task_runner_->RunsTasksOnCurrentThread());
-  registrar_.DispatchInvalidationsToHandlers(id_state_map, source);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map, source);
 }
 
 void FakeSyncManager::UpdateInvalidatorStateOnSyncThread(
diff --git a/sync/notifier/fake_invalidation_handler.cc b/sync/notifier/fake_invalidation_handler.cc
index d63a549..e646bd6 100644
--- a/sync/notifier/fake_invalidation_handler.cc
+++ b/sync/notifier/fake_invalidation_handler.cc
@@ -17,9 +17,9 @@ InvalidatorState FakeInvalidationHandler::GetInvalidatorState() const {
   return state_;
 }
 
-const ObjectIdStateMap&
-FakeInvalidationHandler::GetLastInvalidationIdStateMap() const {
-  return last_id_state_map_;
+const ObjectIdInvalidationMap&
+FakeInvalidationHandler::GetLastInvalidationMap() const {
+  return last_invalidation_map_;
 }
 
 IncomingInvalidationSource
@@ -36,9 +36,9 @@ void FakeInvalidationHandler::OnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void FakeInvalidationHandler::OnIncomingInvalidation(
-    const ObjectIdStateMap& id_state_map,
+    const ObjectIdInvalidationMap& invalidation_map,
     IncomingInvalidationSource source) {
-  last_id_state_map_ = id_state_map;
+  last_invalidation_map_ = invalidation_map;
   last_source_ = source;
   ++invalidation_count_;
 }
diff --git a/sync/notifier/fake_invalidation_handler.h b/sync/notifier/fake_invalidation_handler.h
index fd6ffb3..5f2b8e6 100644
--- a/sync/notifier/fake_invalidation_handler.h
+++ b/sync/notifier/fake_invalidation_handler.h
@@ -19,19 +19,19 @@ class FakeInvalidationHandler : public InvalidationHandler {
   virtual ~FakeInvalidationHandler();
 
   InvalidatorState GetInvalidatorState() const;
-  const ObjectIdStateMap& GetLastInvalidationIdStateMap() const;
+  const ObjectIdInvalidationMap& GetLastInvalidationMap() const;
   IncomingInvalidationSource GetLastInvalidationSource() const;
   int GetInvalidationCount() const;
 
   // InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) OVERRIDE;
 
  private:
   InvalidatorState state_;
-  ObjectIdStateMap last_id_state_map_;
+  ObjectIdInvalidationMap last_invalidation_map_;
   IncomingInvalidationSource last_source_;
   int invalidation_count_;
 
diff --git a/sync/notifier/fake_invalidator.cc b/sync/notifier/fake_invalidator.cc
index c2b7135..1a99819 100644
--- a/sync/notifier/fake_invalidator.cc
+++ b/sync/notifier/fake_invalidator.cc
@@ -35,8 +35,9 @@ const std::string& FakeInvalidator::GetCredentialsToken() const {
   return token_;
 }
 
-const ObjectIdStateMap& FakeInvalidator::GetLastSentIdStateMap() const {
-  return last_sent_id_state_map_;
+const ObjectIdInvalidationMap&
+FakeInvalidator::GetLastSentInvalidationMap() const {
+  return last_sent_invalidation_map_;
 }
 
 void FakeInvalidator::EmitOnInvalidatorStateChange(InvalidatorState state) {
@@ -44,9 +45,9 @@ void FakeInvalidator::EmitOnInvalidatorStateChange(InvalidatorState state) {
 }
 
 void FakeInvalidator::EmitOnIncomingInvalidation(
-    const ObjectIdStateMap& id_state_map,
+    const ObjectIdInvalidationMap& invalidation_map,
     IncomingInvalidationSource source) {
-  registrar_.DispatchInvalidationsToHandlers(id_state_map, source);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map, source);
 }
 
 void FakeInvalidator::RegisterHandler(InvalidationHandler* handler) {
@@ -80,8 +81,9 @@ void FakeInvalidator::UpdateCredentials(
   token_ = token;
 }
 
-void FakeInvalidator::SendInvalidation(const ObjectIdStateMap& id_state_map) {
-  last_sent_id_state_map_ = id_state_map;
+void FakeInvalidator::SendInvalidation(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  last_sent_invalidation_map_ = invalidation_map;
 }
 
 }  // namespace syncer
diff --git a/sync/notifier/fake_invalidator.h b/sync/notifier/fake_invalidator.h
index dff7d21..b65fcea 100644
--- a/sync/notifier/fake_invalidator.h
+++ b/sync/notifier/fake_invalidator.h
@@ -25,11 +25,12 @@ class FakeInvalidator : public Invalidator {
   const std::string& GetStateDeprecated() const;
   const std::string& GetCredentialsEmail() const;
   const std::string& GetCredentialsToken() const;
-  const ObjectIdStateMap& GetLastSentIdStateMap() const;
+  const ObjectIdInvalidationMap& GetLastSentInvalidationMap() const;
 
   void EmitOnInvalidatorStateChange(InvalidatorState state);
-  void EmitOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-                                  IncomingInvalidationSource source);
+  void EmitOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source);
 
   virtual void RegisterHandler(InvalidationHandler* handler) OVERRIDE;
   virtual void UpdateRegisteredIds(InvalidationHandler* handler,
@@ -40,7 +41,8 @@ class FakeInvalidator : public Invalidator {
   virtual void SetStateDeprecated(const std::string& state) OVERRIDE;
   virtual void UpdateCredentials(
       const std::string& email, const std::string& token) OVERRIDE;
-  virtual void SendInvalidation(const ObjectIdStateMap& id_state_map) OVERRIDE;
+  virtual void SendInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
  private:
   InvalidatorRegistrar registrar_;
@@ -48,7 +50,7 @@ class FakeInvalidator : public Invalidator {
   std::string state_;
   std::string email_;
   std::string token_;
-  ObjectIdStateMap last_sent_id_state_map_;
+  ObjectIdInvalidationMap last_sent_invalidation_map_;
 };
 
 }  // namespace syncer
diff --git a/sync/notifier/fake_invalidator_unittest.cc b/sync/notifier/fake_invalidator_unittest.cc
index 6b5decc..e94f60b 100644
--- a/sync/notifier/fake_invalidator_unittest.cc
+++ b/sync/notifier/fake_invalidator_unittest.cc
@@ -44,9 +44,10 @@ class FakeInvalidatorTestDelegate {
     invalidator_->EmitOnInvalidatorStateChange(state);
   }
 
-  void TriggerOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-                                     IncomingInvalidationSource source) {
-    invalidator_->EmitOnIncomingInvalidation(id_state_map, source);
+  void TriggerOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source) {
+    invalidator_->EmitOnIncomingInvalidation(invalidation_map, source);
   }
 
   static bool InvalidatorHandlesDeprecatedState() {
diff --git a/sync/notifier/invalidation_handler.h b/sync/notifier/invalidation_handler.h
index 58f3a53..0dd4721 100644
--- a/sync/notifier/invalidation_handler.h
+++ b/sync/notifier/invalidation_handler.h
@@ -6,7 +6,7 @@
 #define SYNC_NOTIFIER_INVALIDATION_HANDLER_H_
 
 #include "sync/notifier/invalidator_state.h"
-#include "sync/notifier/object_id_state_map.h"
+#include "sync/notifier/object_id_invalidation_map.h"
 
 namespace syncer {
 
@@ -26,7 +26,7 @@ class InvalidationHandler {
   // |id_state_map| and the source is in |source|.  Note that this may be
   // called regardless of the current invalidator state.
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) = 0;
 
  protected:
diff --git a/sync/notifier/invalidation_notifier.cc b/sync/notifier/invalidation_notifier.cc
index 7b00b12..873c578 100644
--- a/sync/notifier/invalidation_notifier.cc
+++ b/sync/notifier/invalidation_notifier.cc
@@ -100,14 +100,16 @@ void InvalidationNotifier::UpdateCredentials(
 }
 
 void InvalidationNotifier::SendInvalidation(
-    const ObjectIdStateMap& id_state_map) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(CalledOnValidThread());
   // Do nothing.
 }
 
-void InvalidationNotifier::OnInvalidate(const ObjectIdStateMap& id_state_map) {
+void InvalidationNotifier::OnInvalidate(
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(CalledOnValidThread());
-  registrar_.DispatchInvalidationsToHandlers(id_state_map, REMOTE_INVALIDATION);
+  registrar_.DispatchInvalidationsToHandlers(invalidation_map,
+                                             REMOTE_INVALIDATION);
 }
 
 void InvalidationNotifier::OnInvalidatorStateChange(InvalidatorState state) {
diff --git a/sync/notifier/invalidation_notifier.h b/sync/notifier/invalidation_notifier.h
index ae67a22..f736124 100644
--- a/sync/notifier/invalidation_notifier.h
+++ b/sync/notifier/invalidation_notifier.h
@@ -59,10 +59,12 @@ class InvalidationNotifier
   virtual void SetStateDeprecated(const std::string& state) OVERRIDE;
   virtual void UpdateCredentials(
       const std::string& email, const std::string& token) OVERRIDE;
-  virtual void SendInvalidation(const ObjectIdStateMap& id_state_map) OVERRIDE;
+  virtual void SendInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
   // SyncInvalidationListener::Delegate implementation.
-  virtual void OnInvalidate(const ObjectIdStateMap& id_state_map) OVERRIDE;
+  virtual void OnInvalidate(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
 
  private:
diff --git a/sync/notifier/invalidation_notifier_unittest.cc b/sync/notifier/invalidation_notifier_unittest.cc
index 2e94420..14877a6 100644
--- a/sync/notifier/invalidation_notifier_unittest.cc
+++ b/sync/notifier/invalidation_notifier_unittest.cc
@@ -11,13 +11,13 @@
 #include "jingle/notifier/listener/fake_push_client.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/fake_invalidation_state_tracker.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidator_test_template.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -68,10 +68,11 @@ class InvalidationNotifierTestDelegate {
     invalidator_->OnInvalidatorStateChange(state);
   }
 
-  void TriggerOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-                                     IncomingInvalidationSource source) {
+  void TriggerOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source) {
     // None of the tests actually care about |source|.
-    invalidator_->OnInvalidate(id_state_map);
+    invalidator_->OnInvalidate(invalidation_map);
   }
 
   static bool InvalidatorHandlesDeprecatedState() {
diff --git a/sync/notifier/invalidator.h b/sync/notifier/invalidator.h
index d5435bc..cd5c289 100644
--- a/sync/notifier/invalidator.h
+++ b/sync/notifier/invalidator.h
@@ -14,7 +14,7 @@
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/notifier/invalidation_util.h"
 #include "sync/notifier/invalidator_state.h"
-#include "sync/notifier/object_id_state_map.h"
+#include "sync/notifier/object_id_invalidation_map.h"
 
 namespace syncer {
 class InvalidationHandler;
@@ -89,7 +89,8 @@ class Invalidator {
   // which is still used by sync integration tests.
   // TODO(akalin): Remove this once we move the integration tests off p2p
   // notifications.
-  virtual void SendInvalidation(const ObjectIdStateMap& id_state_map) = 0;
+  virtual void SendInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) = 0;
 };
 }  // namespace syncer
 
diff --git a/sync/notifier/invalidator_registrar.cc b/sync/notifier/invalidator_registrar.cc
index 65cb318..1fb6571 100644
--- a/sync/notifier/invalidator_registrar.cc
+++ b/sync/notifier/invalidator_registrar.cc
@@ -88,7 +88,7 @@ ObjectIdSet InvalidatorRegistrar::GetAllRegisteredIds() const {
 }
 
 void InvalidatorRegistrar::DispatchInvalidationsToHandlers(
-    const ObjectIdStateMap& id_state_map,
+    const ObjectIdInvalidationMap& invalidation_map,
     IncomingInvalidationSource source) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // If we have no handlers, there's nothing to do.
@@ -96,10 +96,10 @@ void InvalidatorRegistrar::DispatchInvalidationsToHandlers(
     return;
   }
 
-  typedef std::map<InvalidationHandler*, ObjectIdStateMap> DispatchMap;
+  typedef std::map<InvalidationHandler*, ObjectIdInvalidationMap> DispatchMap;
   DispatchMap dispatch_map;
-  for (ObjectIdStateMap::const_iterator it = id_state_map.begin();
-       it != id_state_map.end(); ++it) {
+  for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
     InvalidationHandler* const handler = ObjectIdToHandler(it->first);
     // Filter out invalidations for IDs with no handler.
     if (handler)
diff --git a/sync/notifier/invalidator_registrar.h b/sync/notifier/invalidator_registrar.h
index 1589c5c..90884d2 100644
--- a/sync/notifier/invalidator_registrar.h
+++ b/sync/notifier/invalidator_registrar.h
@@ -12,7 +12,7 @@
 #include "base/threading/thread_checker.h"
 #include "sync/notifier/invalidation_handler.h"
 #include "sync/notifier/invalidation_util.h"
-#include "sync/notifier/object_id_state_map.h"
+#include "sync/notifier/object_id_invalidation_map.h"
 
 namespace invalidation {
 class ObjectId;
@@ -54,8 +54,9 @@ class InvalidatorRegistrar {
   // dispatches the batched invalidations to the corresponding handler.
   // Invalidations for IDs with no corresponding handler are dropped, as are
   // invalidations for handlers that are not added.
-  void DispatchInvalidationsToHandlers(const ObjectIdStateMap& id_state_map,
-                                       IncomingInvalidationSource source);
+  void DispatchInvalidationsToHandlers(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source);
 
   // Updates the invalidator state to the given one and then notifies
   // all handlers.  Note that the order is important; handlers that
diff --git a/sync/notifier/invalidator_registrar_unittest.cc b/sync/notifier/invalidator_registrar_unittest.cc
index f9f478b..043d7eb 100644
--- a/sync/notifier/invalidator_registrar_unittest.cc
+++ b/sync/notifier/invalidator_registrar_unittest.cc
@@ -9,7 +9,7 @@
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/invalidator_registrar.h"
 #include "sync/notifier/invalidator_test_template.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -60,7 +60,8 @@ class RegistrarInvalidator : public Invalidator {
     // Do nothing.
   }
 
-  virtual void SendInvalidation(const ObjectIdStateMap& id_state_map) OVERRIDE {
+  virtual void SendInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE {
     // Do nothing.
   }
 
@@ -102,10 +103,11 @@ class RegistrarInvalidatorTestDelegate {
     invalidator_->GetRegistrar()->UpdateInvalidatorState(state);
   }
 
-  void TriggerOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-                                     IncomingInvalidationSource source) {
+  void TriggerOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source) {
     invalidator_->GetRegistrar()->DispatchInvalidationsToHandlers(
-        id_state_map, source);
+        invalidation_map, source);
   }
 
   static bool InvalidatorHandlesDeprecatedState() {
diff --git a/sync/notifier/invalidator_test_template.h b/sync/notifier/invalidator_test_template.h
index 5bf841c..411da8c 100644
--- a/sync/notifier/invalidator_test_template.h
+++ b/sync/notifier/invalidator_test_template.h
@@ -56,8 +56,9 @@
 //     // Should cause OnIncomingInvalidation() to be called on all
 //     // observers of the Invalidator implementation with the given
 //     // parameters.
-//     void TriggerOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-//                                        IncomingInvalidationSource source) {
+//     void TriggerOnIncomingInvalidation(
+//         const ObjectIdInvalidationMap& invalidation_map,
+//         IncomingInvalidationSource source) {
 //       ...
 //     }
 //
@@ -90,8 +91,8 @@
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/fake_invalidation_state_tracker.h"
 #include "sync/notifier/invalidator.h"
-#include "sync/notifier/object_id_state_map.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -148,7 +149,7 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
 
   invalidator->RegisterHandler(&handler);
 
-  ObjectIdStateMap states;
+  ObjectIdInvalidationMap states;
   states[this->id1].payload = "1";
   states[this->id2].payload = "2";
   states[this->id3].payload = "3";
@@ -165,15 +166,13 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
   this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
 
-  ObjectIdStateMap expected_states;
+  ObjectIdInvalidationMap expected_states;
   expected_states[this->id1].payload = "1";
   expected_states[this->id2].payload = "2";
 
   this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
   EXPECT_EQ(1, handler.GetInvalidationCount());
-  EXPECT_THAT(
-      expected_states,
-      Eq(handler.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(expected_states, Eq(handler.GetLastInvalidationMap()));
   EXPECT_EQ(REMOTE_INVALIDATION, handler.GetLastInvalidationSource());
 
   ids.erase(this->id1);
@@ -186,9 +185,7 @@ TYPED_TEST_P(InvalidatorTest, Basic) {
   // Removed object IDs should not be notified, newly-added ones should.
   this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
   EXPECT_EQ(2, handler.GetInvalidationCount());
-  EXPECT_THAT(
-      expected_states,
-      Eq(handler.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(expected_states, Eq(handler.GetLastInvalidationMap()));
   EXPECT_EQ(REMOTE_INVALIDATION, handler.GetLastInvalidationSource());
 
   this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
@@ -255,30 +252,26 @@ TYPED_TEST_P(InvalidatorTest, MultipleHandlers) {
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler4.GetInvalidatorState());
 
   {
-    ObjectIdStateMap states;
+    ObjectIdInvalidationMap states;
     states[this->id1].payload = "1";
     states[this->id2].payload = "2";
     states[this->id3].payload = "3";
     states[this->id4].payload = "4";
     this->delegate_.TriggerOnIncomingInvalidation(states, REMOTE_INVALIDATION);
 
-    ObjectIdStateMap expected_states;
+    ObjectIdInvalidationMap expected_states;
     expected_states[this->id1].payload = "1";
     expected_states[this->id2].payload = "2";
 
     EXPECT_EQ(1, handler1.GetInvalidationCount());
-    EXPECT_THAT(
-        expected_states,
-        Eq(handler1.GetLastInvalidationIdStateMap()));
+    EXPECT_THAT(expected_states, Eq(handler1.GetLastInvalidationMap()));
     EXPECT_EQ(REMOTE_INVALIDATION, handler1.GetLastInvalidationSource());
 
     expected_states.clear();
     expected_states[this->id3].payload = "3";
 
     EXPECT_EQ(1, handler2.GetInvalidationCount());
-    EXPECT_THAT(
-        expected_states,
-        Eq(handler2.GetLastInvalidationIdStateMap()));
+    EXPECT_THAT(expected_states, Eq(handler2.GetLastInvalidationMap()));
     EXPECT_EQ(REMOTE_INVALIDATION, handler2.GetLastInvalidationSource());
 
     EXPECT_EQ(0, handler3.GetInvalidationCount());
@@ -327,7 +320,7 @@ TYPED_TEST_P(InvalidatorTest, EmptySetUnregisters) {
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
 
   {
-    ObjectIdStateMap states;
+    ObjectIdInvalidationMap states;
     states[this->id1].payload = "1";
     states[this->id2].payload = "2";
     states[this->id3].payload = "3";
diff --git a/sync/notifier/non_blocking_invalidator.cc b/sync/notifier/non_blocking_invalidator.cc
index 8b80a04..7472902 100644
--- a/sync/notifier/non_blocking_invalidator.cc
+++ b/sync/notifier/non_blocking_invalidator.cc
@@ -44,7 +44,7 @@ class NonBlockingInvalidator::Core
   // InvalidationNotifier).
   virtual void OnInvalidatorStateChange(InvalidatorState reason) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) OVERRIDE;
 
  private:
@@ -129,11 +129,12 @@ void NonBlockingInvalidator::Core::OnInvalidatorStateChange(
 }
 
 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);
 }
 
@@ -237,9 +238,9 @@ void NonBlockingInvalidator::UpdateCredentials(const std::string& email,
 }
 
 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.
 }
 
@@ -249,10 +250,10 @@ void NonBlockingInvalidator::OnInvalidatorStateChange(InvalidatorState 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
diff --git a/sync/notifier/non_blocking_invalidator.h b/sync/notifier/non_blocking_invalidator.h
index 30e245f..3cb4f26 100644
--- a/sync/notifier/non_blocking_invalidator.h
+++ b/sync/notifier/non_blocking_invalidator.h
@@ -55,12 +55,13 @@ class NonBlockingInvalidator
   virtual void SetStateDeprecated(const std::string& state) OVERRIDE;
   virtual void UpdateCredentials(
       const std::string& email, const std::string& token) OVERRIDE;
-  virtual void SendInvalidation(const ObjectIdStateMap& id_state_map) OVERRIDE;
+  virtual void SendInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
   // InvalidationHandler implementation.
   virtual void OnInvalidatorStateChange(InvalidatorState state) OVERRIDE;
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) OVERRIDE;
 
  private:
diff --git a/sync/notifier/non_blocking_invalidator_unittest.cc b/sync/notifier/non_blocking_invalidator_unittest.cc
index f865b4a..df8142a 100644
--- a/sync/notifier/non_blocking_invalidator_unittest.cc
+++ b/sync/notifier/non_blocking_invalidator_unittest.cc
@@ -16,7 +16,7 @@
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidator_test_template.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -80,9 +80,10 @@ class NonBlockingInvalidatorTestDelegate {
     invalidator_->OnInvalidatorStateChange(state);
   }
 
-  void TriggerOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-                                     IncomingInvalidationSource source) {
-    invalidator_->OnIncomingInvalidation(id_state_map, source);
+  void TriggerOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source) {
+    invalidator_->OnIncomingInvalidation(invalidation_map, source);
   }
 
   static bool InvalidatorHandlesDeprecatedState() {
diff --git a/sync/notifier/object_id_invalidation_map.cc b/sync/notifier/object_id_invalidation_map.cc
new file mode 100644
index 0000000..5fa253e
--- /dev/null
+++ b/sync/notifier/object_id_invalidation_map.cc
@@ -0,0 +1,123 @@
+// 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/object_id_invalidation_map.h"
+
+#include <algorithm>
+
+#include "base/compiler_specific.h"
+#include "base/values.h"
+
+namespace syncer {
+
+ObjectIdSet ObjectIdInvalidationMapToSet(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  ObjectIdSet ids;
+  for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
+    ids.insert(it->first);
+  }
+  return ids;
+}
+
+ObjectIdInvalidationMap ObjectIdSetToInvalidationMap(
+    const ObjectIdSet& ids, const std::string& payload) {
+  ObjectIdInvalidationMap invalidation_map;
+  for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
+    // TODO(dcheng): Do we need to provide a way to set AckHandle?
+    invalidation_map[*it].payload = payload;
+  }
+  return invalidation_map;
+}
+
+namespace {
+
+struct ObjectIdInvalidationMapValueEquals {
+  bool operator()(const ObjectIdInvalidationMap::value_type& value1,
+                  const ObjectIdInvalidationMap::value_type& value2) const {
+    return
+        (value1.first == value2.first) &&
+        value1.second.Equals(value2.second);
+  }
+};
+
+}  // namespace
+
+bool ObjectIdInvalidationMapEquals(
+    const ObjectIdInvalidationMap& invalidation_map1,
+    const ObjectIdInvalidationMap& invalidation_map2) {
+  return
+      (invalidation_map1.size() == invalidation_map2.size()) &&
+      std::equal(invalidation_map1.begin(), invalidation_map1.end(),
+                 invalidation_map2.begin(),
+                 ObjectIdInvalidationMapValueEquals());
+}
+
+scoped_ptr<base::ListValue> ObjectIdInvalidationMapToValue(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  scoped_ptr<ListValue> value(new ListValue());
+  for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
+    DictionaryValue* entry = new DictionaryValue();
+    entry->Set("objectId", ObjectIdToValue(it->first).release());
+    entry->Set("state", it->second.ToValue().release());
+    value->Append(entry);
+  }
+  return value.Pass();
+}
+
+bool ObjectIdInvalidationMapFromValue(const base::ListValue& value,
+                               ObjectIdInvalidationMap* out) {
+  out->clear();
+  for (base::ListValue::const_iterator it = value.begin();
+       it != value.end(); ++it) {
+    const base::DictionaryValue* entry = NULL;
+    const base::DictionaryValue* id_value = NULL;
+    const base::DictionaryValue* invalidation_value = NULL;
+    invalidation::ObjectId id;
+    Invalidation invalidation;
+    if (!(*it)->GetAsDictionary(&entry) ||
+        !entry->GetDictionary("objectId", &id_value) ||
+        !entry->GetDictionary("state", &invalidation_value) ||
+        !ObjectIdFromValue(*id_value, &id) ||
+        !invalidation.ResetFromValue(*invalidation_value)) {
+      return false;
+    }
+    ignore_result(out->insert(std::make_pair(id, invalidation)));
+  }
+  return true;
+}
+
+ModelTypeInvalidationMap ObjectIdInvalidationMapToModelTypeInvalidationMap(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  ModelTypeInvalidationMap type_invalidation_map;
+  for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
+    ModelType model_type;
+    if (!ObjectIdToRealModelType(it->first, &model_type)) {
+      DLOG(WARNING) << "Invalid object ID: "
+                    << ObjectIdToString(it->first);
+      continue;
+    }
+    type_invalidation_map[model_type] = it->second;
+  }
+  return type_invalidation_map;
+}
+
+ObjectIdInvalidationMap ModelTypeInvalidationMapToObjectIdInvalidationMap(
+    const ModelTypeInvalidationMap& invalidation_map) {
+  ObjectIdInvalidationMap id_invalidation_map;
+  for (ModelTypeInvalidationMap::const_iterator it = invalidation_map.begin();
+       it != invalidation_map.end(); ++it) {
+    invalidation::ObjectId id;
+    if (!RealModelTypeToObjectId(it->first, &id)) {
+      DLOG(WARNING) << "Invalid model type " << it->first;
+      continue;
+    }
+    id_invalidation_map[id] = it->second;
+  }
+  return id_invalidation_map;
+}
+
+}  // namespace syncer
diff --git a/sync/notifier/object_id_invalidation_map.h b/sync/notifier/object_id_invalidation_map.h
new file mode 100644
index 0000000..03569d8
--- /dev/null
+++ b/sync/notifier/object_id_invalidation_map.h
@@ -0,0 +1,51 @@
+// 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.
+
+#ifndef SYNC_NOTIFIER_OBJECT_ID_INVALIDATION_MAP_H_
+#define SYNC_NOTIFIER_OBJECT_ID_INVALIDATION_MAP_H_
+
+#include <map>
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "google/cacheinvalidation/include/types.h"
+#include "sync/internal_api/public/base/invalidation.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
+#include "sync/notifier/invalidation_util.h"
+
+namespace base {
+class ListValue;
+}  // namespace base
+
+namespace syncer {
+
+typedef std::map<invalidation::ObjectId,
+                 Invalidation,
+                 ObjectIdLessThan> ObjectIdInvalidationMap;
+
+// Converts between ObjectIdInvalidationMaps and ObjectIdSets.
+ObjectIdSet ObjectIdInvalidationMapToSet(
+    const ObjectIdInvalidationMap& invalidation_map);
+ObjectIdInvalidationMap ObjectIdSetToInvalidationMap(
+    const ObjectIdSet& ids, const std::string& payload);
+
+bool ObjectIdInvalidationMapEquals(
+    const ObjectIdInvalidationMap& invalidation_map1,
+    const ObjectIdInvalidationMap& invalidation_map2);
+
+scoped_ptr<base::ListValue> ObjectIdInvalidationMapToValue(
+    const ObjectIdInvalidationMap& invalidation_map);
+
+bool ObjectIdInvalidationMapFromValue(const base::ListValue& value,
+                               ObjectIdInvalidationMap* out);
+
+// Converts between ObjectIdInvalidationMaps and ModelTypeInvalidationMaps.
+ModelTypeInvalidationMap ObjectIdInvalidationMapToModelTypeInvalidationMap(
+    const ObjectIdInvalidationMap& invalidation_map);
+ObjectIdInvalidationMap ModelTypeInvalidationMapToObjectIdInvalidationMap(
+    const ModelTypeInvalidationMap& invalidation_map);
+
+}  // namespace syncer
+
+#endif  // HOME_DCHENG_SRC_CHROMIUM_SRC_SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_H_
diff --git a/sync/notifier/object_id_state_map_test_util.cc b/sync/notifier/object_id_invalidation_map_test_util.cc
index 58659af..f2f8285 100644
--- a/sync/notifier/object_id_state_map_test_util.cc
+++ b/sync/notifier/object_id_invalidation_map_test_util.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 
 #include <algorithm>
 
@@ -18,32 +18,34 @@ using ::testing::PrintToString;
 
 namespace {
 
-class ObjectIdStateMapEqMatcher
-    : public MatcherInterface<const ObjectIdStateMap&> {
+class ObjectIdInvalidationMapEqMatcher
+    : public MatcherInterface<const ObjectIdInvalidationMap&> {
  public:
-  explicit ObjectIdStateMapEqMatcher(const ObjectIdStateMap& expected);
+  explicit ObjectIdInvalidationMapEqMatcher(
+      const ObjectIdInvalidationMap& expected);
 
-  virtual bool MatchAndExplain(const ObjectIdStateMap& actual,
+  virtual bool MatchAndExplain(const ObjectIdInvalidationMap& actual,
                                MatchResultListener* listener) const;
   virtual void DescribeTo(::std::ostream* os) const;
   virtual void DescribeNegationTo(::std::ostream* os) const;
 
  private:
-  const ObjectIdStateMap expected_;
+  const ObjectIdInvalidationMap expected_;
 
-  DISALLOW_COPY_AND_ASSIGN(ObjectIdStateMapEqMatcher);
+  DISALLOW_COPY_AND_ASSIGN(ObjectIdInvalidationMapEqMatcher);
 };
 
-ObjectIdStateMapEqMatcher::ObjectIdStateMapEqMatcher(
-    const ObjectIdStateMap& expected) : expected_(expected) {
+ObjectIdInvalidationMapEqMatcher::ObjectIdInvalidationMapEqMatcher(
+    const ObjectIdInvalidationMap& expected) : expected_(expected) {
 }
 
-bool ObjectIdStateMapEqMatcher::MatchAndExplain(
-    const ObjectIdStateMap& actual, MatchResultListener* listener) const {
-  ObjectIdStateMap expected_only;
-  ObjectIdStateMap actual_only;
+bool ObjectIdInvalidationMapEqMatcher::MatchAndExplain(
+    const ObjectIdInvalidationMap& actual,
+    MatchResultListener* listener) const {
+  ObjectIdInvalidationMap expected_only;
+  ObjectIdInvalidationMap actual_only;
   typedef std::pair<invalidation::ObjectId,
-                    std::pair<InvalidationState, InvalidationState> >
+                    std::pair<Invalidation, Invalidation> >
       ValueDifference;
   std::vector<ValueDifference> value_differences;
 
@@ -56,9 +58,9 @@ bool ObjectIdStateMapEqMatcher::MatchAndExplain(
                       std::inserter(actual_only, actual_only.begin()),
                       actual.value_comp());
 
-  for (ObjectIdStateMap::const_iterator it = expected_.begin();
+  for (ObjectIdInvalidationMap::const_iterator it = expected_.begin();
        it != expected_.end(); ++it) {
-    ObjectIdStateMap::const_iterator find_it =
+    ObjectIdInvalidationMap::const_iterator find_it =
         actual.find(it->first);
     if (find_it != actual.end() &&
         !Matches(Eq(it->second))(find_it->second)) {
@@ -93,18 +95,20 @@ bool ObjectIdStateMapEqMatcher::MatchAndExplain(
   return false;
 }
 
-void ObjectIdStateMapEqMatcher::DescribeTo(::std::ostream* os) const {
+void ObjectIdInvalidationMapEqMatcher::DescribeTo(::std::ostream* os) const {
   *os << " is equal to " << PrintToString(expected_);
 }
 
-void ObjectIdStateMapEqMatcher::DescribeNegationTo(::std::ostream* os) const {
+void ObjectIdInvalidationMapEqMatcher::DescribeNegationTo
+(::std::ostream* os) const {
   *os << " isn't equal to " << PrintToString(expected_);
 }
 
 }  // namespace
 
-Matcher<const ObjectIdStateMap&> Eq(const ObjectIdStateMap& expected) {
-  return MakeMatcher(new ObjectIdStateMapEqMatcher(expected));
+Matcher<const ObjectIdInvalidationMap&> Eq(
+    const ObjectIdInvalidationMap& expected) {
+  return MakeMatcher(new ObjectIdInvalidationMapEqMatcher(expected));
 }
 
 }  // namespace syncer
diff --git a/sync/notifier/object_id_invalidation_map_test_util.h b/sync/notifier/object_id_invalidation_map_test_util.h
new file mode 100644
index 0000000..47d03e9
--- /dev/null
+++ b/sync/notifier/object_id_invalidation_map_test_util.h
@@ -0,0 +1,20 @@
+// 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.
+
+#ifndef SYNC_NOTIFIER_OBJECT_ID_INVALIDATION_MAP_TEST_UTILH_
+#define SYNC_NOTIFIER_OBJECT_ID_INVALIDATION_MAP_TEST_UTILH_
+
+// Convince googletest to use the correct overload for PrintTo().
+#include "sync/internal_api/public/base/invalidation_test_util.h"
+#include "sync/notifier/object_id_invalidation_map.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace syncer {
+
+::testing::Matcher<const ObjectIdInvalidationMap&> Eq(
+    const ObjectIdInvalidationMap& expected);
+
+}  // namespace syncer
+
+#endif  // SYNC_NOTIFIER_OBJECT_ID_INVALIDATION_MAP_TEST_UTILH_
diff --git a/sync/notifier/object_id_state_map.cc b/sync/notifier/object_id_state_map.cc
deleted file mode 100644
index c673ed8..0000000
--- a/sync/notifier/object_id_state_map.cc
+++ /dev/null
@@ -1,120 +0,0 @@
-// 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/object_id_state_map.h"
-
-#include <algorithm>
-
-#include "base/compiler_specific.h"
-#include "base/values.h"
-
-namespace syncer {
-
-ObjectIdSet ObjectIdStateMapToSet(const ObjectIdStateMap& id_state_map) {
-  ObjectIdSet ids;
-  for (ObjectIdStateMap::const_iterator it = id_state_map.begin();
-       it != id_state_map.end(); ++it) {
-    ids.insert(it->first);
-  }
-  return ids;
-}
-
-ObjectIdStateMap ObjectIdSetToStateMap(const ObjectIdSet& ids,
-                                       const std::string& payload) {
-  ObjectIdStateMap id_state_map;
-  for (ObjectIdSet::const_iterator it = ids.begin(); it != ids.end(); ++it) {
-    // TODO(dcheng): Do we need to provide a way to set AckHandle?
-    id_state_map[*it].payload = payload;
-  }
-  return id_state_map;
-}
-
-namespace {
-
-struct ObjectIdStateMapValueEquals {
-  bool operator()(const ObjectIdStateMap::value_type& value1,
-                  const ObjectIdStateMap::value_type& value2) const {
-    return
-        (value1.first == value2.first) &&
-        value1.second.Equals(value2.second);
-  }
-};
-
-}  // namespace
-
-bool ObjectIdStateMapEquals(const ObjectIdStateMap& id_state_map1,
-                            const ObjectIdStateMap& id_state_map2) {
-  return
-      (id_state_map1.size() == id_state_map2.size()) &&
-      std::equal(id_state_map1.begin(), id_state_map1.end(),
-                 id_state_map2.begin(), ObjectIdStateMapValueEquals());
-}
-
-scoped_ptr<base::ListValue> ObjectIdStateMapToValue(
-    const ObjectIdStateMap& id_state_map) {
-  scoped_ptr<ListValue> value(new ListValue());
-  for (ObjectIdStateMap::const_iterator it = id_state_map.begin();
-       it != id_state_map.end(); ++it) {
-    DictionaryValue* entry = new DictionaryValue();
-    entry->Set("objectId", ObjectIdToValue(it->first).release());
-    entry->Set("state", it->second.ToValue().release());
-    value->Append(entry);
-  }
-  return value.Pass();
-}
-
-bool ObjectIdStateMapFromValue(const base::ListValue& value,
-                               ObjectIdStateMap* out) {
-  out->clear();
-  for (base::ListValue::const_iterator it = value.begin();
-       it != value.end(); ++it) {
-    const base::DictionaryValue* entry = NULL;
-    const base::DictionaryValue* id_value = NULL;
-    const base::DictionaryValue* state_value = NULL;
-    invalidation::ObjectId id;
-    InvalidationState state;
-    if (!(*it)->GetAsDictionary(&entry) ||
-        !entry->GetDictionary("objectId", &id_value) ||
-        !entry->GetDictionary("state", &state_value) ||
-        !ObjectIdFromValue(*id_value, &id) ||
-        !state.ResetFromValue(*state_value)) {
-      return false;
-    }
-    ignore_result(out->insert(std::make_pair(id, state)));
-  }
-  return true;
-}
-
-ModelTypeStateMap ObjectIdStateMapToModelTypeStateMap(
-    const ObjectIdStateMap& id_state_map) {
-  ModelTypeStateMap type_state_map;
-  for (ObjectIdStateMap::const_iterator it = id_state_map.begin();
-       it != id_state_map.end(); ++it) {
-    ModelType model_type;
-    if (!ObjectIdToRealModelType(it->first, &model_type)) {
-      DLOG(WARNING) << "Invalid object ID: "
-                    << ObjectIdToString(it->first);
-      continue;
-    }
-    type_state_map[model_type] = it->second;
-  }
-  return type_state_map;
-}
-
-ObjectIdStateMap ModelTypeStateMapToObjectIdStateMap(
-    const ModelTypeStateMap& type_state_map) {
-  ObjectIdStateMap id_state_map;
-  for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
-       it != type_state_map.end(); ++it) {
-    invalidation::ObjectId id;
-    if (!RealModelTypeToObjectId(it->first, &id)) {
-      DLOG(WARNING) << "Invalid model type " << it->first;
-      continue;
-    }
-    id_state_map[id] = it->second;
-  }
-  return id_state_map;
-}
-
-}  // namespace syncer
diff --git a/sync/notifier/object_id_state_map.h b/sync/notifier/object_id_state_map.h
deleted file mode 100644
index 1e9513e..0000000
--- a/sync/notifier/object_id_state_map.h
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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.
-
-#ifndef SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_H_
-#define SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_H_
-
-#include <map>
-#include <string>
-
-#include "base/memory/scoped_ptr.h"
-#include "google/cacheinvalidation/include/types.h"
-#include "sync/internal_api/public/base/invalidation_state.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
-#include "sync/notifier/invalidation_util.h"
-
-namespace base {
-class ListValue;
-}  // namespace base
-
-namespace syncer {
-
-typedef std::map<invalidation::ObjectId,
-                 InvalidationState,
-                 ObjectIdLessThan> ObjectIdStateMap;
-
-// Converts between ObjectIdStateMaps and ObjectIdSets.
-ObjectIdSet ObjectIdStateMapToSet(const ObjectIdStateMap& id_payloads);
-ObjectIdStateMap ObjectIdSetToStateMap(const ObjectIdSet& ids,
-                                       const std::string& payload);
-
-bool ObjectIdStateMapEquals(const ObjectIdStateMap& id_state_map1,
-                            const ObjectIdStateMap& id_state_map2);
-
-scoped_ptr<base::ListValue> ObjectIdStateMapToValue(
-    const ObjectIdStateMap& model_type_payloads);
-
-bool ObjectIdStateMapFromValue(const base::ListValue& value,
-                               ObjectIdStateMap* out);
-
-// Converts between ObjectIdStateMaps and ModelTypeStateMaps.
-ModelTypeStateMap ObjectIdStateMapToModelTypeStateMap(
-    const ObjectIdStateMap& id_payloads);
-ObjectIdStateMap ModelTypeStateMapToObjectIdStateMap(
-    const ModelTypeStateMap& type_payloads);
-
-}  // namespace syncer
-
-#endif  // HOME_DCHENG_SRC_CHROMIUM_SRC_SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_H_
diff --git a/sync/notifier/object_id_state_map_test_util.h b/sync/notifier/object_id_state_map_test_util.h
deleted file mode 100644
index 7b26b93..0000000
--- a/sync/notifier/object_id_state_map_test_util.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// 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.
-
-#ifndef SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_TEST_UTILH_
-#define SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_TEST_UTILH_
-
-// Convince googletest to use the correct overload for PrintTo().
-#include "sync/internal_api/public/base/invalidation_state_test_util.h"
-#include "sync/notifier/object_id_state_map.h"
-#include "testing/gmock/include/gmock/gmock.h"
-
-namespace syncer {
-
-::testing::Matcher<const ObjectIdStateMap&> Eq(
-    const ObjectIdStateMap& expected);
-
-}  // namespace syncer
-
-#endif  // SYNC_NOTIFIER_OBJECT_ID_STATE_MAP_TEST_UTILH_
diff --git a/sync/notifier/p2p_invalidator.cc b/sync/notifier/p2p_invalidator.cc
index e5d3b98..adf6010 100644
--- a/sync/notifier/p2p_invalidator.cc
+++ b/sync/notifier/p2p_invalidator.cc
@@ -11,7 +11,6 @@
 #include "base/logging.h"
 #include "base/values.h"
 #include "jingle/notifier/listener/push_client.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
 #include "sync/notifier/invalidation_handler.h"
 #include "sync/notifier/invalidation_util.h"
 
@@ -27,7 +26,7 @@ const char kNotifyAll[] = "notifyAll";
 
 const char kSenderIdKey[] = "senderId";
 const char kNotificationTypeKey[] = "notificationType";
-const char kIdStateMapKey[] = "idStateMap";
+const char kIdInvalidationMapKey[] = "idInvalidationMap";
 const char kSourceKey[] = "source";
 
 }  // namespace
@@ -74,11 +73,11 @@ P2PNotificationData::P2PNotificationData()
 P2PNotificationData::P2PNotificationData(
     const std::string& sender_id,
     P2PNotificationTarget target,
-    const ObjectIdStateMap& id_state_map,
+    const ObjectIdInvalidationMap& invalidation_map,
     IncomingInvalidationSource source)
     : sender_id_(sender_id),
       target_(target),
-      id_state_map_(id_state_map),
+      invalidation_map_(invalidation_map),
       source_(source) {}
 
 P2PNotificationData::~P2PNotificationData() {}
@@ -97,8 +96,9 @@ bool P2PNotificationData::IsTargeted(const std::string& id) const {
   }
 }
 
-const ObjectIdStateMap& P2PNotificationData::GetIdStateMap() const {
-  return id_state_map_;
+const ObjectIdInvalidationMap&
+P2PNotificationData::GetIdInvalidationMap() const {
+  return invalidation_map_;
 }
 
 IncomingInvalidationSource P2PNotificationData::GetSource() const {
@@ -109,7 +109,8 @@ bool P2PNotificationData::Equals(const P2PNotificationData& other) const {
   return
       (sender_id_ == other.sender_id_) &&
       (target_ == other.target_) &&
-      ObjectIdStateMapEquals(id_state_map_, other.id_state_map_) &&
+      ObjectIdInvalidationMapEquals(invalidation_map_,
+                                    other.invalidation_map_) &&
       (source_ == other.source_);
 }
 
@@ -118,7 +119,8 @@ std::string P2PNotificationData::ToString() const {
   dict->SetString(kSenderIdKey, sender_id_);
   dict->SetString(kNotificationTypeKey,
                   P2PNotificationTargetToString(target_));
-  dict->Set(kIdStateMapKey, ObjectIdStateMapToValue(id_state_map_).release());
+  dict->Set(kIdInvalidationMapKey,
+            ObjectIdInvalidationMapToValue(invalidation_map_).release());
   dict->SetInteger(kSourceKey, source_);
   std::string json;
   base::JSONWriter::Write(dict.get(), &json);
@@ -141,10 +143,11 @@ bool P2PNotificationData::ResetFromString(const std::string& str) {
                  << kNotificationTypeKey;
   }
   target_ = P2PNotificationTargetFromString(target_str);
-  const base::ListValue* id_state_map_list = NULL;
-  if (!data_dict->GetList(kIdStateMapKey, &id_state_map_list) ||
-      !ObjectIdStateMapFromValue(*id_state_map_list, &id_state_map_)) {
-    LOG(WARNING) << "Could not parse " << kIdStateMapKey;
+  const base::ListValue* invalidation_map_list = NULL;
+  if (!data_dict->GetList(kIdInvalidationMapKey, &invalidation_map_list) ||
+      !ObjectIdInvalidationMapFromValue(*invalidation_map_list,
+                                        &invalidation_map_)) {
+    LOG(WARNING) << "Could not parse " << kIdInvalidationMapKey;
   }
   int source_num = 0;
   if (!data_dict->GetInteger(kSourceKey, &source_num)) {
@@ -187,7 +190,7 @@ void P2PInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
                       ObjectIdLessThan());
   registrar_.UpdateRegisteredIds(handler, ids);
   const P2PNotificationData notification_data(
-      unique_id_, NOTIFY_SELF, ObjectIdSetToStateMap(new_ids, ""),
+      unique_id_, NOTIFY_SELF, ObjectIdSetToInvalidationMap(new_ids, ""),
       REMOTE_INVALIDATION);
   SendNotificationData(notification_data);
 }
@@ -229,10 +232,11 @@ void P2PInvalidator::UpdateCredentials(
   logged_in_ = true;
 }
 
-void P2PInvalidator::SendInvalidation(const ObjectIdStateMap& id_state_map) {
+void P2PInvalidator::SendInvalidation(
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const P2PNotificationData notification_data(
-      unique_id_, send_notification_target_, id_state_map,
+      unique_id_, send_notification_target_, invalidation_map,
       REMOTE_INVALIDATION);
   SendNotificationData(notification_data);
 }
@@ -245,7 +249,7 @@ void P2PInvalidator::OnNotificationsEnabled() {
   if (just_turned_on) {
     const P2PNotificationData notification_data(
         unique_id_, NOTIFY_SELF,
-        ObjectIdSetToStateMap(registrar_.GetAllRegisteredIds(), ""),
+        ObjectIdSetToInvalidationMap(registrar_.GetAllRegisteredIds(), ""),
         REMOTE_INVALIDATION);
     SendNotificationData(notification_data);
   }
@@ -280,7 +284,7 @@ void P2PInvalidator::OnIncomingNotification(
     notification_data =
         P2PNotificationData(
             unique_id_, NOTIFY_ALL,
-            ObjectIdSetToStateMap(registrar_.GetAllRegisteredIds(), ""),
+            ObjectIdSetToInvalidationMap(registrar_.GetAllRegisteredIds(), ""),
             REMOTE_INVALIDATION);
   }
   if (!notification_data.IsTargeted(unique_id_)) {
@@ -289,7 +293,7 @@ void P2PInvalidator::OnIncomingNotification(
     return;
   }
   registrar_.DispatchInvalidationsToHandlers(
-      notification_data.GetIdStateMap(),
+      notification_data.GetIdInvalidationMap(),
       REMOTE_INVALIDATION);
 }
 
@@ -302,7 +306,7 @@ void P2PInvalidator::SendNotificationDataForTest(
 void P2PInvalidator::SendNotificationData(
     const P2PNotificationData& notification_data) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (notification_data.GetIdStateMap().empty()) {
+  if (notification_data.GetIdInvalidationMap().empty()) {
     DVLOG(1) << "Not sending XMPP notification with empty state map: "
              << notification_data.ToString();
     return;
diff --git a/sync/notifier/p2p_invalidator.h b/sync/notifier/p2p_invalidator.h
index dd462ef..bbcbcf5 100644
--- a/sync/notifier/p2p_invalidator.h
+++ b/sync/notifier/p2p_invalidator.h
@@ -56,7 +56,7 @@ class P2PNotificationData {
   P2PNotificationData();
   P2PNotificationData(const std::string& sender_id,
                       P2PNotificationTarget target,
-                      const ObjectIdStateMap& id_state_map,
+                      const ObjectIdInvalidationMap& invalidation_map,
                       IncomingInvalidationSource source);
 
   ~P2PNotificationData();
@@ -64,7 +64,7 @@ class P2PNotificationData {
   // Returns true if the given ID is targeted by this notification.
   bool IsTargeted(const std::string& id) const;
 
-  const ObjectIdStateMap& GetIdStateMap() const;
+  const ObjectIdInvalidationMap& GetIdInvalidationMap() const;
 
   IncomingInvalidationSource GetSource() const;
 
@@ -81,8 +81,8 @@ class P2PNotificationData {
   std::string sender_id_;
   // The intendent recipient(s) of the notification.
   P2PNotificationTarget target_;
-  // The state map for the notification.
-  ObjectIdStateMap id_state_map_;
+  // The invalidation map for the notification.
+  ObjectIdInvalidationMap invalidation_map_;
   // The source of the invalidation.
   IncomingInvalidationSource source_;
 };
@@ -110,7 +110,8 @@ class P2PInvalidator : public Invalidator,
   virtual void SetStateDeprecated(const std::string& state) OVERRIDE;
   virtual void UpdateCredentials(
       const std::string& email, const std::string& token) OVERRIDE;
-  virtual void SendInvalidation(const ObjectIdStateMap& id_state_map) OVERRIDE;
+  virtual void SendInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE;
 
   // PushClientObserver implementation.
   virtual void OnNotificationsEnabled() OVERRIDE;
diff --git a/sync/notifier/p2p_invalidator_unittest.cc b/sync/notifier/p2p_invalidator_unittest.cc
index 82e81fe..6be2c21 100644
--- a/sync/notifier/p2p_invalidator_unittest.cc
+++ b/sync/notifier/p2p_invalidator_unittest.cc
@@ -8,10 +8,10 @@
 
 #include "jingle/notifier/listener/fake_push_client.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/invalidator_test_template.h"
-#include "sync/notifier/object_id_state_map_test_util.h"
+#include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -64,10 +64,11 @@ class P2PInvalidatorTestDelegate {
     }
   }
 
-  void TriggerOnIncomingInvalidation(const ObjectIdStateMap& id_state_map,
-                                     IncomingInvalidationSource source) {
+  void TriggerOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map,
+      IncomingInvalidationSource source) {
     const P2PNotificationData notification_data(
-        "", NOTIFY_ALL, id_state_map, source);
+        "", NOTIFY_ALL, invalidation_map, source);
     notifier::Notification notification;
     notification.channel = kSyncP2PNotificationChannel;
     notification.data = notification_data.ToString();
@@ -97,8 +98,8 @@ class P2PInvalidatorTest : public testing::Test {
     delegate_.GetInvalidator()->UnregisterHandler(&fake_handler_);
   }
 
-  ModelTypeStateMap MakeStateMap(ModelTypeSet types) {
-    return ModelTypeSetToStateMap(types, std::string());
+  ModelTypeInvalidationMap MakeInvalidationMap(ModelTypeSet types) {
+    return ModelTypeSetToInvalidationMap(types, std::string());
   }
 
   // Simulate receiving all the notifications we sent out since last
@@ -136,21 +137,22 @@ TEST_F(P2PInvalidatorTest, P2PNotificationTarget) {
 TEST_F(P2PInvalidatorTest, P2PNotificationDataIsTargeted) {
   {
     const P2PNotificationData notification_data(
-        "sender", NOTIFY_SELF, ObjectIdStateMap(), REMOTE_INVALIDATION);
+        "sender", NOTIFY_SELF, ObjectIdInvalidationMap(), REMOTE_INVALIDATION);
     EXPECT_TRUE(notification_data.IsTargeted("sender"));
     EXPECT_FALSE(notification_data.IsTargeted("other1"));
     EXPECT_FALSE(notification_data.IsTargeted("other2"));
   }
   {
     const P2PNotificationData notification_data(
-        "sender", NOTIFY_OTHERS, ObjectIdStateMap(), REMOTE_INVALIDATION);
+        "sender", NOTIFY_OTHERS, ObjectIdInvalidationMap(),
+        REMOTE_INVALIDATION);
     EXPECT_FALSE(notification_data.IsTargeted("sender"));
     EXPECT_TRUE(notification_data.IsTargeted("other1"));
     EXPECT_TRUE(notification_data.IsTargeted("other2"));
   }
   {
     const P2PNotificationData notification_data(
-        "sender", NOTIFY_ALL, ObjectIdStateMap(), REMOTE_INVALIDATION);
+        "sender", NOTIFY_ALL, ObjectIdInvalidationMap(), REMOTE_INVALIDATION);
     EXPECT_TRUE(notification_data.IsTargeted("sender"));
     EXPECT_TRUE(notification_data.IsTargeted("other1"));
     EXPECT_TRUE(notification_data.IsTargeted("other2"));
@@ -164,11 +166,11 @@ TEST_F(P2PInvalidatorTest, P2PNotificationDataDefault) {
   EXPECT_TRUE(notification_data.IsTargeted(""));
   EXPECT_FALSE(notification_data.IsTargeted("other1"));
   EXPECT_FALSE(notification_data.IsTargeted("other2"));
-  EXPECT_TRUE(notification_data.GetIdStateMap().empty());
+  EXPECT_TRUE(notification_data.GetIdInvalidationMap().empty());
   const std::string& notification_data_str = notification_data.ToString();
   EXPECT_EQ(
-      "{\"idStateMap\":[],\"notificationType\":\"notifySelf\",\"senderId\":"
-      "\"\",\"source\":0}", notification_data_str);
+      "{\"idInvalidationMap\":[],\"notificationType\":\"notifySelf\","
+      "\"senderId\":\"\",\"source\":0}", notification_data_str);
 
   P2PNotificationData notification_data_parsed;
   EXPECT_TRUE(notification_data_parsed.ResetFromString(notification_data_str));
@@ -178,18 +180,19 @@ TEST_F(P2PInvalidatorTest, P2PNotificationDataDefault) {
 // Make sure the P2PNotificationData <-> string conversions work for a
 // non-default-constructed P2PNotificationData.
 TEST_F(P2PInvalidatorTest, P2PNotificationDataNonDefault) {
-  const ObjectIdStateMap& id_state_map =
-      ObjectIdSetToStateMap(
+  const ObjectIdInvalidationMap& invalidation_map =
+      ObjectIdSetToInvalidationMap(
           ModelTypeSetToObjectIdSet(ModelTypeSet(BOOKMARKS, THEMES)), "");
   const P2PNotificationData notification_data(
-      "sender", NOTIFY_ALL, id_state_map, LOCAL_INVALIDATION);
+      "sender", NOTIFY_ALL, invalidation_map, LOCAL_INVALIDATION);
   EXPECT_TRUE(notification_data.IsTargeted("sender"));
   EXPECT_TRUE(notification_data.IsTargeted("other1"));
   EXPECT_TRUE(notification_data.IsTargeted("other2"));
-  EXPECT_THAT(id_state_map, Eq(notification_data.GetIdStateMap()));
+  EXPECT_THAT(invalidation_map,
+              Eq(notification_data.GetIdInvalidationMap()));
   const std::string& notification_data_str = notification_data.ToString();
   EXPECT_EQ(
-      "{\"idStateMap\":["
+      "{\"idInvalidationMap\":["
       "{\"objectId\":{\"name\":\"BOOKMARK\",\"source\":1004},"
       "\"state\":{\"ackHandle\":{},\"payload\":\"\"}},"
       "{\"objectId\":{\"name\":\"THEME\",\"source\":1004},"
@@ -238,17 +241,18 @@ TEST_F(P2PInvalidatorTest, NotificationsBasic) {
   ReflectSentNotifications();
   EXPECT_EQ(1, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(
-      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(enabled_types)),
-      Eq(fake_handler_.GetLastInvalidationIdStateMap()));
+      ModelTypeInvalidationMapToObjectIdInvalidationMap(
+          MakeInvalidationMap(enabled_types)),
+      Eq(fake_handler_.GetLastInvalidationMap()));
   EXPECT_EQ(REMOTE_INVALIDATION, fake_handler_.GetLastInvalidationSource());
 
   // Sent with target NOTIFY_OTHERS so should not be propagated to
   // |fake_handler_|.
   {
-    const ObjectIdStateMap& id_state_map =
-        ObjectIdSetToStateMap(
+    const ObjectIdInvalidationMap& invalidation_map =
+        ObjectIdSetToInvalidationMap(
             ModelTypeSetToObjectIdSet(ModelTypeSet(THEMES, APPS)), "");
-    invalidator->SendInvalidation(id_state_map);
+    invalidator->SendInvalidation(invalidation_map);
   }
 
   ReflectSentNotifications();
@@ -263,8 +267,8 @@ TEST_F(P2PInvalidatorTest, SendNotificationData) {
   const ModelTypeSet changed_types(THEMES, APPS);
   const ModelTypeSet expected_types(THEMES);
 
-  const ObjectIdStateMap& id_state_map =
-      ObjectIdSetToStateMap(
+  const ObjectIdInvalidationMap& invalidation_map =
+      ObjectIdSetToInvalidationMap(
           ModelTypeSetToObjectIdSet(changed_types), "");
 
   P2PInvalidator* const invalidator = delegate_.GetInvalidator();
@@ -283,8 +287,9 @@ TEST_F(P2PInvalidatorTest, SendNotificationData) {
   ReflectSentNotifications();
   EXPECT_EQ(1, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(
-      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(enabled_types)),
-      Eq(fake_handler_.GetLastInvalidationIdStateMap()));
+      ModelTypeInvalidationMapToObjectIdInvalidationMap(
+          MakeInvalidationMap(enabled_types)),
+      Eq(fake_handler_.GetLastInvalidationMap()));
   EXPECT_EQ(REMOTE_INVALIDATION, fake_handler_.GetLastInvalidationSource());
 
   // Should be dropped.
@@ -292,81 +297,74 @@ TEST_F(P2PInvalidatorTest, SendNotificationData) {
   ReflectSentNotifications();
   EXPECT_EQ(1, fake_handler_.GetInvalidationCount());
 
-  const ObjectIdStateMap& expected_ids =
-      ModelTypeStateMapToObjectIdStateMap(MakeStateMap(expected_types));
+  const ObjectIdInvalidationMap& expected_ids =
+      ModelTypeInvalidationMapToObjectIdInvalidationMap(
+          MakeInvalidationMap(expected_types));
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_SELF,
-                          id_state_map, REMOTE_INVALIDATION));
+                          invalidation_map, REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
-  EXPECT_THAT(
-      expected_ids,
-      Eq(fake_handler_.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_SELF,
-                          id_state_map, REMOTE_INVALIDATION));
+                          invalidation_map, REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_SELF,
-                          ObjectIdStateMap(), REMOTE_INVALIDATION));
+                          ObjectIdInvalidationMap(), REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_OTHERS,
-                          id_state_map, REMOTE_INVALIDATION));
+                          invalidation_map, REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(2, fake_handler_.GetInvalidationCount());
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_OTHERS,
-                          id_state_map, REMOTE_INVALIDATION));
+                          invalidation_map, REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(3, fake_handler_.GetInvalidationCount());
-  EXPECT_THAT(
-      expected_ids,
-      Eq(fake_handler_.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_OTHERS,
-                          ObjectIdStateMap(), REMOTE_INVALIDATION));
+                          ObjectIdInvalidationMap(), REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(3, fake_handler_.GetInvalidationCount());
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender", NOTIFY_ALL,
-                          id_state_map, REMOTE_INVALIDATION));
+                          invalidation_map, REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(4, fake_handler_.GetInvalidationCount());
-  EXPECT_THAT(
-      expected_ids,
-      Eq(fake_handler_.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be propagated.
   invalidator->SendNotificationDataForTest(
       P2PNotificationData("sender2", NOTIFY_ALL,
-                          id_state_map, REMOTE_INVALIDATION));
+                          invalidation_map, REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(5, fake_handler_.GetInvalidationCount());
-  EXPECT_THAT(
-      expected_ids,
-      Eq(fake_handler_.GetLastInvalidationIdStateMap()));
+  EXPECT_THAT(expected_ids, Eq(fake_handler_.GetLastInvalidationMap()));
 
   // Should be dropped.
   invalidator->SendNotificationDataForTest(
   P2PNotificationData("sender2", NOTIFY_ALL,
-                      ObjectIdStateMap(), REMOTE_INVALIDATION));
+                      ObjectIdInvalidationMap(), REMOTE_INVALIDATION));
   ReflectSentNotifications();
   EXPECT_EQ(5, fake_handler_.GetInvalidationCount());
 }
diff --git a/sync/notifier/sync_invalidation_listener.cc b/sync/notifier/sync_invalidation_listener.cc
index f879683..ab70527f6 100644
--- a/sync/notifier/sync_invalidation_listener.cc
+++ b/sync/notifier/sync_invalidation_listener.cc
@@ -162,9 +162,9 @@ void SyncInvalidationListener::Invalidate(
   if (invalidation.has_payload())
     payload = invalidation.payload();
 
-  ObjectIdStateMap id_state_map;
-  id_state_map[id].payload = payload;
-  EmitInvalidation(id_state_map);
+  ObjectIdInvalidationMap invalidation_map;
+  invalidation_map[id].payload = payload;
+  EmitInvalidation(invalidation_map);
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/78462).
   client->Acknowledge(ack_handle);
@@ -178,9 +178,9 @@ void SyncInvalidationListener::InvalidateUnknownVersion(
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateUnknownVersion";
 
-  ObjectIdStateMap id_state_map;
-  id_state_map[object_id].payload = std::string();
-  EmitInvalidation(id_state_map);
+  ObjectIdInvalidationMap invalidation_map;
+  invalidation_map[object_id].payload = std::string();
+  EmitInvalidation(invalidation_map);
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/78462).
   client->Acknowledge(ack_handle);
@@ -195,21 +195,18 @@ void SyncInvalidationListener::InvalidateAll(
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateAll";
 
-  ObjectIdStateMap id_state_map;
-  for (ObjectIdSet::const_iterator it = registered_ids_.begin();
-       it != registered_ids_.end(); ++it) {
-    id_state_map[*it].payload = std::string();
-  }
-  EmitInvalidation(id_state_map);
+  const ObjectIdInvalidationMap& invalidation_map =
+      ObjectIdSetToInvalidationMap(registered_ids_, std::string());
+  EmitInvalidation(invalidation_map);
   // TODO(akalin): We should really acknowledge only after we get the
   // updates from the sync server. (see http://crbug.com/76482).
   client->Acknowledge(ack_handle);
 }
 
 void SyncInvalidationListener::EmitInvalidation(
-    const ObjectIdStateMap& id_state_map) {
+    const ObjectIdInvalidationMap& invalidation_map) {
   DCHECK(CalledOnValidThread());
-  delegate_->OnInvalidate(id_state_map);
+  delegate_->OnInvalidate(invalidation_map);
 }
 
 void SyncInvalidationListener::InformRegistrationStatus(
diff --git a/sync/notifier/sync_invalidation_listener.h b/sync/notifier/sync_invalidation_listener.h
index 0a63bd6..d1fc079 100644
--- a/sync/notifier/sync_invalidation_listener.h
+++ b/sync/notifier/sync_invalidation_listener.h
@@ -21,7 +21,7 @@
 #include "sync/internal_api/public/util/weak_handle.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidator_state.h"
-#include "sync/notifier/object_id_state_map.h"
+#include "sync/notifier/object_id_invalidation_map.h"
 #include "sync/notifier/state_writer.h"
 #include "sync/notifier/sync_system_resources.h"
 
@@ -56,7 +56,8 @@ class SyncInvalidationListener
    public:
     virtual ~Delegate();
 
-    virtual void OnInvalidate(const ObjectIdStateMap& id_state_map) = 0;
+    virtual void OnInvalidate(
+        const ObjectIdInvalidationMap& invalidation_map) = 0;
 
     virtual void OnInvalidatorStateChange(InvalidatorState state) = 0;
   };
@@ -136,7 +137,7 @@ class SyncInvalidationListener
 
   void EmitStateChange();
 
-  void EmitInvalidation(const ObjectIdStateMap& id_state_map);
+  void EmitInvalidation(const ObjectIdInvalidationMap& invalidation_map);
 
   // Owned by |sync_system_resources_|.
   notifier::PushClient* const push_client_;
diff --git a/sync/notifier/sync_invalidation_listener_unittest.cc b/sync/notifier/sync_invalidation_listener_unittest.cc
index d17f988..a335060 100644
--- a/sync/notifier/sync_invalidation_listener_unittest.cc
+++ b/sync/notifier/sync_invalidation_listener_unittest.cc
@@ -140,8 +140,8 @@ class FakeDelegate : public SyncInvalidationListener::Delegate {
   }
 
   std::string GetPayload(const ObjectId& id) const {
-    ObjectIdStateMap::const_iterator it = states_.find(id);
-    return (it == states_.end()) ? "" : it->second.payload;
+    ObjectIdInvalidationMap::const_iterator it = invalidations_.find(id);
+    return (it == invalidations_.end()) ? "" : it->second.payload;
   }
 
   InvalidatorState GetInvalidatorState() const {
@@ -150,11 +150,12 @@ class FakeDelegate : public SyncInvalidationListener::Delegate {
 
   // SyncInvalidationListener::Delegate implementation.
 
-  virtual void OnInvalidate(const ObjectIdStateMap& id_state_map) OVERRIDE {
-    for (ObjectIdStateMap::const_iterator it = id_state_map.begin();
-         it != id_state_map.end(); ++it) {
+  virtual void OnInvalidate(
+      const ObjectIdInvalidationMap& invalidation_map) OVERRIDE {
+    for (ObjectIdInvalidationMap::const_iterator it = invalidation_map.begin();
+         it != invalidation_map.end(); ++it) {
       ++invalidation_counts_[it->first];
-      states_[it->first] = it->second;
+      invalidations_[it->first] = it->second;
     }
   }
 
@@ -165,7 +166,7 @@ class FakeDelegate : public SyncInvalidationListener::Delegate {
  private:
   typedef std::map<ObjectId, int, ObjectIdLessThan> ObjectIdCountMap;
   ObjectIdCountMap invalidation_counts_;
-  ObjectIdStateMap states_;
+  ObjectIdInvalidationMap invalidations_;
   InvalidatorState state_;
 };
 
diff --git a/sync/sessions/session_state_unittest.cc b/sync/sessions/session_state_unittest.cc
index 1069e94..3b3daea 100644
--- a/sync/sessions/session_state_unittest.cc
+++ b/sync/sessions/session_state_unittest.cc
@@ -30,11 +30,11 @@ class SessionStateTest : public testing::Test {};
 TEST_F(SessionStateTest, SyncSourceInfoToValue) {
   sync_pb::GetUpdatesCallerInfo::GetUpdatesSource updates_source =
       sync_pb::GetUpdatesCallerInfo::PERIODIC;
-  ModelTypeStateMap types;
+  ModelTypeInvalidationMap types;
   types[PREFERENCES].payload = "preferencespayload";
   types[EXTENSIONS].payload = "";
   scoped_ptr<DictionaryValue> expected_types_value(
-      ModelTypeStateMapToValue(types));
+      ModelTypeInvalidationMapToValue(types));
 
   SyncSourceInfo source_info(updates_source, types);
 
@@ -61,11 +61,11 @@ TEST_F(SessionStateTest, SyncSessionSnapshotToValue) {
   scoped_ptr<ListValue> expected_initial_sync_ended_value(
       ModelTypeSetToValue(initial_sync_ended));
 
-  ModelTypeStateMap download_progress_markers;
+  ModelTypeInvalidationMap download_progress_markers;
   download_progress_markers[BOOKMARKS].payload = "test";
   download_progress_markers[APPS].payload = "apps";
   scoped_ptr<DictionaryValue> expected_download_progress_markers_value(
-      ModelTypeStateMapToValue(download_progress_markers));
+      ModelTypeInvalidationMapToValue(download_progress_markers));
 
   const bool kHasMoreToSync = false;
   const bool kIsSilenced = true;
diff --git a/sync/sessions/sync_session.cc b/sync/sessions/sync_session.cc
index b2be0e5..9806425 100644
--- a/sync/sessions/sync_session.cc
+++ b/sync/sessions/sync_session.cc
@@ -48,17 +48,17 @@ std::set<ModelSafeGroup> ComputeEnabledGroups(
   return enabled_groups;
 }
 
-void PurgeStaleStates(ModelTypeStateMap* original,
+void PurgeStaleStates(ModelTypeInvalidationMap* original,
                       const ModelSafeRoutingInfo& routing_info) {
-  std::vector<ModelTypeStateMap::iterator> iterators_to_delete;
-  for (ModelTypeStateMap::iterator i = original->begin();
+  std::vector<ModelTypeInvalidationMap::iterator> iterators_to_delete;
+  for (ModelTypeInvalidationMap::iterator i = original->begin();
        i != original->end(); ++i) {
     if (routing_info.end() == routing_info.find(i->first)) {
       iterators_to_delete.push_back(i);
     }
   }
 
-  for (std::vector<ModelTypeStateMap::iterator>::iterator
+  for (std::vector<ModelTypeInvalidationMap::iterator>::iterator
        it = iterators_to_delete.begin(); it != iterators_to_delete.end();
        ++it) {
     original->erase(*it);
@@ -157,7 +157,7 @@ SyncSessionSnapshot SyncSession::TakeSnapshot() const {
 
   bool is_share_useable = true;
   ModelTypeSet initial_sync_ended;
-  ModelTypeStateMap download_progress_markers;
+  ModelTypeInvalidationMap download_progress_markers;
   for (int i = FIRST_REAL_MODEL_TYPE; i < MODEL_TYPE_COUNT; ++i) {
     ModelType type(ModelTypeFromInt(i));
     if (routing_info_.count(type) != 0) {
diff --git a/sync/sessions/sync_session_unittest.cc b/sync/sessions/sync_session_unittest.cc
index bc69fe8..d187ce6 100644
--- a/sync/sessions/sync_session_unittest.cc
+++ b/sync/sessions/sync_session_unittest.cc
@@ -12,7 +12,7 @@
 #include "sync/engine/syncer_types.h"
 #include "sync/engine/throttled_data_type_tracker.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map_test_util.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map_test_util.h"
 #include "sync/sessions/session_state.h"
 #include "sync/sessions/status_controller.h"
 #include "sync/syncable/syncable_id.h"
@@ -273,12 +273,12 @@ TEST_F(SyncSessionTest, ResetTransientState) {
 TEST_F(SyncSessionTest, Coalesce) {
   std::vector<ModelSafeWorker*> workers_one, workers_two;
   ModelSafeRoutingInfo routes_one, routes_two;
-  ModelTypeStateMap one_type =
-      ModelTypeSetToStateMap(
+  ModelTypeInvalidationMap one_type =
+      ModelTypeSetToInvalidationMap(
           ParamsMeaningJustOneEnabledType(),
           std::string());
-  ModelTypeStateMap all_types =
-      ModelTypeSetToStateMap(
+  ModelTypeInvalidationMap all_types =
+      ModelTypeSetToInvalidationMap(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_one(sync_pb::GetUpdatesCallerInfo::PERIODIC, one_type);
@@ -330,12 +330,12 @@ TEST_F(SyncSessionTest, Coalesce) {
 TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestRemoveOneType) {
   std::vector<ModelSafeWorker*> workers_one, workers_two;
   ModelSafeRoutingInfo routes_one, routes_two;
-  ModelTypeStateMap one_type =
-      ModelTypeSetToStateMap(
+  ModelTypeInvalidationMap one_type =
+      ModelTypeSetToInvalidationMap(
           ParamsMeaningJustOneEnabledType(),
           std::string());
-  ModelTypeStateMap all_types =
-      ModelTypeSetToStateMap(
+  ModelTypeInvalidationMap all_types =
+      ModelTypeSetToInvalidationMap(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_one(sync_pb::GetUpdatesCallerInfo::PERIODIC, one_type);
@@ -402,8 +402,8 @@ TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestRemoveOneType) {
 TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestWithSameType) {
   std::vector<ModelSafeWorker*> workers_first, workers_second;
   ModelSafeRoutingInfo routes_first, routes_second;
-  ModelTypeStateMap all_types =
-      ModelTypeSetToStateMap(
+  ModelTypeInvalidationMap all_types =
+      ModelTypeSetToInvalidationMap(
           ParamsMeaningAllEnabledTypes(),
           std::string());
   SyncSourceInfo source_first(sync_pb::GetUpdatesCallerInfo::PERIODIC,
@@ -482,23 +482,23 @@ TEST_F(SyncSessionTest, RebaseRoutingInfoWithLatestWithSameType) {
 }
 
 
-TEST_F(SyncSessionTest, MakeTypeStateMapFromBitSet) {
+TEST_F(SyncSessionTest, MakeTypeInvalidationMapFromBitSet) {
   ModelTypeSet types;
   std::string payload = "test";
-  ModelTypeStateMap type_state_map =
-      ModelTypeSetToStateMap(types, payload);
-  EXPECT_TRUE(type_state_map.empty());
+  ModelTypeInvalidationMap invalidation_map =
+      ModelTypeSetToInvalidationMap(types, payload);
+  EXPECT_TRUE(invalidation_map.empty());
 
   types.Put(BOOKMARKS);
   types.Put(PASSWORDS);
   types.Put(AUTOFILL);
   payload = "test2";
-  type_state_map = ModelTypeSetToStateMap(types, payload);
+  invalidation_map = ModelTypeSetToInvalidationMap(types, payload);
 
-  ASSERT_EQ(3U, type_state_map.size());
-  EXPECT_EQ(type_state_map[BOOKMARKS].payload, payload);
-  EXPECT_EQ(type_state_map[PASSWORDS].payload, payload);
-  EXPECT_EQ(type_state_map[AUTOFILL].payload, payload);
+  ASSERT_EQ(3U, invalidation_map.size());
+  EXPECT_EQ(invalidation_map[BOOKMARKS].payload, payload);
+  EXPECT_EQ(invalidation_map[PASSWORDS].payload, payload);
+  EXPECT_EQ(invalidation_map[AUTOFILL].payload, payload);
 }
 
 }  // namespace
diff --git a/sync/sync.gyp b/sync/sync.gyp
index 96ccfcc..4358eed 100644
--- a/sync/sync.gyp
+++ b/sync/sync.gyp
@@ -42,11 +42,11 @@
       'sources': [
         'base/sync_export.h',
         'internal_api/public/base/enum_set.h',
-        'internal_api/public/base/invalidation_state.cc',
-        'internal_api/public/base/invalidation_state.h',
+        'internal_api/public/base/invalidation.cc',
+        'internal_api/public/base/invalidation.h',
         'internal_api/public/base/model_type.h',
-        'internal_api/public/base/model_type_state_map.cc',
-        'internal_api/public/base/model_type_state_map.h',
+        'internal_api/public/base/model_type_invalidation_map.cc',
+        'internal_api/public/base/model_type_invalidation_map.h',
         'internal_api/public/base/node_ordinal.cc',
         'internal_api/public/base/node_ordinal.h',
         'internal_api/public/base/ordinal.h',
@@ -272,8 +272,8 @@
         'notifier/invalidator_registrar.h',
         'notifier/invalidator_state.cc',
         'notifier/invalidator_state.h',
-        'notifier/object_id_state_map.cc',
-        'notifier/object_id_state_map.h',
+        'notifier/object_id_invalidation_map.cc',
+        'notifier/object_id_invalidation_map.h',
       ],
       'conditions': [
         ['OS != "android"', {
@@ -428,10 +428,10 @@
         'sync',
       ],
       'sources': [
-        'internal_api/public/base/invalidation_state_test_util.cc',
-        'internal_api/public/base/invalidation_state_test_util.h',
-        'internal_api/public/base/model_type_state_map_test_util.cc',
-        'internal_api/public/base/model_type_state_map_test_util.h',
+        'internal_api/public/base/invalidation_test_util.cc',
+        'internal_api/public/base/invalidation_test_util.h',
+        'internal_api/public/base/model_type_invalidation_map_test_util.cc',
+        'internal_api/public/base/model_type_invalidation_map_test_util.h',
         'internal_api/public/base/model_type_test_util.cc',
         'internal_api/public/base/model_type_test_util.h',
         'js/js_test_util.cc',
@@ -498,8 +498,8 @@
         'notifier/fake_invalidation_handler.h',
         'notifier/invalidator_test_template.cc',
         'notifier/invalidator_test_template.h',
-        'notifier/object_id_state_map_test_util.cc',
-        'notifier/object_id_state_map_test_util.h',
+        'notifier/object_id_invalidation_map_test_util.cc',
+        'notifier/object_id_invalidation_map_test_util.h',
       ],
     },
 
@@ -592,7 +592,7 @@
         ],
         'sources': [
           'internal_api/public/base/enum_set_unittest.cc',
-          'internal_api/public/base/model_type_state_map_unittest.cc',
+          'internal_api/public/base/model_type_invalidation_map_unittest.cc',
           'internal_api/public/base/node_ordinal_unittest.cc',
           'internal_api/public/base/ordinal_unittest.cc',
           'internal_api/public/engine/model_safe_worker_unittest.cc',
diff --git a/sync/test/engine/fake_sync_scheduler.cc b/sync/test/engine/fake_sync_scheduler.cc
index fee1595..826119b 100644
--- a/sync/test/engine/fake_sync_scheduler.cc
+++ b/sync/test/engine/fake_sync_scheduler.cc
@@ -27,7 +27,7 @@ void FakeSyncScheduler::ScheduleNudgeAsync(
 
 void FakeSyncScheduler::ScheduleNudgeWithStatesAsync(
      const base::TimeDelta& delay, NudgeSource source,
-     const ModelTypeStateMap& types_with_payloads,
+     const ModelTypeInvalidationMap& invalidation_map,
      const tracked_objects::Location& nudge_location) {
 }
 
diff --git a/sync/test/engine/fake_sync_scheduler.h b/sync/test/engine/fake_sync_scheduler.h
index 40ebd41..9638ea6 100644
--- a/sync/test/engine/fake_sync_scheduler.h
+++ b/sync/test/engine/fake_sync_scheduler.h
@@ -28,7 +28,7 @@ class FakeSyncScheduler : public SyncScheduler {
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual void ScheduleNudgeWithStatesAsync(
       const base::TimeDelta& delay, NudgeSource source,
-      const ModelTypeStateMap& type_state_map,
+      const ModelTypeInvalidationMap& invalidation_map,
       const tracked_objects::Location& nudge_location) OVERRIDE;
   virtual bool ScheduleConfiguration(
       const ConfigurationParams& params) OVERRIDE;
diff --git a/sync/test/engine/mock_connection_manager.h b/sync/test/engine/mock_connection_manager.h
index 617e39d..008887b 100644
--- a/sync/test/engine/mock_connection_manager.h
+++ b/sync/test/engine/mock_connection_manager.h
@@ -17,7 +17,7 @@
 #include "base/memory/scoped_vector.h"
 #include "sync/engine/net/server_connection_manager.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/protocol/sync.pb.h"
 
 namespace syncer {
@@ -190,7 +190,7 @@ class MockConnectionManager : public ServerConnectionManager {
     expected_filter_ = expected_filter;
   }
 
-  void ExpectGetUpdatesRequestStates(const ModelTypeStateMap& states) {
+  void ExpectGetUpdatesRequestStates(const ModelTypeInvalidationMap& states) {
     expected_states_ = states;
   }
 
@@ -341,7 +341,7 @@ class MockConnectionManager : public ServerConnectionManager {
 
   ModelTypeSet expected_filter_;
 
-  ModelTypeStateMap expected_states_;
+  ModelTypeInvalidationMap expected_states_;
 
   int num_get_updates_requests_;
 
diff --git a/sync/test/engine/syncer_command_test.h b/sync/test/engine/syncer_command_test.h
index 8e1aa14..e177a87 100644
--- a/sync/test/engine/syncer_command_test.h
+++ b/sync/test/engine/syncer_command_test.h
@@ -100,8 +100,8 @@ class SyncerCommandTestBase : public testing::Test,
 
   // Lazily create a session requesting all datatypes with no state.
   sessions::SyncSession* session() {
-    ModelTypeStateMap types =
-        ModelSafeRoutingInfoToStateMap(routing_info_, std::string());
+    ModelTypeInvalidationMap types =
+        ModelSafeRoutingInfoToInvalidationMap(routing_info_, std::string());
     return session(sessions::SyncSourceInfo(types));
   }
 
diff --git a/sync/tools/sync_listen_notifications.cc b/sync/tools/sync_listen_notifications.cc
index e7eb13d..51cef83 100644
--- a/sync/tools/sync_listen_notifications.cc
+++ b/sync/tools/sync_listen_notifications.cc
@@ -24,7 +24,7 @@
 #include "net/base/transport_security_state.h"
 #include "net/url_request/url_request_test_util.h"
 #include "sync/internal_api/public/base/model_type.h"
-#include "sync/internal_api/public/base/model_type_state_map.h"
+#include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/notifier/invalidation_state_tracker.h"
 #include "sync/notifier/invalidation_handler.h"
 #include "sync/notifier/invalidation_util.h"
@@ -60,12 +60,13 @@ class NotificationPrinter : public InvalidationHandler {
   }
 
   virtual void OnIncomingInvalidation(
-      const ObjectIdStateMap& id_state_map,
+      const ObjectIdInvalidationMap& invalidation_map,
       IncomingInvalidationSource source) OVERRIDE {
-    const ModelTypeStateMap& type_state_map =
-        ObjectIdStateMapToModelTypeStateMap(id_state_map);
-    for (ModelTypeStateMap::const_iterator it = type_state_map.begin();
-         it != type_state_map.end(); ++it) {
+    const ModelTypeInvalidationMap& type_invalidation_map =
+        ObjectIdInvalidationMapToModelTypeInvalidationMap(invalidation_map);
+    for (ModelTypeInvalidationMap::const_iterator it =
+             type_invalidation_map.begin(); it != type_invalidation_map.end();
+         ++it) {
       LOG(INFO) << (source == REMOTE_INVALIDATION ? "Remote" : "Local")
                 << " Invalidation: type = "
                 << ModelTypeToString(it->first)