[Invalidations] Add GetInvalidatorState() to Invalidator{,Frontend}

chrome/browser/sync/glue/chrome_sync_notification_bridge_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/sync/glue/chrome_sync_notification_bridge.h"
 
 #include <cstddef>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 51 matching lines @@
     sync_thread_.Stop();
     // Must be reset only after the sync thread is stopped.
     bridge_.reset();
     EXPECT_EQ(NULL, sync_handler_.get());
     if (!sync_handler_notification_success_)
       ADD_FAILURE() << "Sync handler did not receive proper notification.";
   }
 
   void VerifyAndDestroyObserver(
       const syncer::ModelTypeStateMap& expected_states,
-      syncer::IncomingNotificationSource expected_source) {
+      syncer::IncomingInvalidationSource expected_source) {
     ASSERT_TRUE(sync_thread_.message_loop_proxy()->PostTask(
         FROM_HERE,
         base::Bind(&ChromeSyncNotificationBridgeTest::
                        VerifyAndDestroyObserverOnSyncThread,
                    base::Unretained(this),
                    expected_states,
                    expected_source)));
     BlockForSyncThread();
   }
 
@@ skipping 23 matching lines @@
     content::NotificationService::current()->Notify(
         type,
         content::Source<Profile>(&mock_profile_),
         content::Details<const syncer::ModelTypeStateMap>(&state_map));
     BlockForSyncThread();
   }
 
  private:
   void VerifyAndDestroyObserverOnSyncThread(
       const syncer::ModelTypeStateMap& expected_states,
-      syncer::IncomingNotificationSource expected_source) {
+      syncer::IncomingInvalidationSource expected_source) {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     if (sync_handler_.get()) {
       sync_handler_notification_success_ =
-          (sync_handler_->GetNotificationCount() == 1) &&
+          (sync_handler_->GetInvalidationCount() == 1) &&
           ObjectIdStateMapEquals(
-              sync_handler_->GetLastNotificationIdStateMap(),
+              sync_handler_->GetLastInvalidationIdStateMap(),
               syncer::ModelTypeStateMapToObjectIdStateMap(expected_states)) &&
-          (sync_handler_->GetLastNotificationSource() == expected_source);
+          (sync_handler_->GetLastInvalidationSource() == expected_source);
       bridge_->UnregisterHandler(sync_handler_.get());
     } else {
       sync_handler_notification_success_ = false;
     }
     sync_handler_.reset();
   }
 
   void CreateObserverOnSyncThread() {
     DCHECK(sync_thread_.message_loop_proxy()->RunsTasksOnCurrentThread());
     sync_handler_.reset(new syncer::FakeInvalidationHandler());
@@ skipping 22 matching lines @@
   content::TestBrowserThread ui_thread_;
   base::Thread sync_thread_;
   NiceMock<ProfileMock> mock_profile_;
   // Created/used/destroyed on sync thread.
   scoped_ptr<syncer::FakeInvalidationHandler> sync_handler_;
   bool sync_handler_notification_success_;
   scoped_ptr<ChromeSyncNotificationBridge> bridge_;
 };
 
 // Adds an observer on the sync thread, triggers a local refresh
-// notification, and ensures the bridge posts a LOCAL_NOTIFICATION
+// 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()));
   CreateObserver();
   UpdateEnabledTypes(syncer::ModelTypeSet(syncer::SESSIONS));
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
                              state_map);
-  VerifyAndDestroyObserver(state_map, syncer::LOCAL_NOTIFICATION);
+  VerifyAndDestroyObserver(state_map, syncer::LOCAL_INVALIDATION);
 }
 
 // Adds an observer on the sync thread, triggers a remote refresh
-// notification, and ensures the bridge posts a REMOTE_NOTIFICATION
+// 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()));
   CreateObserver();
   UpdateEnabledTypes(syncer::ModelTypeSet(syncer::SESSIONS));
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
                              state_map);
-  VerifyAndDestroyObserver(state_map, syncer::REMOTE_NOTIFICATION);
+  VerifyAndDestroyObserver(state_map, syncer::REMOTE_INVALIDATION);
 }
 
 // Adds an observer on the sync thread, triggers a local refresh
 // notification with empty state map and ensures the bridge posts a
-// LOCAL_NOTIFICATION with the proper state to it.
+// LOCAL_INVALIDATION with the proper state to it.
 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());
   CreateObserver();
   UpdateEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_LOCAL,
                              syncer::ModelTypeStateMap());
   VerifyAndDestroyObserver(
-      enabled_types_state_map, syncer::LOCAL_NOTIFICATION);
+      enabled_types_state_map, syncer::LOCAL_INVALIDATION);
 }
 
 // Adds an observer on the sync thread, triggers a remote refresh
 // notification with empty state map and ensures the bridge posts a
-// REMOTE_NOTIFICATION with the proper state to it.
+// REMOTE_INVALIDATION with the proper state to it.
 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());
   CreateObserver();
   UpdateEnabledTypes(enabled_types);
   TriggerRefreshNotification(chrome::NOTIFICATION_SYNC_REFRESH_REMOTE,
                              syncer::ModelTypeStateMap());
   VerifyAndDestroyObserver(
-      enabled_types_state_map, syncer::REMOTE_NOTIFICATION);
+      enabled_types_state_map, syncer::REMOTE_INVALIDATION);
 }
 
 }  // namespace
 }  // namespace browser_sync