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

components/invalidation/invalidator_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 Invalidator should pass in
 // order to be conformant.  Here's how you use it to test your implementation.
 //
 // Say your class is called MyInvalidator.  Then you need to define a class
 // called MyInvalidatorTestDelegate in my_sync_notifier_unittest.cc like this:
 //
@@ skipping 128 matching lines @@
   invalidation_map.Insert(Invalidation::Init(this->id2, 2, "2"));
   invalidation_map.Insert(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());
 
   ObjectIdSet ids;
   ids.insert(this->id1);
   ids.insert(this->id2);
-  invalidator->UpdateRegisteredIds(&handler, ids);
+  EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler, ids));
 
   this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
 
   ObjectIdInvalidationMap expected_invalidations;
   expected_invalidations.Insert(Invalidation::Init(this->id1, 1, "1"));
   expected_invalidations.Insert(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->UpdateRegisteredIds(&handler, ids);
+  EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler, ids));
 
   expected_invalidations = ObjectIdInvalidationMap();
   expected_invalidations.Insert(Invalidation::Init(this->id2, 2, "2"));
   expected_invalidations.Insert(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 28 matching lines @@
 
   invalidator->RegisterHandler(&handler1);
   invalidator->RegisterHandler(&handler2);
   invalidator->RegisterHandler(&handler3);
   invalidator->RegisterHandler(&handler4);
 
   {
     ObjectIdSet ids;
     ids.insert(this->id1);
     ids.insert(this->id2);
-    invalidator->UpdateRegisteredIds(&handler1, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler1, ids));
   }
 
   {
     ObjectIdSet ids;
     ids.insert(this->id3);
-    invalidator->UpdateRegisteredIds(&handler2, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler2, ids));
   }
 
   // Don't register any IDs for handler3.
 
   {
     ObjectIdSet ids;
     ids.insert(this->id4);
-    invalidator->UpdateRegisteredIds(&handler4, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler4, ids));
   }
 
   invalidator->UnregisterHandler(&handler4);
 
   this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler1.GetInvalidatorState());
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler3.GetInvalidatorState());
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler4.GetInvalidatorState());
 
@@ skipping 27 matching lines @@
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler1.GetInvalidatorState());
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler2.GetInvalidatorState());
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler3.GetInvalidatorState());
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler4.GetInvalidatorState());
 
   invalidator->UnregisterHandler(&handler3);
   invalidator->UnregisterHandler(&handler2);
   invalidator->UnregisterHandler(&handler1);
 }
 
+// Multiple registrations by different handlers on the same object ID should
+// return false.
+TYPED_TEST_P(InvalidatorTest, MultipleRegistrations) {
+  Invalidator* const invalidator = this->CreateAndInitializeInvalidator();
+
+  FakeInvalidationHandler handler1;
+  FakeInvalidationHandler handler2;
+
+  invalidator->RegisterHandler(&handler1);
+  invalidator->RegisterHandler(&handler2);
+
+  // Registering both handlers for the same ObjectId. First call should succeed,
+  // second should fail.
+  ObjectIdSet ids;
+  ids.insert(this->id1);
+  EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler1, ids));
+  EXPECT_FALSE(invalidator->UpdateRegisteredIds(&handler2, ids));
+
+  invalidator->UnregisterHandler(&handler2);
+  invalidator->UnregisterHandler(&handler1);
+}
+
 // Make sure that passing an empty set to UpdateRegisteredIds clears the
 // corresponding entries for the handler.
 TYPED_TEST_P(InvalidatorTest, EmptySetUnregisters) {
   Invalidator* const invalidator = this->CreateAndInitializeInvalidator();
 
   FakeInvalidationHandler handler1;
 
   // Control observer.
   FakeInvalidationHandler handler2;
 
   invalidator->RegisterHandler(&handler1);
   invalidator->RegisterHandler(&handler2);
 
   {
     ObjectIdSet ids;
     ids.insert(this->id1);
     ids.insert(this->id2);
-    invalidator->UpdateRegisteredIds(&handler1, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler1, ids));
   }
 
   {
     ObjectIdSet ids;
     ids.insert(this->id3);
-    invalidator->UpdateRegisteredIds(&handler2, ids);
+    EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler2, ids));
   }
 
   // Unregister the IDs for the first observer. It should not receive any
   // further invalidations.
-  invalidator->UpdateRegisteredIds(&handler1, ObjectIdSet());
+  EXPECT_TRUE(invalidator->UpdateRegisteredIds(&handler1, ObjectIdSet()));
 
   this->delegate_.TriggerOnInvalidatorStateChange(INVALIDATIONS_ENABLED);
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler1.GetInvalidatorState());
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler2.GetInvalidatorState());
 
   {
     ObjectIdInvalidationMap invalidation_map;
     invalidation_map.Insert(Invalidation::Init(this->id1, 1, "1"));
     invalidation_map.Insert(Invalidation::Init(this->id2, 2, "2"));
     invalidation_map.Insert(Invalidation::Init(this->id3, 3, "3"));
@@ skipping 48 matching lines @@
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetLastRetrievedState());
 
   this->delegate_.TriggerOnInvalidatorStateChange(TRANSIENT_INVALIDATION_ERROR);
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler.GetInvalidatorState());
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler.GetLastRetrievedState());
 
   invalidator->UnregisterHandler(&handler);
 }
 
 REGISTER_TYPED_TEST_CASE_P(InvalidatorTest,
-                           Basic, MultipleHandlers, EmptySetUnregisters,
+                           Basic,
+                           MultipleHandlers,
+                           MultipleRegistrations,
+                           EmptySetUnregisters,
                            GetInvalidatorStateAlwaysCurrent);
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_INVALIDATION_INVALIDATOR_TEST_TEMPLATE_H_