[Tango->FCM] Part 1. Ditch the objectId from the new FCM-based architecture.

ObjectId is the representation of the subscription topic from the
outdated Tango protocol.

It's not relevant to the new architecture, since subscription is represented
by topic name (in case of sync topic name is for example "BOOKMARKS" or
"PASSWORDS").

After this CL all code related to the FCMInvalidationService won't use the
ObjectId. But in some places the term Id still used. This is the subject for
follow up refactoring.


Bug: 878446, 801985
Change-Id: Idcf5bb464fff8976b319bd4721bdca2e3be77751
Reviewed-on: https://chromium-review.googlesource.com/1194032
Commit-Queue: Tatiana Gornak <melandory@chromium.org>
Reviewed-by: Pavel Yatsuk <pavely@chromium.org>
Cr-Commit-Position: refs/heads/master@{#587904}

components/invalidation/impl/BUILD.gn

@@ -212,6 +212,8 @@ static_library("test_support") {
     "fake_invalidator.h",
     "fake_system_resources.cc",
     "fake_system_resources.h",
+    "fcm_fake_invalidator.cc",
+    "fcm_fake_invalidator.h",
     "invalidation_service_test_template.cc",
     "invalidation_service_test_template.h",
     "invalidation_test_util.cc",

components/invalidation/impl/deprecated_invalidator_registrar_unittest.cc

@@ -42,6 +42,11 @@ class DeprecatedRegistrarInvalidator : public Invalidator {
     registrar_.UnregisterHandler(handler);
   }
 
+  bool UpdateRegisteredIds(InvalidationHandler*, const TopicSet&) override {
+    NOTREACHED();
+    return false;
+  }
+
   InvalidatorState GetInvalidatorState() const override {
     return registrar_.GetInvalidatorState();
   }

components/invalidation/impl/fake_invalidator.cc

@@ -47,6 +47,12 @@ bool FakeInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
   return registrar_.UpdateRegisteredIds(handler, ids);
 }
 
+bool FakeInvalidator::UpdateRegisteredIds(InvalidationHandler*,
+                                          const TopicSet&) {
+  NOTREACHED();
+  return false;
+}
+
 void FakeInvalidator::UnregisterHandler(InvalidationHandler* handler) {
   registrar_.UnregisterHandler(handler);
 }

components/invalidation/impl/fake_invalidator.h

@@ -33,6 +33,8 @@ class FakeInvalidator : public Invalidator {
   void RegisterHandler(InvalidationHandler* handler) override;
   bool UpdateRegisteredIds(InvalidationHandler* handler,
                            const ObjectIdSet& ids) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& topics) override;
   void UnregisterHandler(InvalidationHandler* handler) override;
   InvalidatorState GetInvalidatorState() const override;
   void UpdateCredentials(const std::string& email,

components/invalidation/impl/fcm_fake_invalidator.cc

+// Copyright 2018 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 "components/invalidation/impl/fcm_fake_invalidator.h"
+
+#include "components/invalidation/public/invalidation_util.h"
+#include "components/invalidation/public/object_id_invalidation_map.h"
+#include "components/invalidation/public/topic_invalidation_map.h"
+
+namespace syncer {
+
+FCMFakeInvalidator::FCMFakeInvalidator() {}
+
+FCMFakeInvalidator::~FCMFakeInvalidator() {}
+
+bool FCMFakeInvalidator::IsHandlerRegistered(
+    InvalidationHandler* handler) const {
+  return registrar_.IsHandlerRegisteredForTest(handler);
+}
+
+ObjectIdSet FCMFakeInvalidator::GetRegisteredIds(
+    InvalidationHandler* handler) const {
+  return ConvertTopicsToIds(registrar_.GetRegisteredTopics(handler));
+}
+
+const std::string& FCMFakeInvalidator::GetCredentialsEmail() const {
+  return email_;
+}
+
+const std::string& FCMFakeInvalidator::GetCredentialsToken() const {
+  return token_;
+}
+
+void FCMFakeInvalidator::EmitOnInvalidatorStateChange(InvalidatorState state) {
+  registrar_.UpdateInvalidatorState(state);
+}
+
+void FCMFakeInvalidator::EmitOnIncomingInvalidation(
+    const ObjectIdInvalidationMap& invalidation_map) {
+  registrar_.DispatchInvalidationsToHandlers(
+      ConvertObjectIdInvalidationMapToTopicInvalidationMap(invalidation_map));
+}
+
+void FCMFakeInvalidator::RegisterHandler(InvalidationHandler* handler) {
+  registrar_.RegisterHandler(handler);
+}
+
+bool FCMFakeInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
+                                             const ObjectIdSet& ids) {
+  return false;
+  NOTREACHED();
+}
+
+bool FCMFakeInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
+                                             const TopicSet& topics) {
+  return registrar_.UpdateRegisteredTopics(handler, topics);
+}
+
+void FCMFakeInvalidator::UnregisterHandler(InvalidationHandler* handler) {
+  registrar_.UnregisterHandler(handler);
+}
+
+InvalidatorState FCMFakeInvalidator::GetInvalidatorState() const {
+  return registrar_.GetInvalidatorState();
+}
+
+void FCMFakeInvalidator::UpdateCredentials(const std::string& email,
+                                           const std::string& token) {
+  email_ = email;
+  token_ = token;
+}
+
+void FCMFakeInvalidator::RequestDetailedStatus(
+    base::Callback<void(const base::DictionaryValue&)> callback) const {
+  base::DictionaryValue value;
+  callback.Run(value);
+}
+}  // namespace syncer

components/invalidation/impl/fcm_fake_invalidator.h

+// Copyright 2018 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.
+
+#ifndef COMPONENTS_INVALIDATION_IMPL_FCM_FAKE_INVALIDATOR_H_
+#define COMPONENTS_INVALIDATION_IMPL_FCM_FAKE_INVALIDATOR_H_
+
+#include <string>
+
+#include "base/callback_forward.h"
+#include "base/compiler_specific.h"
+#include "components/invalidation/impl/invalidator.h"
+#include "components/invalidation/impl/invalidator_registrar.h"
+#include "components/invalidation/public/invalidation_util.h"
+
+namespace syncer {
+
+class FCMFakeInvalidator : public Invalidator {
+ public:
+  FCMFakeInvalidator();
+  ~FCMFakeInvalidator() override;
+
+  bool IsHandlerRegistered(InvalidationHandler* handler) const;
+  ObjectIdSet GetRegisteredIds(InvalidationHandler* handler) const;
+  const std::string& GetUniqueId() const;
+  const std::string& GetCredentialsEmail() const;
+  const std::string& GetCredentialsToken() const;
+
+  void EmitOnInvalidatorStateChange(InvalidatorState state);
+  void EmitOnIncomingInvalidation(
+      const ObjectIdInvalidationMap& invalidation_map);
+
+  void RegisterHandler(InvalidationHandler* handler) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const ObjectIdSet& ids) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& topics) override;
+  void UnregisterHandler(InvalidationHandler* handler) override;
+  InvalidatorState GetInvalidatorState() const override;
+  void UpdateCredentials(const std::string& email,
+                         const std::string& token) override;
+  void RequestDetailedStatus(base::Callback<void(const base::DictionaryValue&)>
+                                 callback) const override;
+
+ private:
+  InvalidatorRegistrar registrar_;
+  std::string state_;
+  std::string email_;
+  std::string token_;
+};
+
+}  // namespace syncer
+
+#endif  // COMPONENTS_INVALIDATION_IMPL_FCM_FAKE_INVALIDATOR_H_

