Rename SyncNotifier->Invalidator and SyncNotifierObserver->InvalidationHandler.

sync/notifier/invalidator_registrar_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 "google/cacheinvalidation/types.pb.h"
-#include "sync/notifier/fake_sync_notifier_observer.h"
+#include "sync/notifier/fake_invalidation_handler.h"
+#include "sync/notifier/invalidator_registrar.h"
 #include "sync/notifier/object_id_state_map_test_util.h"
-#include "sync/notifier/sync_notifier_registrar.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
-class SyncNotifierRegistrarTest : public testing::Test {
+class InvalidatorRegistrarTest : public testing::Test {
  protected:
-  SyncNotifierRegistrarTest()
+  InvalidatorRegistrarTest()
       : kObjectId1(ipc::invalidation::ObjectSource::TEST, "a"),
         kObjectId2(ipc::invalidation::ObjectSource::TEST, "b"),
         kObjectId3(ipc::invalidation::ObjectSource::TEST, "c"),
         kObjectId4(ipc::invalidation::ObjectSource::TEST, "d") {
   }
 
   const invalidation::ObjectId kObjectId1;
   const invalidation::ObjectId kObjectId2;
   const invalidation::ObjectId kObjectId3;
   const invalidation::ObjectId kObjectId4;
 };
 
 // Register a handler, register some IDs for that handler, and then unregister
 // the handler, dispatching invalidations in between.  The handler should only
 // see invalidations when its registered and its IDs are registered.
-TEST_F(SyncNotifierRegistrarTest, Basic) {
-  FakeSyncNotifierObserver handler;
+TEST_F(InvalidatorRegistrarTest, Basic) {
+  FakeInvalidationHandler handler;
 
-  SyncNotifierRegistrar registrar;
+  InvalidatorRegistrar registrar;
 
   registrar.RegisterHandler(&handler);
 
   ObjectIdStateMap states;
   states[kObjectId1].payload = "1";
   states[kObjectId2].payload = "2";
   states[kObjectId3].payload = "3";
 
   // Should be ignored since no IDs are registered to |handler|.
   registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
@@ skipping 35 matching lines @@
   // Should be ignored since |handler| isn't registered anymore.
   registrar.DispatchInvalidationsToHandlers(states, REMOTE_NOTIFICATION);
   EXPECT_EQ(2, handler.GetNotificationCount());
 }
 
 // Register handlers and some IDs for those handlers, register a handler with
 // no IDs, and register a handler with some IDs but unregister it.  Then,
 // dispatch some notifications and invalidations.  Handlers that are registered
 // should get notifications, and the ones that have registered IDs should
 // receive invalidations for those IDs.
-TEST_F(SyncNotifierRegistrarTest, MultipleHandlers) {
-  FakeSyncNotifierObserver handler1;
-  FakeSyncNotifierObserver handler2;
-  FakeSyncNotifierObserver handler3;
-  FakeSyncNotifierObserver handler4;
+TEST_F(InvalidatorRegistrarTest, MultipleHandlers) {
+  FakeInvalidationHandler handler1;
+  FakeInvalidationHandler handler2;
+  FakeInvalidationHandler handler3;
+  FakeInvalidationHandler handler4;
 
-  SyncNotifierRegistrar registrar;
+  InvalidatorRegistrar registrar;
 
   registrar.RegisterHandler(&handler1);
   registrar.RegisterHandler(&handler2);
   registrar.RegisterHandler(&handler3);
   registrar.RegisterHandler(&handler4);
 
   {
     ObjectIdSet ids;
     ids.insert(kObjectId1);
     ids.insert(kObjectId2);
@@ skipping 63 matching lines @@
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             handler2.GetNotificationsDisabledReason());
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             handler3.GetNotificationsDisabledReason());
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             handler4.GetNotificationsDisabledReason());
 }
 
 // Multiple registrations by different handlers on the same object ID should
 // cause a CHECK.
-TEST_F(SyncNotifierRegistrarTest, MultipleRegistration) {
-  SyncNotifierRegistrar registrar;
+TEST_F(InvalidatorRegistrarTest, MultipleRegistration) {
+  InvalidatorRegistrar registrar;
 
-  FakeSyncNotifierObserver handler1;
+  FakeInvalidationHandler handler1;
   registrar.RegisterHandler(&handler1);
 
-  FakeSyncNotifierObserver handler2;
+  FakeInvalidationHandler handler2;
   registrar.RegisterHandler(&handler2);
 
   ObjectIdSet ids;
   ids.insert(kObjectId1);
   ids.insert(kObjectId2);
   registrar.UpdateRegisteredIds(&handler1, ids);
 
   registrar.DetachFromThreadForTest();
   // We expect a death via CHECK(). We can't match against the CHECK() message
   // though since they are removed in official builds.
   EXPECT_DEATH({ registrar.UpdateRegisteredIds(&handler2, ids); }, "");
 }
 
 // Make sure that passing an empty set to UpdateRegisteredIds clears the
 // corresponding entries for the handler.
-TEST_F(SyncNotifierRegistrarTest, EmptySetUnregisters) {
-  FakeSyncNotifierObserver handler1;
+TEST_F(InvalidatorRegistrarTest, EmptySetUnregisters) {
+  FakeInvalidationHandler handler1;
 
   // Control observer.
-  FakeSyncNotifierObserver handler2;
+  FakeInvalidationHandler handler2;
 
-  SyncNotifierRegistrar registrar;
+  InvalidatorRegistrar registrar;
 
   registrar.RegisterHandler(&handler1);
   registrar.RegisterHandler(&handler2);
 
   {
     ObjectIdSet ids;
     ids.insert(kObjectId1);
     ids.insert(kObjectId2);
     registrar.UpdateRegisteredIds(&handler1, ids);
   }
@@ skipping 28 matching lines @@
   registrar.EmitOnNotificationsDisabled(TRANSIENT_NOTIFICATION_ERROR);
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             handler1.GetNotificationsDisabledReason());
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             handler2.GetNotificationsDisabledReason());
 }
 
 }  // namespace
 
 }  // namespace syncer