[Sync] InvalidationService shouldn't CHECK when registering ObjectId for more than one handler

components/invalidation/invalidation_service_test_template.h

 // Copyright 2014 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.
 
 // This class defines tests that implementations of InvalidationService should
 // pass in order to be conformant.  Here's how you use it to test your
 // implementation.
 //
 // Say your class is called MyInvalidationService.  Then you need to define a
 // class called MyInvalidationServiceTestDelegate in
@@ skipping 116 matching lines @@
   invalidation_map.Insert(syncer::Invalidation::Init(this->id2, 2, "2"));
   invalidation_map.Insert(syncer::Invalidation::Init(this->id3, 3, "3"));
 
   // Should be ignored since no IDs are registered to |handler|.
   this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
   EXPECT_EQ(0, handler.GetInvalidationCount());
 
   syncer::ObjectIdSet ids;
   ids.insert(this->id1);
   ids.insert(this->id2);
-  invalidator->UpdateRegisteredInvalidationIds(&handler, ids);
+  EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler, ids));
 
   this->delegate_.TriggerOnInvalidatorStateChange(
       syncer::INVALIDATIONS_ENABLED);
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
 
   syncer::ObjectIdInvalidationMap expected_invalidations;
   expected_invalidations.Insert(syncer::Invalidation::Init(this->id1, 1, "1"));
   expected_invalidations.Insert(syncer::Invalidation::Init(this->id2, 2, "2"));
 
   this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
   EXPECT_EQ(1, handler.GetInvalidationCount());
   EXPECT_THAT(expected_invalidations, Eq(handler.GetLastInvalidationMap()));
 
   ids.erase(this->id1);
   ids.insert(this->id3);
-  invalidator->UpdateRegisteredInvalidationIds(&handler, ids);
+  EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler, ids));
 
   expected_invalidations = syncer::ObjectIdInvalidationMap();
   expected_invalidations.Insert(syncer::Invalidation::Init(this->id2, 2, "2"));
   expected_invalidations.Insert(syncer::Invalidation::Init(this->id3, 3, "3"));
 
   // Removed object IDs should not be notified, newly-added ones should.
   this->delegate_.TriggerOnIncomingInvalidation(invalidation_map);
   EXPECT_EQ(2, handler.GetInvalidationCount());
   EXPECT_THAT(expected_invalidations, Eq(handler.GetLastInvalidationMap()));
 
@@ skipping 30 matching lines @@
 
   invalidator->RegisterInvalidationHandler(&handler1);
   invalidator->RegisterInvalidationHandler(&handler2);
   invalidator->RegisterInvalidationHandler(&handler3);
   invalidator->RegisterInvalidationHandler(&handler4);
 
   {
     syncer::ObjectIdSet ids;
     ids.insert(this->id1);
     ids.insert(this->id2);
-    invalidator->UpdateRegisteredInvalidationIds(&handler1, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler1, ids));
   }
 
   {
     syncer::ObjectIdSet ids;
     ids.insert(this->id3);
-    invalidator->UpdateRegisteredInvalidationIds(&handler2, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler2, ids));
   }
 
   // Don't register any IDs for handler3.
 
   {
     syncer::ObjectIdSet ids;
     ids.insert(this->id4);
-    invalidator->UpdateRegisteredInvalidationIds(&handler4, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler4, ids));
   }
 
   invalidator->UnregisterInvalidationHandler(&handler4);
 
   this->delegate_.TriggerOnInvalidatorStateChange(
       syncer::INVALIDATIONS_ENABLED);
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler1.GetInvalidatorState());
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler3.GetInvalidatorState());
   EXPECT_EQ(syncer::TRANSIENT_INVALIDATION_ERROR,
@@ skipping 36 matching lines @@
   EXPECT_EQ(syncer::TRANSIENT_INVALIDATION_ERROR,
             handler3.GetInvalidatorState());
   EXPECT_EQ(syncer::TRANSIENT_INVALIDATION_ERROR,
             handler4.GetInvalidatorState());
 
   invalidator->UnregisterInvalidationHandler(&handler3);
   invalidator->UnregisterInvalidationHandler(&handler2);
   invalidator->UnregisterInvalidationHandler(&handler1);
 }
 