components/invalidation/impl/fcm_invalidation_service.cc

@@ -11,6 +11,7 @@
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/invalidation/public/invalidator_state.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
+#include "components/invalidation/public/topic_invalidation_map.h"
 #include "google_apis/gaia/gaia_constants.h"
 
 namespace invalidation {
@@ -71,13 +72,14 @@ bool FCMInvalidationService::UpdateRegisteredInvalidationIds(
     const syncer::ObjectIdSet& ids) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DVLOG(2) << "Registering ids: " << ids.size();
-  if (!invalidator_registrar_.UpdateRegisteredIds(handler, ids))
+  syncer::TopicSet topics = ConvertIdsToTopics(ids);
+  if (!invalidator_registrar_.UpdateRegisteredTopics(handler, topics))
     return false;
   if (invalidator_) {
     CHECK(invalidator_->UpdateRegisteredIds(
         this, invalidator_registrar_.GetAllRegisteredIds()));
   }
-  logger_.OnUpdateIds(invalidator_registrar_.GetSanitizedHandlersIdsMap());
+  logger_.OnUpdateTopics(invalidator_registrar_.GetSanitizedHandlersIdsMap());
   return true;
 }
 
@@ -144,7 +146,8 @@ void FCMInvalidationService::OnInvalidatorStateChange(
 
 void FCMInvalidationService::OnIncomingInvalidation(
     const syncer::ObjectIdInvalidationMap& invalidation_map) {
-  invalidator_registrar_.DispatchInvalidationsToHandlers(invalidation_map);
+  invalidator_registrar_.DispatchInvalidationsToHandlers(
+      ConvertObjectIdInvalidationMapToTopicInvalidationMap(invalidation_map));
 
   logger_.OnInvalidation(invalidation_map);
 }

components/invalidation/impl/fcm_invalidation_service.h

@@ -7,8 +7,8 @@
 
 #include "base/macros.h"
 #include "base/timer/timer.h"
-#include "components/invalidation/impl/deprecated_invalidator_registrar.h"
 #include "components/invalidation/impl/invalidation_logger.h"
+#include "components/invalidation/impl/invalidator_registrar.h"
 #include "components/invalidation/public/identity_provider.h"
 #include "components/invalidation/public/invalidation_handler.h"
 #include "components/invalidation/public/invalidation_service.h"
@@ -87,7 +87,7 @@ class FCMInvalidationService : public InvalidationService,
   void StartInvalidator();
   void StopInvalidator();
 
-  syncer::DeprecatedInvalidatorRegistrar invalidator_registrar_;
+  syncer::InvalidatorRegistrar invalidator_registrar_;
   std::unique_ptr<syncer::Invalidator> invalidator_;
 
   // The invalidation logger object we use to record state changes

components/invalidation/impl/fcm_invalidation_service_unittest.cc

@@ -13,7 +13,7 @@
 #include "base/memory/weak_ptr.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
 #include "components/gcm_driver/gcm_driver.h"
-#include "components/invalidation/impl/fake_invalidator.h"
+#include "components/invalidation/impl/fcm_fake_invalidator.h"
 #include "components/invalidation/impl/gcm_invalidation_bridge.h"
 #include "components/invalidation/impl/invalidation_service_test_template.h"
 #include "components/invalidation/impl/invalidation_state_tracker.h"
@@ -50,7 +50,7 @@ class FCMInvalidationServiceTestDelegate {
   }
 
   void InitializeInvalidationService() {
-    fake_invalidator_ = new syncer::FakeInvalidator();
+    fake_invalidator_ = new syncer::FCMFakeInvalidator();
     invalidation_service_->InitForTest(fake_invalidator_);
   }
 
@@ -71,7 +71,7 @@ class FCMInvalidationServiceTestDelegate {
 
   identity::IdentityTestEnvironment identity_test_env_;
   std::unique_ptr<gcm::GCMDriver> gcm_driver_;
-  syncer::FakeInvalidator* fake_invalidator_;  // Owned by the service.
+  syncer::FCMFakeInvalidator* fake_invalidator_;  // Owned by the service.
   network::TestURLLoaderFactory url_loader_factory_;
 
   std::unique_ptr<FCMInvalidationService> invalidation_service_;

components/invalidation/impl/fcm_invalidator.cc

@@ -36,10 +36,16 @@ void FCMInvalidator::RegisterHandler(InvalidationHandler* handler) {
 
 bool FCMInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
                                          const ObjectIdSet& ids) {
-  if (!registrar_.UpdateRegisteredIds(handler, ids))
+  return UpdateRegisteredIds(handler, ConvertIdsToTopics(ids));
+}
+
+bool FCMInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
+                                         const TopicSet& topics) {
+  if (!registrar_.UpdateRegisteredTopics(handler, topics))
     return false;
 
-  invalidation_listener_.UpdateRegisteredIds(registrar_.GetAllRegisteredIds());
+  invalidation_listener_.UpdateRegisteredTopics(
+      registrar_.GetAllRegisteredIds());
   return true;
 }
 
@@ -57,7 +63,7 @@ InvalidatorState FCMInvalidator::GetInvalidatorState() const {
 }
 
 void FCMInvalidator::OnInvalidate(
-    const ObjectIdInvalidationMap& invalidation_map) {
+    const TopicInvalidationMap& invalidation_map) {
   registrar_.DispatchInvalidationsToHandlers(invalidation_map);
 }
 

components/invalidation/impl/fcm_invalidator.h

@@ -7,9 +7,9 @@
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "components/invalidation/impl/deprecated_invalidator_registrar.h"
 #include "components/invalidation/impl/fcm_sync_invalidation_listener.h"
 #include "components/invalidation/impl/invalidator.h"
+#include "components/invalidation/impl/invalidator_registrar.h"
 #include "components/invalidation/public/invalidator_state.h"
 #include "services/network/public/mojom/url_loader_factory.mojom.h"
 
@@ -40,6 +40,9 @@ class FCMInvalidator : public Invalidator,
   void RegisterHandler(InvalidationHandler* handler) override;
   bool UpdateRegisteredIds(InvalidationHandler* handler,
                            const ObjectIdSet& ids) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& topics) override;
