Enable invalidations for arbitrary objects on Android.

chrome/browser/invalidation/invalidation_service_android_unittest.cc

 // Copyright (c) 2013 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/invalidation/invalidation_service_android.h"
 
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/invalidation/invalidation_service_factory.h"
 #include "chrome/browser/invalidation/invalidation_service_test_template.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_service.h"
+#include "sync/notifier/fake_invalidation_handler.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace invalidation {
 
 class InvalidationServiceAndroidTestDelegate {
  public:
   InvalidationServiceAndroidTestDelegate() { }
 
   ~InvalidationServiceAndroidTestDelegate() {
     DestroyInvalidationService();
@@ skipping 27 matching lines @@
   }
 
   scoped_ptr<TestingProfile> profile_;
   scoped_ptr<InvalidationServiceAndroid> invalidation_service_android_;
 };
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     AndroidInvalidationServiceTest, InvalidationServiceTest,
     InvalidationServiceAndroidTestDelegate);
 
+class InvalidationServiceAndroidRegistrationTest : public testing::Test {
+ protected:
+  InvalidationServiceAndroidRegistrationTest()
+      : invalidation_service_(&profile_),
+        object_registration_updated_(false) {
+    invalidation_service_.SetUpdateRegistrationCallbackForTest(base::Bind(
+        &InvalidationServiceAndroidRegistrationTest::UpdateRegistration,
+        base::Unretained(this)));
+    OBJECT_SET_A.insert(invalidation::ObjectId(1, "A"));
+    OBJECT_SET_A.insert(invalidation::ObjectId(2, "B"));
+    OBJECT_SET_A.insert(invalidation::ObjectId(3, "C"));
+    OBJECT_SET_B.insert(invalidation::ObjectId(1, "D"));
+    OBJECT_SET_B.insert(invalidation::ObjectId(2, "E"));
+    OBJECT_SET_C.insert(invalidation::ObjectId(3, "F"));
+    OBJECT_SET_SYNC.insert(
+        invalidation::ObjectId(ipc::invalidation::ObjectSource::CHROME_SYNC,
+        "A"));
+    OBJECT_SET_SYNC.insert(
+        invalidation::ObjectId(ipc::invalidation::ObjectSource::CHROME_SYNC,
+        "B"));
+    OBJECT_SET_MIXED.insert(OBJECT_SET_A.begin(), OBJECT_SET_A.end());
+    OBJECT_SET_MIXED.insert(OBJECT_SET_SYNC.begin(), OBJECT_SET_SYNC.end());
+  }
+
+  virtual ~InvalidationServiceAndroidRegistrationTest() {
+    invalidation_service_.Shutdown();
+  }
+
+  // Determines if the object registration was updated since the last time this
+  // method was called.
+  bool ObjectRegistrationUpdated() {
+    bool updated = object_registration_updated_;
+    object_registration_updated_ = false;
+    return updated;
+  }
+
+  // Determines if all of the object ids in the given set were registered in
+  // the last registration update.
+  bool ObjectsRegistered(const syncer::ObjectIdSet& ids) {
+    return CheckObjectRegistration(ids, true /* expect_registered */);
+  }
+
+  // Determines if none of the object ids in the given set were registered in
+  // the last registration update.
+  bool ObjectsNotRegistered(const syncer::ObjectIdSet& ids) {
+    return CheckObjectRegistration(ids, false /* expect_registered */);
+  }
+
+  // Get the number of objects which are registered.
+  size_t RegisteredObjectCount() {
+    return registered_object_ids_.size();
+  }
+
+  // Determines if the given object id was registered in the last registration
+  // update.
+  bool IsRegistered(const invalidation::ObjectId& id) {
+    return registered_object_ids_.find(id) != registered_object_ids_.end();
+  }
+
+  // Disjoint object id sets containing non-Sync object ids.
+  syncer::ObjectIdSet OBJECT_SET_A;
+  syncer::ObjectIdSet OBJECT_SET_B;
+  syncer::ObjectIdSet OBJECT_SET_C;
+
+  // An object id set containing Sync object ids.
+  syncer::ObjectIdSet OBJECT_SET_SYNC;
+
+  // An object id set comprised of the union of OBJECT_SET_A and
+  // OBJECT_SET_SYNC.
+  syncer::ObjectIdSet OBJECT_SET_MIXED;
+
+  TestingProfile profile_;
+
+  // The invalidation service used for testing.
+  InvalidationServiceAndroid invalidation_service_;
+
+ private:
+  // Determines if all of the object ids in the given set have the same
+  // registration status.
+  bool CheckObjectRegistration(const syncer::ObjectIdSet& ids,
+                               bool expect_registered) {
+    syncer::ObjectIdSet::const_iterator id;
+    for (id = ids.begin(); id != ids.end(); ++id)
+      if (IsRegistered(*id) != expect_registered)
+        return false;
+    return true;
+  }
+
+  // Callback invoked when the invalidation service updates the registration.
+  void UpdateRegistration(const std::vector<int>& object_sources,
+                          const std::vector<std::string>& object_names) {
+    object_registration_updated_ = true;
+    registered_object_ids_.clear();
+    for (size_t i = 0; i < object_sources.size(); ++i) {
+      registered_object_ids_.insert(invalidation::ObjectId(
+          object_sources[i], object_names[i]));
+    }
+  }
+
+  bool object_registration_updated_;
+  syncer::ObjectIdSet registered_object_ids_;
+};
+
+TEST_F(InvalidationServiceAndroidRegistrationTest, NoObjectRegistration) {
+  syncer::FakeInvalidationHandler handler;
+  invalidation_service_.RegisterInvalidationHandler(&handler);
+  EXPECT_EQ(0U, RegisteredObjectCount());
+  invalidation_service_.UnregisterInvalidationHandler(&handler);
+}
+
+TEST_F(InvalidationServiceAndroidRegistrationTest, UpdateObjectRegistration) {
+  syncer::FakeInvalidationHandler handler1;
+  syncer::FakeInvalidationHandler handler2;
+  syncer::FakeInvalidationHandler handler3;
+  syncer::FakeInvalidationHandler handler4;
+  invalidation_service_.RegisterInvalidationHandler(&handler1);
+  invalidation_service_.RegisterInvalidationHandler(&handler2);
+  invalidation_service_.RegisterInvalidationHandler(&handler3);
+  invalidation_service_.RegisterInvalidationHandler(&handler4);
+
+  // Register for object set A.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler1,
+                                                        OBJECT_SET_A);
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  EXPECT_EQ(OBJECT_SET_A.size(), RegisteredObjectCount());
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_A));
+
+  // Register for object sets B and C.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler2,
+                                                        OBJECT_SET_B);
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler3,
+                                                        OBJECT_SET_C);
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  EXPECT_EQ(OBJECT_SET_A.size() + OBJECT_SET_B.size() + OBJECT_SET_C.size(),
+            RegisteredObjectCount());
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_A));
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_B));
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_C));
+
+  // Register for sync object set. Expect no registration update.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler4,
+                                                        OBJECT_SET_SYNC);
+  EXPECT_FALSE(ObjectRegistrationUpdated());
+  EXPECT_TRUE(ObjectsNotRegistered(OBJECT_SET_SYNC));
+
+  // Unregister for object set C.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler3,
+                                                        syncer::ObjectIdSet());
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  EXPECT_TRUE(ObjectsNotRegistered(OBJECT_SET_C));
+
+  // Unregister for object set A.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler1,
+                                                        syncer::ObjectIdSet());
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  EXPECT_TRUE(ObjectsNotRegistered(OBJECT_SET_A));
+
+  // Unregister for sync object set. Expect no registration update.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler4,
+                                                        syncer::ObjectIdSet());
+  EXPECT_FALSE(ObjectRegistrationUpdated());
+
+  // Register for mixed object set. Expect only the objects in set A to be
+  // registered.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler3,
+                                                        OBJECT_SET_MIXED);
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_A));
+  EXPECT_TRUE(ObjectsNotRegistered(OBJECT_SET_SYNC));
+
+  // Unregister the handler mapped to set B. Expect no registration update.
+  invalidation_service_.UnregisterInvalidationHandler(&handler2);
+  EXPECT_FALSE(ObjectRegistrationUpdated());
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_B));
+
+  // Replace object set A with object set C.
+  invalidation_service_.UpdateRegisteredInvalidationIds(&handler3,
+                                                        OBJECT_SET_C);
+  EXPECT_TRUE(ObjectRegistrationUpdated());
+  EXPECT_TRUE(ObjectsNotRegistered(OBJECT_SET_A));
+  EXPECT_TRUE(ObjectsRegistered(OBJECT_SET_C));
+
+  invalidation_service_.UnregisterInvalidationHandler(&handler1);
+  invalidation_service_.UnregisterInvalidationHandler(&handler3);
+  invalidation_service_.UnregisterInvalidationHandler(&handler4);
+}
+
 }  // namespace invalidation