+// Multiple registrations by different handlers on the same object ID should
+// return false.
+TYPED_TEST_P(InvalidationServiceTest, MultipleRegistrations) {
+  invalidation::InvalidationService* const invalidator =
+      this->CreateAndInitializeInvalidationService();
+
+  syncer::FakeInvalidationHandler handler1;
+  syncer::FakeInvalidationHandler handler2;
+
+  invalidator->RegisterInvalidationHandler(&handler1);
+  invalidator->RegisterInvalidationHandler(&handler2);
+
+  // Registering both handlers for the same ObjectId. First call should succeed,
+  // second should fail.
+  syncer::ObjectIdSet ids;
+  ids.insert(this->id1);
+  EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler1, ids));
+  EXPECT_FALSE(invalidator->UpdateRegisteredInvalidationIds(&handler2, ids));
+
+  invalidator->UnregisterInvalidationHandler(&handler2);
+  invalidator->UnregisterInvalidationHandler(&handler1);
+}
+
 // Make sure that passing an empty set to UpdateRegisteredInvalidationIds clears
 // the corresponding entries for the handler.
 TYPED_TEST_P(InvalidationServiceTest, EmptySetUnregisters) {
   invalidation::InvalidationService* const invalidator =
       this->CreateAndInitializeInvalidationService();
 
   syncer::FakeInvalidationHandler handler1;
 
   // Control observer.
   syncer::FakeInvalidationHandler handler2;
 
   invalidator->RegisterInvalidationHandler(&handler1);
   invalidator->RegisterInvalidationHandler(&handler2);
 
   {
     syncer::ObjectIdSet ids;
     ids.insert(this->id1);
     ids.insert(this->id2);
-    invalidator->UpdateRegisteredInvalidationIds(&handler1, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler1, ids));
   }
 
   {
     syncer::ObjectIdSet ids;
     ids.insert(this->id3);
-    invalidator->UpdateRegisteredInvalidationIds(&handler2, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(&handler2, ids));
   }
 
   // Unregister the IDs for the first observer. It should not receive any
   // further invalidations.
-  invalidator->UpdateRegisteredInvalidationIds(&handler1,
-                                               syncer::ObjectIdSet());
+  EXPECT_TRUE(invalidator->UpdateRegisteredInvalidationIds(
+      &handler1, syncer::ObjectIdSet()));
 
   this->delegate_.TriggerOnInvalidatorStateChange(
       syncer::INVALIDATIONS_ENABLED);
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler1.GetInvalidatorState());
   EXPECT_EQ(syncer::INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
 
   {
     syncer::ObjectIdInvalidationMap invalidation_map;
     invalidation_map.Insert(syncer::Invalidation::Init(this->id1, 1, "1"));
     invalidation_map.Insert(syncer::Invalidation::Init(this->id2, 2, "2"));
@@ skipping 58 matching lines @@
       syncer::TRANSIENT_INVALIDATION_ERROR);
   EXPECT_EQ(syncer::TRANSIENT_INVALIDATION_ERROR,
             handler.GetInvalidatorState());
   EXPECT_EQ(syncer::TRANSIENT_INVALIDATION_ERROR,
             handler.GetLastRetrievedState());
 
   invalidator->UnregisterInvalidationHandler(&handler);
 }
 
 REGISTER_TYPED_TEST_CASE_P(InvalidationServiceTest,
-                           Basic, MultipleHandlers, EmptySetUnregisters,
+                           Basic,
+                           MultipleHandlers,
+                           MultipleRegistrations,
+                           EmptySetUnregisters,
                            GetInvalidatorStateAlwaysCurrent);
 
 #endif  // COMPONENTS_INVALIDATION_INVALIDATION_SERVICE_TEST_TEMPLATE_H_