+
   void UnregisterHandler(InvalidationHandler* handler) override;
   InvalidatorState GetInvalidatorState() const override;
   void UpdateCredentials(const std::string& email,
@@ -49,14 +52,14 @@ class FCMInvalidator : public Invalidator,
       const override;
 
   // SyncInvalidationListener::Delegate implementation.
-  void OnInvalidate(const ObjectIdInvalidationMap& invalidation_map) override;
+  void OnInvalidate(const TopicInvalidationMap& invalidation_map) override;
   void OnInvalidatorStateChange(InvalidatorState state) override;
 
  private:
   friend class FCMInvalidatorTestDelegate;
 
   bool is_started_ = false;
-  DeprecatedInvalidatorRegistrar registrar_;
+  InvalidatorRegistrar registrar_;
 
   // The invalidation listener.
   FCMSyncInvalidationListener invalidation_listener_;

components/invalidation/impl/fcm_invalidator_unittest.cc

@@ -16,6 +16,7 @@
 #include "components/invalidation/impl/per_user_topic_registration_manager.h"
 #include "components/invalidation/impl/profile_identity_provider.h"
 #include "components/invalidation/impl/push_client_channel.h"
+#include "components/invalidation/public/topic_invalidation_map.h"
 #include "components/prefs/testing_pref_service.h"
 #include "net/url_request/url_request_test_util.h"
 #include "services/identity/public/cpp/identity_test_environment.h"
@@ -64,7 +65,8 @@ class FCMInvalidatorTestDelegate {
 
   void TriggerOnIncomingInvalidation(
       const ObjectIdInvalidationMap& invalidation_map) {
-    invalidator_->OnInvalidate(invalidation_map);
+    invalidator_->OnInvalidate(
+        ConvertObjectIdInvalidationMapToTopicInvalidationMap(invalidation_map));
   }
 
  private:

components/invalidation/impl/fcm_sync_invalidation_listener.cc

@@ -11,42 +11,12 @@
 #include "components/invalidation/impl/per_user_topic_invalidation_client.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/invalidation/public/object_id_invalidation_map.h"
+#include "components/invalidation/public/topic_invalidation_map.h"
 #include "components/prefs/pref_service.h"
 #include "google/cacheinvalidation/include/types.h"
 
 namespace syncer {
 
-namespace {
-
-invalidation::ObjectId ConvertToObjectId(
-    const invalidation::InvalidationObjectId& invalidation_object_id) {
-  return invalidation::ObjectId(invalidation_object_id.source(),
-                                invalidation_object_id.name());
-}
-
-invalidation::InvalidationObjectId ConvertToInvalidationObjectId(
-    const invalidation::ObjectId& object_id) {
-  return invalidation::InvalidationObjectId(object_id.source(),
-                                            object_id.name());
-}
-
-ObjectIdSet ConvertToObjectIdSet(const InvalidationObjectIdSet& ids) {
-  ObjectIdSet object_ids;
-  for (const auto& id : ids)
-    object_ids.insert(ConvertToObjectId(id));
-  return object_ids;
-}
-
-InvalidationObjectIdSet ConvertToInvalidationObjectIdSet(
-    const ObjectIdSet& ids) {
-  InvalidationObjectIdSet invalidation_object_ids;
-  for (const auto& id : ids)
-    invalidation_object_ids.insert(ConvertToInvalidationObjectId(id));
-  return invalidation_object_ids;
-}
-
-}  // namespace
-
 FCMSyncInvalidationListener::Delegate::~Delegate() {}
 
 FCMSyncInvalidationListener::FCMSyncInvalidationListener(
@@ -81,8 +51,9 @@ void FCMSyncInvalidationListener::Start(
   invalidation_client_->Start();
 }
 
-void FCMSyncInvalidationListener::UpdateRegisteredIds(const ObjectIdSet& ids) {
-  registered_ids_ = ConvertToInvalidationObjectIdSet(ids);
+void FCMSyncInvalidationListener::UpdateRegisteredTopics(
+    const TopicSet& topics) {
+  registered_topics_ = topics;
   if (ticl_state_ == INVALIDATIONS_ENABLED &&
       per_user_topic_registration_manager_ && !token_.empty())
     DoRegistrationUpdate();
@@ -110,7 +81,7 @@ void FCMSyncInvalidationListener::Invalidate(
   DVLOG(2) << "Received invalidation with version " << invalidation.version()
            << " for " << ObjectIdToString(id);
 
-  ObjectIdInvalidationMap invalidations;
+  TopicInvalidationMap invalidations;
   Invalidation inv = Invalidation::Init(id, invalidation.version(), payload);
   inv.SetAckHandler(AsWeakPtr(), base::ThreadTaskRunnerHandle::Get());
   invalidations.Insert(inv);
@@ -124,7 +95,7 @@ void FCMSyncInvalidationListener::InvalidateUnknownVersion(
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateUnknownVersion";
 
-  ObjectIdInvalidationMap invalidations;
+  TopicInvalidationMap invalidations;
   Invalidation unknown_version = Invalidation::InitUnknownVersion(object_id);
   unknown_version.SetAckHandler(AsWeakPtr(),
                                 base::ThreadTaskRunnerHandle::Get());
@@ -139,10 +110,10 @@ void FCMSyncInvalidationListener::InvalidateAll(InvalidationClient* client) {
   DCHECK_EQ(client, invalidation_client_.get());
   DVLOG(1) << "InvalidateAll";
 
-  ObjectIdInvalidationMap invalidations;
-  for (const auto& registered_id : registered_ids_) {
-    Invalidation unknown_version =
-        Invalidation::InitUnknownVersion(ConvertToObjectId(registered_id));
+  TopicInvalidationMap invalidations;
+  for (const auto& registered_topic : registered_topics_) {
+    invalidation::ObjectId id(ConvertTopicToId(registered_topic));
+    Invalidation unknown_version = Invalidation::InitUnknownVersion(id);
     unknown_version.SetAckHandler(AsWeakPtr(),
                                   base::ThreadTaskRunnerHandle::Get());
     invalidations.Insert(unknown_version);
@@ -151,18 +122,18 @@ void FCMSyncInvalidationListener::InvalidateAll(InvalidationClient* client) {
 }
 
 void FCMSyncInvalidationListener::DispatchInvalidations(
-    const ObjectIdInvalidationMap& invalidations) {
-  ObjectIdInvalidationMap to_save = invalidations;
-  ObjectIdInvalidationMap to_emit = invalidations.GetSubsetWithObjectIds(
-      ConvertToObjectIdSet(registered_ids_));
+    const TopicInvalidationMap& invalidations) {
+  TopicInvalidationMap to_save = invalidations;
+  TopicInvalidationMap to_emit =
+      invalidations.GetSubsetWithTopics(registered_topics_);
 
   SaveInvalidations(to_save);
   EmitSavedInvalidations(to_emit);
 }
 
 void FCMSyncInvalidationListener::SaveInvalidations(
-    const ObjectIdInvalidationMap& to_save) {
-  ObjectIdSet objects_to_save = to_save.GetObjectIds();
+    const TopicInvalidationMap& to_save) {
+  ObjectIdSet objects_to_save = ConvertTopicsToIds(to_save.GetTopics());
   for (ObjectIdSet::const_iterator it = objects_to_save.begin();
        it != objects_to_save.end(); ++it) {
     UnackedInvalidationsMap::iterator lookup =
@@ -172,12 +143,12 @@ void FCMSyncInvalidationListener::SaveInvalidations(
                    .insert(std::make_pair(*it, UnackedInvalidationSet(*it)))
                    .first;
     }
-    lookup->second.AddSet(to_save.ForObject(*it));
+    lookup->second.AddSet(to_save.ForTopic((*it).name()));
   }
 }
 
 void FCMSyncInvalidationListener::EmitSavedInvalidations(
-    const ObjectIdInvalidationMap& to_emit) {
+    const TopicInvalidationMap& to_emit) {
   DVLOG(2) << "Emitting invalidations: " << to_emit.ToString();
   delegate_->OnInvalidate(to_emit);
 }
@@ -217,16 +188,17 @@ void FCMSyncInvalidationListener::Drop(const invalidation::ObjectId& id,
 }
 
 void FCMSyncInvalidationListener::DoRegistrationUpdate() {
-  per_user_topic_registration_manager_->UpdateRegisteredIds(registered_ids_,
-                                                            token_);
+  per_user_topic_registration_manager_->UpdateRegisteredTopics(
+      registered_topics_, token_);
 
   // TODO(melandory): remove unacked invalidations for unregistered objects.
   ObjectIdInvalidationMap object_id_invalidation_map;
   for (auto& unacked : unacked_invalidations_map_) {
-    if (registered_ids_.find(ConvertToInvalidationObjectId(unacked.first)) ==
-        registered_ids_.end()) {
+    if (registered_topics_.find(unacked.first.name()) ==
+        registered_topics_.end()) {
       continue;
     }
+
     unacked.second.ExportInvalidations(AsWeakPtr(),
                                        base::ThreadTaskRunnerHandle::Get(),
                                        &object_id_invalidation_map);
@@ -235,15 +207,16 @@ void FCMSyncInvalidationListener::DoRegistrationUpdate() {
   // There's no need to run these through DispatchInvalidations(); they've
   // already been saved to storage (that's where we found them) so all we need
   // to do now is emit them.
-  EmitSavedInvalidations(object_id_invalidation_map);
+  EmitSavedInvalidations(ConvertObjectIdInvalidationMapToTopicInvalidationMap(
+      object_id_invalidation_map));
 }
 
 void FCMSyncInvalidationListener::StopForTest() {
   Stop();
 }
 
-ObjectIdSet FCMSyncInvalidationListener::GetRegisteredIdsForTest() const {
-  return ConvertToObjectIdSet(registered_ids_);
+TopicSet FCMSyncInvalidationListener::GetRegisteredIdsForTest() const {
+  return registered_topics_;
 }
 
 base::WeakPtr<FCMSyncInvalidationListener>

components/invalidation/impl/fcm_sync_invalidation_listener.h

@@ -24,7 +24,7 @@
 
 namespace syncer {
 
-class ObjectIdInvalidationMap;
+class TopicInvalidationMap;
 
 // A simple wrapper around PerUserTopicInvalidationClient that
 // handles all the startup/shutdown details and hookups.
@@ -44,7 +44,7 @@ class FCMSyncInvalidationListener : public InvalidationListener,
    public:
     virtual ~Delegate();
 
-    virtual void OnInvalidate(const ObjectIdInvalidationMap& invalidations) = 0;
+    virtual void OnInvalidate(const TopicInvalidationMap& invalidations) = 0;
 
     virtual void OnInvalidatorStateChange(InvalidatorState state) = 0;
   };
@@ -62,7 +62,7 @@ class FCMSyncInvalidationListener : public InvalidationListener,
 
   // Update the set of object IDs that we're interested in getting
   // notifications for. May be called at any time.
-  void UpdateRegisteredIds(const ObjectIdSet& ids);
+  void UpdateRegisteredTopics(const TopicSet& topics);
 
   // InvalidationListener implementation.
   void Ready(InvalidationClient* client) override;
@@ -91,7 +91,7 @@ class FCMSyncInvalidationListener : public InvalidationListener,
 
   void StopForTest();
 
-  ObjectIdSet GetRegisteredIdsForTest() const;
+  TopicSet GetRegisteredIdsForTest() const;
 
   base::WeakPtr<FCMSyncInvalidationListener> AsWeakPtr();
 
@@ -109,16 +109,16 @@ class FCMSyncInvalidationListener : public InvalidationListener,
   //
   // If there are observers registered, they will be saved (to make sure we
   // don't drop them until they've been acted on) and emitted to the observers.
-  void DispatchInvalidations(const ObjectIdInvalidationMap& invalidations);
+  void DispatchInvalidations(const TopicInvalidationMap& invalidations);
 
   // Saves invalidations.
   //
   // This call isn't synchronous so we can't guarantee these invalidations will
   // be safely on disk by the end of the call, but it should ensure that the
   // data makes it to disk eventually.
-  void SaveInvalidations(const ObjectIdInvalidationMap& to_save);
+  void SaveInvalidations(const TopicInvalidationMap& to_save);
   // Emits previously saved invalidations to their registered observers.
-  void EmitSavedInvalidations(const ObjectIdInvalidationMap& to_emit);
+  void EmitSavedInvalidations(const TopicInvalidationMap& to_emit);
 
   // Generate a Dictionary with all the debugging information.
   std::unique_ptr<base::DictionaryValue> CollectDebugData() const;
@@ -130,7 +130,7 @@ class FCMSyncInvalidationListener : public InvalidationListener,
   std::unique_ptr<InvalidationClient> invalidation_client_;
 
   // Stored to pass to |per_user_topic_registration_manager_| on start.
-  InvalidationObjectIdSet registered_ids_;
+  TopicSet registered_topics_;
 
   // The states of the ticl and FCN channel.
   InvalidatorState ticl_state_;

components/invalidation/impl/invalidation_logger.cc

@@ -7,6 +7,7 @@
 #include "base/values.h"
 #include "components/invalidation/impl/invalidation_logger_observer.h"
 #include "components/invalidation/public/invalidation_handler.h"
+#include "components/invalidation/public/invalidation_util.h"
 
 namespace invalidation {
 class InvalidationLoggerObserver;
@@ -53,6 +54,15 @@ void InvalidationLogger::EmitState() {
   }
 }
 
+void InvalidationLogger::OnUpdateTopics(
+    std::map<std::string, syncer::TopicSet> updated_topics) {
+  for (const auto& updated_topic : updated_topics) {
+    latest_ids_[updated_topic.first] =
+        syncer::ConvertTopicsToIds(updated_topic.second);
+  }
+  EmitUpdatedIds();
+}
+
 void InvalidationLogger::OnUpdateIds(
     std::map<std::string, syncer::ObjectIdSet> updated_ids) {
   for (std::map<std::string, syncer::ObjectIdSet>::const_iterator it =

components/invalidation/impl/invalidation_logger.h

@@ -49,6 +49,7 @@ class InvalidationLogger {
   void OnUnregistration(const std::string& details);
   void OnStateChange(const syncer::InvalidatorState& new_state);
   void OnUpdateIds(std::map<std::string, syncer::ObjectIdSet> updated_ids);
+  void OnUpdateTopics(std::map<std::string, syncer::TopicSet> updated_topics);
   void OnDebugMessage(const base::DictionaryValue& details);
   void OnInvalidation(const syncer::ObjectIdInvalidationMap& details);
 

components/invalidation/impl/invalidation_notifier.cc

@@ -53,6 +53,12 @@ bool InvalidationNotifier::UpdateRegisteredIds(InvalidationHandler* handler,
   return true;
 }
 
+bool InvalidationNotifier::UpdateRegisteredIds(InvalidationHandler* handler,
+                                               const TopicSet& ids) {
+  NOTREACHED();
+  return false;
+}
+
 void InvalidationNotifier::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   registrar_.UnregisterHandler(handler);

components/invalidation/impl/invalidation_notifier.h

@@ -52,6 +52,8 @@ class INVALIDATION_EXPORT InvalidationNotifier
   void RegisterHandler(InvalidationHandler* handler) override;
   bool UpdateRegisteredIds(InvalidationHandler* handler,
                            const ObjectIdSet& ids) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& ids) override;
   void UnregisterHandler(InvalidationHandler* handler) override;
   InvalidatorState GetInvalidatorState() const override;
   void UpdateCredentials(const std::string& email,

components/invalidation/impl/invalidator.h

@@ -64,6 +64,12 @@ class INVALIDATION_EXPORT Invalidator {
                                    const ObjectIdSet& ids)
       WARN_UNUSED_RESULT = 0;
 
+  // Updates the set of ObjectIds associated with |handler|.  |handler| must
+  // not be NULL, and must already be registered.  An ID must be registered for
+  // at most one handler. If ID is already registered function returns false.
+  virtual bool UpdateRegisteredIds(InvalidationHandler* handler,
+                                   const TopicSet& ids) WARN_UNUSED_RESULT = 0;
+
   // Stops sending notifications to |handler|.  |handler| must not be NULL, and
   // it must already be registered.  Note that this doesn't unregister the IDs
   // associated with |handler|.

components/invalidation/impl/invalidator_registrar_unittest.cc

@@ -42,6 +42,12 @@ class RegistrarInvalidator : public Invalidator {
     return registrar_.UpdateRegisteredTopics(handler, topics);
   }
 
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& ids) override {
+    NOTREACHED();
+    return false;
+  }
+
   void UnregisterHandler(InvalidationHandler* handler) override {
     registrar_.UnregisterHandler(handler);
   }

components/invalidation/impl/non_blocking_invalidator.cc

@@ -273,6 +273,12 @@ bool NonBlockingInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
   return true;
 }
 
+bool NonBlockingInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
+                                                 const TopicSet& ids) {
+  NOTREACHED();
+  return false;
+}
+
 void NonBlockingInvalidator::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK(parent_task_runner_->BelongsToCurrentThread());
   registrar_.UnregisterHandler(handler);

components/invalidation/impl/non_blocking_invalidator.h

@@ -62,6 +62,8 @@ class INVALIDATION_EXPORT NonBlockingInvalidator
   void RegisterHandler(InvalidationHandler* handler) override;
   bool UpdateRegisteredIds(InvalidationHandler* handler,
                            const ObjectIdSet& ids) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& ids) override;
   void UnregisterHandler(InvalidationHandler* handler) override;
   InvalidatorState GetInvalidatorState() const override;
   void UpdateCredentials(const std::string& email,

components/invalidation/impl/p2p_invalidator.cc

@@ -180,6 +180,12 @@ bool P2PInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
   return true;
 }
 
+bool P2PInvalidator::UpdateRegisteredIds(InvalidationHandler* handler,
+                                         const TopicSet& ids) {
+  NOTREACHED();
+  return false;
+}
+
 void P2PInvalidator::UnregisterHandler(InvalidationHandler* handler) {
   DCHECK(thread_checker_.CalledOnValidThread());
   registrar_.UnregisterHandler(handler);

components/invalidation/impl/p2p_invalidator.h

@@ -104,6 +104,8 @@ class INVALIDATION_EXPORT P2PInvalidator : public Invalidator,
   void RegisterHandler(InvalidationHandler* handler) override;
   bool UpdateRegisteredIds(InvalidationHandler* handler,
                            const ObjectIdSet& ids) override;
+  bool UpdateRegisteredIds(InvalidationHandler* handler,
+                           const TopicSet& ids) override;
   void UnregisterHandler(InvalidationHandler* handler) override;
   InvalidatorState GetInvalidatorState() const override;
   void UpdateCredentials(const std::string& email,

components/invalidation/impl/per_user_topic_registration_manager.cc

@@ -18,7 +18,6 @@
 #include "base/strings/stringprintf.h"
 #include "components/gcm_driver/instance_id/instance_id_driver.h"
 #include "components/invalidation/public/identity_provider.h"
-#include "components/invalidation/public/invalidation_object_id.h"
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/prefs/pref_service.h"
@@ -40,7 +39,7 @@ const char kFCMOAuthScope[] =
     "https://www.googleapis.com/auth/firebase.messaging";
 
 using SubscriptionFinishedCallback =
-    base::OnceCallback<void(invalidation::InvalidationObjectId id,
+    base::OnceCallback<void(Topic id,
                             const Status& code,
                             const std::string& private_topic_name,
                             PerUserTopicRegistrationRequest::RequestType type)>;
@@ -80,7 +79,7 @@ void PerUserTopicRegistrationManager::RegisterProfilePrefs(
 }
 
 struct PerUserTopicRegistrationManager::RegistrationEntry {
-  RegistrationEntry(const invalidation::InvalidationObjectId& id,
+  RegistrationEntry(const Topic& id,
                     SubscriptionFinishedCallback completion_callback,
                     PerUserTopicRegistrationRequest::RequestType type);
   ~RegistrationEntry();
@@ -91,7 +90,7 @@ struct PerUserTopicRegistrationManager::RegistrationEntry {
   void DoRegister();
 
   // The object for which this is the status.
-  const invalidation::InvalidationObjectId id;
+  const Topic id;
   SubscriptionFinishedCallback completion_callback;
   PerUserTopicRegistrationRequest::RequestType type;
 
@@ -101,7 +100,7 @@ struct PerUserTopicRegistrationManager::RegistrationEntry {
 };
 
 PerUserTopicRegistrationManager::RegistrationEntry::RegistrationEntry(
-    const invalidation::InvalidationObjectId& id,
+    const Topic& id,
     SubscriptionFinishedCallback completion_callback,
     PerUserTopicRegistrationRequest::RequestType type)
     : id(id), completion_callback(std::move(completion_callback)), type(type) {}
@@ -134,18 +133,15 @@ void PerUserTopicRegistrationManager::Init() {
   std::vector<std::string> keys_to_remove;
   // Load registered ids from prefs.
   for (const auto& it : pref_data->DictItems()) {
-    std::string serialized_object_id = it.first;
-    invalidation::InvalidationObjectId object_id;
-    if (DeserializeInvalidationObjectId(serialized_object_id, &object_id)) {
-      std::string private_topic_name;
-      if (it.second.GetAsString(&private_topic_name) &&
-          !private_topic_name.empty()) {
-        registered_ids_[object_id] = private_topic_name;
-        continue;
+    Topic topic = it.first;
+    std::string private_topic_name;
+    if (it.second.GetAsString(&private_topic_name) &&
+        !private_topic_name.empty()) {
+      topic_to_private_topic_[topic] = private_topic_name;
+      continue;
       }
-    }
     // Remove saved pref.
-    keys_to_remove.push_back(serialized_object_id);
+      keys_to_remove.push_back(topic);
   }
 
   // Delete prefs, which weren't decoded successfully.
@@ -156,8 +152,8 @@ void PerUserTopicRegistrationManager::Init() {
   }
 }
 
-void PerUserTopicRegistrationManager::UpdateRegisteredIds(
-    const InvalidationObjectIdSet& ids,
+void PerUserTopicRegistrationManager::UpdateRegisteredTopics(
+    const TopicSet& ids,
     const std::string& instance_id_token) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   token_ = instance_id_token;
@@ -165,7 +161,7 @@ void PerUserTopicRegistrationManager::UpdateRegisteredIds(
   // should be re-requested.
   for (const auto& id : ids) {
     // If id isn't registered, schedule the registration.
-    if (registered_ids_.find(id) == registered_ids_.end()) {
+    if (topic_to_private_topic_.find(id) == topic_to_private_topic_.end()) {
       registration_statuses_[id] = std::make_unique<RegistrationEntry>(
           id,
           base::BindOnce(
@@ -177,8 +173,9 @@ void PerUserTopicRegistrationManager::UpdateRegisteredIds(
 
   // There is registered id, which need to be unregistered.
   // Schedule unregistration and immediately remove from
-  // |registered_ids_|
-  for (auto it = registered_ids_.begin(); it != registered_ids_.end();) {
+  // |topic_to_private_topic_|
+  for (auto it = topic_to_private_topic_.begin();
+       it != topic_to_private_topic_.end();) {
     auto id = it->first;
     if (ids.find(id) == ids.end()) {
       registration_statuses_[id] = std::make_unique<RegistrationEntry>(
@@ -187,7 +184,7 @@ void PerUserTopicRegistrationManager::UpdateRegisteredIds(
               &PerUserTopicRegistrationManager::RegistrationFinishedForId,
               base::Unretained(this)),
           PerUserTopicRegistrationRequest::UNSUBSCRIBE);
-      it = registered_ids_.erase(it);
+      it = topic_to_private_topic_.erase(it);
     } else {
       ++it;
     }
@@ -202,11 +199,10 @@ void PerUserTopicRegistrationManager::DoRegistrationUpdate() {
 }
 
 void PerUserTopicRegistrationManager::StartRegistrationRequest(
-    const invalidation::InvalidationObjectId& id) {
-  auto it = registration_statuses_.find(id);
+    const Topic& topic) {
+  auto it = registration_statuses_.find(topic);
   if (it == registration_statuses_.end()) {
-    NOTREACHED() << "StartRegistrationRequest called on "
-                 << InvalidationObjectIdToString(id)
+    NOTREACHED() << "StartRegistrationRequest called on " << topic
                  << " which is not in the registration map";
     return;
   }
@@ -214,7 +210,7 @@ void PerUserTopicRegistrationManager::StartRegistrationRequest(
 
   it->second->request = builder.SetToken(token_)
                             .SetScope(kInvalidationRegistrationScope)
-                            .SetPublicTopicName(id.name())
+                            .SetPublicTopicName(topic)
                             .SetAuthenticationHeader(base::StringPrintf(
                                 "Bearer %s", access_token_.c_str()))
                             .SetProjectId(kProjectId)
@@ -228,7 +224,7 @@ void PerUserTopicRegistrationManager::StartRegistrationRequest(
 }
 
 void PerUserTopicRegistrationManager::RegistrationFinishedForId(
-    invalidation::InvalidationObjectId id,
+    Topic id,
     const Status& code,
     const std::string& private_topic_name,
     PerUserTopicRegistrationRequest::RequestType type) {
@@ -236,16 +232,14 @@ void PerUserTopicRegistrationManager::RegistrationFinishedForId(
     auto it = registration_statuses_.find(id);
     registration_statuses_.erase(it);
     DictionaryPrefUpdate update(local_state_, kTypeRegisteredForInvalidation);
-    std::string serialized_object_id = SerializeInvalidationObjectId(id);
     switch (type) {
       case PerUserTopicRegistrationRequest::SUBSCRIBE: {
-        auto serialized_object_id = SerializeInvalidationObjectId(id);
-        update->SetKey(serialized_object_id, base::Value(private_topic_name));
-        registered_ids_[id] = private_topic_name;
+        update->SetKey(id, base::Value(private_topic_name));
+        topic_to_private_topic_[id] = private_topic_name;
         break;
       }
       case PerUserTopicRegistrationRequest::UNSUBSCRIBE: {
-        update->RemoveKey(serialized_object_id);
+        update->RemoveKey(id);
         break;
       }
     }
@@ -256,13 +250,12 @@ void PerUserTopicRegistrationManager::RegistrationFinishedForId(
   // in case of failure.
 }
 
-InvalidationObjectIdSet PerUserTopicRegistrationManager::GetRegisteredIds()
-    const {
-  InvalidationObjectIdSet ids;
-  for (const auto& id : registered_ids_)
-    ids.insert(id.first);
+TopicSet PerUserTopicRegistrationManager::GetRegisteredIds() const {
+  TopicSet topics;
+  for (const auto& t : topic_to_private_topic_)
+    topics.insert(t.first);
 
-  return ids;
+  return topics;
 }
 
 void PerUserTopicRegistrationManager::RequestAccessToken() {

components/invalidation/impl/per_user_topic_registration_manager.h

@@ -51,12 +51,12 @@ class INVALIDATION_EXPORT PerUserTopicRegistrationManager {
 
   static void RegisterProfilePrefs(PrefRegistrySimple* registry);
 
-  virtual void UpdateRegisteredIds(const InvalidationObjectIdSet& ids,
-                                   const std::string& token);
+  virtual void UpdateRegisteredTopics(const TopicSet& ids,
+                                      const std::string& token);
 
   virtual void Init();
 
-  InvalidationObjectIdSet GetRegisteredIds() const;
+  TopicSet GetRegisteredIds() const;
 
  private:
   struct RegistrationEntry;
@@ -64,10 +64,10 @@ class INVALIDATION_EXPORT PerUserTopicRegistrationManager {
   void DoRegistrationUpdate();
 
   // Tries to register |id|. No retry in case of failure.
-  void StartRegistrationRequest(const invalidation::InvalidationObjectId& id);
+  void StartRegistrationRequest(const Topic& id);
 
   void RegistrationFinishedForId(
-      invalidation::InvalidationObjectId id,
+      Topic id,
       const Status& code,
       const std::string& private_topic_name,
       PerUserTopicRegistrationRequest::RequestType type);
@@ -79,16 +79,10 @@ class INVALIDATION_EXPORT PerUserTopicRegistrationManager {
   void OnAccessTokenRequestSucceeded(std::string access_token);
   void OnAccessTokenRequestFailed(GoogleServiceAuthError error);
 
-  std::map<invalidation::InvalidationObjectId,
-           std::unique_ptr<RegistrationEntry>,
-           InvalidationObjectIdLessThan>
-      registration_statuses_;
+  std::map<Topic, std::unique_ptr<RegistrationEntry>> registration_statuses_;
 
   // For registered ids it maps the id value to the topic value.
-  std::map<invalidation::InvalidationObjectId,
-           std::string,
-           InvalidationObjectIdLessThan>
-      registered_ids_;
+  std::map<Topic, std::string> topic_to_private_topic_;
 
   // Token derrived from GCM IID.
   std::string token_;

components/invalidation/impl/per_user_topic_registration_manager_unittest.cc

@@ -34,21 +34,21 @@ const char kTypeRegisteredForInvalidation[] =
 
 const char kFakeInstanceIdToken[] = "fake_instance_id_token";
 
-invalidation::InvalidationObjectId GetIdForIndex(size_t index) {
+std::string IndexToName(size_t index) {
   char name[2] = "a";
   name[0] += static_cast<char>(index);
-  return invalidation::InvalidationObjectId(1 + index, name);
+  return name;
 }
 
-InvalidationObjectIdSet GetSequenceOfIdsStartingAt(size_t start, size_t count) {
-  InvalidationObjectIdSet ids;
+TopicSet GetSequenceOfTopicsStartingAt(size_t start, size_t count) {
+  TopicSet ids;
   for (size_t i = start; i < start + count; ++i)
-    ids.insert(GetIdForIndex(i));
+    ids.insert(IndexToName(i));
   return ids;
 }
 
-InvalidationObjectIdSet GetSequenceOfIds(size_t count) {
-  return GetSequenceOfIdsStartingAt(0, count);
+TopicSet GetSequenceOfTopics(size_t count) {
+  return GetSequenceOfTopicsStartingAt(0, count);
 }
 
 network::ResourceResponseHead CreateHeadersForTest(int responce_code) {
@@ -142,8 +142,8 @@ class PerUserTopicRegistrationManagerTest : public testing::Test {
 };
 
 TEST_F(PerUserTopicRegistrationManagerTest,
-       EmptyPrivateTopicShouldNotUpdateRegisteredIds) {
-  InvalidationObjectIdSet ids = GetSequenceOfIds(kInvalidationObjectIdsCount);
+       EmptyPrivateTopicShouldNotUpdateRegisteredTopics) {
+  TopicSet ids = GetSequenceOfTopics(kInvalidationObjectIdsCount);
 
   auto per_user_topic_registration_manager = BuildRegistrationManager();
 
@@ -156,7 +156,7 @@ TEST_F(PerUserTopicRegistrationManagerTest,
       FullSubscriptionUrl(), CreateHeadersForTest(net::HTTP_OK), response_body,
       CreateStatusForTest(net::OK, response_body));
 
-  per_user_topic_registration_manager->UpdateRegisteredIds(
+  per_user_topic_registration_manager->UpdateRegisteredTopics(
       ids, kFakeInstanceIdToken);
   base::RunLoop().RunUntilIdle();
 
@@ -165,8 +165,8 @@ TEST_F(PerUserTopicRegistrationManagerTest,
   EXPECT_TRUE(per_user_topic_registration_manager->GetRegisteredIds().empty());
 }
 
-TEST_F(PerUserTopicRegistrationManagerTest, ShouldUpdateRegisteredIds) {
-  InvalidationObjectIdSet ids = GetSequenceOfIds(kInvalidationObjectIdsCount);
+TEST_F(PerUserTopicRegistrationManagerTest, ShouldUpdateRegisteredTopics) {
+  TopicSet ids = GetSequenceOfTopics(kInvalidationObjectIdsCount);
 
   auto per_user_topic_registration_manager = BuildRegistrationManager();
 
@@ -174,7 +174,7 @@ TEST_F(PerUserTopicRegistrationManagerTest, ShouldUpdateRegisteredIds) {
 
   AddCorrectSubscriptionResponce();
 
-  per_user_topic_registration_manager->UpdateRegisteredIds(
+  per_user_topic_registration_manager->UpdateRegisteredTopics(
       ids, kFakeInstanceIdToken);
   base::RunLoop().RunUntilIdle();
 
@@ -183,34 +183,34 @@ TEST_F(PerUserTopicRegistrationManagerTest, ShouldUpdateRegisteredIds) {
   for (const auto& id : ids) {
     const base::DictionaryValue* topics =
         pref_service()->GetDictionary(kTypeRegisteredForInvalidation);
-    const base::Value* private_topic_value = topics->FindKeyOfType(
-        SerializeInvalidationObjectId(id), base::Value::Type::STRING);
+    const base::Value* private_topic_value =
+        topics->FindKeyOfType(id, base::Value::Type::STRING);
     ASSERT_NE(private_topic_value, nullptr);
   }
 }
 
 TEST_F(PerUserTopicRegistrationManagerTest,
        ShouldDisableIdsAndDeleteFromPrefs) {
-  InvalidationObjectIdSet ids = GetSequenceOfIds(kInvalidationObjectIdsCount);
+  TopicSet ids = GetSequenceOfTopics(kInvalidationObjectIdsCount);
 
   AddCorrectSubscriptionResponce();
 
   auto per_user_topic_registration_manager = BuildRegistrationManager();
   EXPECT_TRUE(per_user_topic_registration_manager->GetRegisteredIds().empty());
 
-  per_user_topic_registration_manager->UpdateRegisteredIds(
+  per_user_topic_registration_manager->UpdateRegisteredTopics(
       ids, kFakeInstanceIdToken);
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ids, per_user_topic_registration_manager->GetRegisteredIds());
 
   // Disable some ids.
-  InvalidationObjectIdSet disabled_ids = GetSequenceOfIds(3);
-  InvalidationObjectIdSet enabled_ids =
-      GetSequenceOfIdsStartingAt(3, kInvalidationObjectIdsCount - 3);
+  TopicSet disabled_ids = GetSequenceOfTopics(3);
+  TopicSet enabled_ids =
+      GetSequenceOfTopicsStartingAt(3, kInvalidationObjectIdsCount - 3);
   for (const auto& id : disabled_ids)
-    AddCorrectUnSubscriptionResponceForTopic(id.name());
+    AddCorrectUnSubscriptionResponceForTopic(id);
 
-  per_user_topic_registration_manager->UpdateRegisteredIds(
+  per_user_topic_registration_manager->UpdateRegisteredTopics(
       enabled_ids, kFakeInstanceIdToken);
   base::RunLoop().RunUntilIdle();
 
@@ -218,8 +218,7 @@ TEST_F(PerUserTopicRegistrationManagerTest,
   for (const auto& id : disabled_ids) {
     const base::DictionaryValue* topics =
         pref_service()->GetDictionary(kTypeRegisteredForInvalidation);
-    const base::Value* private_topic_value =
-        topics->FindKey(SerializeInvalidationObjectId(id));
+    const base::Value* private_topic_value = topics->FindKey(id);
     ASSERT_EQ(private_topic_value, nullptr);
   }
 
@@ -227,8 +226,8 @@ TEST_F(PerUserTopicRegistrationManagerTest,
   for (const auto& id : enabled_ids) {
     const base::DictionaryValue* topics =
         pref_service()->GetDictionary(kTypeRegisteredForInvalidation);
-    const base::Value* private_topic_value = topics->FindKeyOfType(
-        SerializeInvalidationObjectId(id), base::Value::Type::STRING);
+    const base::Value* private_topic_value =
+        topics->FindKeyOfType(id, base::Value::Type::STRING);
     ASSERT_NE(private_topic_value, nullptr);
   }
 }

components/invalidation/public/invalidation_util.cc

@@ -21,6 +21,8 @@ namespace {
 const char kSourceKey[] = "source";
 const char kNameKey[] = "name";
 
+const int kDeprecatedSource = 2000;
+
 }  // namespace
 
 namespace syncer {
@@ -136,4 +138,22 @@ std::string InvalidationObjectIdToString(
   return str;
 }
 
+TopicSet ConvertIdsToTopics(ObjectIdSet ids) {
+  TopicSet topics;
+  for (const auto& id : ids)
+    topics.insert(id.name());
+  return topics;
+}
+
+ObjectIdSet ConvertTopicsToIds(TopicSet topics) {
+  ObjectIdSet ids;
+  for (const auto& topic : topics)
+    ids.insert(invalidation::ObjectId(kDeprecatedSource, topic));
+  return ids;
+}
+
+invalidation::ObjectId ConvertTopicToId(const Topic& topic) {
+  return invalidation::ObjectId(kDeprecatedSource, topic);
+}
+
 }  // namespace syncer

components/invalidation/public/invalidation_util.h

@@ -91,6 +91,10 @@ bool DeserializeInvalidationObjectId(const std::string& serialized,
 INVALIDATION_EXPORT std::string InvalidationObjectIdToString(
     const invalidation::InvalidationObjectId& object_id);
 
+TopicSet ConvertIdsToTopics(ObjectIdSet ids);
+ObjectIdSet ConvertTopicsToIds(TopicSet topics);
+invalidation::ObjectId ConvertTopicToId(const Topic& topic);
+
 }  // namespace syncer
 
 #endif  // COMPONENTS_INVALIDATION_PUBLIC_INVALIDATION_UTIL_H_

components/invalidation/public/topic_invalidation_map.cc

@@ -7,6 +7,7 @@
 #include <stddef.h>
 
 #include "base/json/json_string_value_serializer.h"
+#include "components/invalidation/public/object_id_invalidation_map.h"
 
 namespace syncer {
 
@@ -114,4 +115,15 @@ std::string TopicInvalidationMap::ToString() const {
 TopicInvalidationMap::TopicInvalidationMap(const TopicToListMap& map)
     : map_(map) {}
 
+TopicInvalidationMap ConvertObjectIdInvalidationMapToTopicInvalidationMap(
+    ObjectIdInvalidationMap object_ids_map) {
+  TopicInvalidationMap topics_map;
+  std::vector<Invalidation> invalidations;
+  object_ids_map.GetAllInvalidations(&invalidations);
+  for (const auto& invalidation : invalidations) {
+    topics_map.Insert(invalidation);
+  }
+  return topics_map;
+}
+
 }  // namespace syncer

components/invalidation/public/topic_invalidation_map.h

@@ -15,6 +15,7 @@
 #include "components/invalidation/public/single_object_invalidation_set.h"
 
 namespace syncer {
+class ObjectIdInvalidationMap;
 
 // A set of notifications with some helper methods to organize them by object ID
 // and version number.
@@ -66,6 +67,9 @@ class INVALIDATION_EXPORT TopicInvalidationMap {
   TopicToListMap map_;
 };
 
+TopicInvalidationMap ConvertObjectIdInvalidationMapToTopicInvalidationMap(
+    ObjectIdInvalidationMap object_ids_map);
+
 }  // namespace syncer
 
 #endif  // COMPONENTS_INVALIDATION_PUBLIC_TOPIC_INVALIDATION_MAP_H_