[Invalidations] Remove remaining ObjectID usages

This CL removes remaining ObjectID usages (mostly in
components/invalidation) from C++ codebase. Cleaning up
the dependencies on cacheinvalidation outside of
components/invalidation will be done in follow up patches.

Tbr: fukino@chromium.org
Bug: 1029698
Change-Id: Ib6b2aa064be72f35c9ddef191a7471e194090588
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2087338
Commit-Queue: Maksim Moskvitin <mmoskvitin@google.com>
Auto-Submit: Maksim Moskvitin <mmoskvitin@google.com>
Reviewed-by: Marc Treib <treib@chromium.org>
Cr-Commit-Position: refs/heads/master@{#748198}

components/drive/drive_notification_manager.cc

@@ -244,7 +244,6 @@ void DriveNotificationManager::UpdateRegisteredDriveNotifications() {
     return;
 
   syncer::TopicSet topics;
-  syncer::ObjectIdSet ids;
   topics.insert(GetDriveInvalidationTopic());
 
   for (const auto& team_drive_id : team_drive_ids_) {

components/invalidation/DEPS

@@ -3,7 +3,6 @@ include_rules = [
   "-content",
   "-components/invalidation",
   "+components/prefs",
-  "+google/cacheinvalidation",
   "+google_apis/gaia",
   "+mojo/public",
 ]

components/invalidation/impl/BUILD.gn

@@ -137,10 +137,7 @@ static_library("test_support") {
     "topic_invalidation_map_test_util.h",
   ]
 
-  public_deps = [
-    ":impl",
-    "//third_party/cacheinvalidation",
-  ]
+  public_deps = [ ":impl" ]
   deps = [
     "//base",
     "//components/gcm_driver:test_support",

components/invalidation/impl/fake_invalidation_service.cc

@@ -78,8 +78,7 @@ void FakeInvalidationService::EmitInvalidationForTest(
   // If no one is listening to this invalidation, do not send it out.
   syncer::Topics subscribed_topics =
       invalidator_registrar_->GetAllSubscribedTopics();
-  if (subscribed_topics.find(invalidation.object_id().name()) ==
-      subscribed_topics.end()) {
+  if (subscribed_topics.find(invalidation.topic()) == subscribed_topics.end()) {
     mock_ack_handler_.RegisterUnsentInvalidation(&invalidation_copy);
     return;
   }

components/invalidation/impl/fcm_invalidation_listener.cc

@@ -10,7 +10,6 @@
 #include "components/invalidation/public/invalidation_util.h"
 #include "components/invalidation/public/topic_invalidation_map.h"
 #include "components/prefs/pref_service.h"
-#include "google/cacheinvalidation/include/types.h"
 
 namespace syncer {
 
@@ -79,8 +78,8 @@ void FCMInvalidationListener::InvalidationReceived(
     return;
   }
   TopicInvalidationMap invalidations;
-  Invalidation inv = Invalidation::Init(
-      ConvertTopicToId(*expected_public_topic), version, payload);
+  Invalidation inv =
+      Invalidation::Init(*expected_public_topic, version, payload);
   inv.SetAckHandler(weak_factory_.GetWeakPtr(),
                     base::ThreadTaskRunnerHandle::Get());
   DVLOG(1) << "Received invalidation with version " << inv.version() << " for "

components/invalidation/impl/fcm_invalidation_listener_unittest.cc

@@ -337,9 +337,8 @@ TEST_F(FCMInvalidationListenerTest, ManyInvalidations_NoDrop) {
   EXPECT_EQ(initial_version + kRepeatCount - 1, GetVersion(topic));
 }
 
-// Fire an invalidation for an unregistered object topic with a payload.  It
-// should still be processed, and both the payload and the version should be
-// updated.
+// Fire an invalidation for an unregistered topic with a payload. It should
+// still be processed, and both the payload and the version should be updated.
 TEST_F(FCMInvalidationListenerTest, InvalidateBeforeRegistration_Simple) {
   const Topic kUnregisteredId = "unregistered";
   const Topic& topic = kUnregisteredId;
@@ -361,7 +360,7 @@ TEST_F(FCMInvalidationListenerTest, InvalidateBeforeRegistration_Simple) {
   EXPECT_EQ(kPayload1, GetPayload(topic));
 }
 
-// Fire ten invalidations before an object registers.  Some invalidations will
+// Fire ten invalidations before an topics registers.  Some invalidations will
 // be dropped an replaced with an unknown version invalidation.
 TEST_F(FCMInvalidationListenerTest, InvalidateBeforeRegistration_Drop) {
   const int kRepeatCount =

components/invalidation/impl/invalidation_logger.h

@@ -81,8 +81,8 @@ class InvalidationLogger {
   syncer::InvalidatorState last_invalidator_state_;
   base::Time last_invalidator_state_timestamp_;
 
-  // The map that contains every object id that is currently registered
-  // and its owner.
+  // The map that contains every topic that is currently registered and its
+  // owner.
   std::map<std::string, syncer::Topics> handler_latest_topics_map_;
 
   // The map that counts how many invalidations per Topic there has been.

components/invalidation/impl/invalidation_logger_unittest.cc

@@ -154,10 +154,10 @@ TEST(InvalidationLoggerTest, TestEmitContent) {
   log.UnregisterObserver(&observer_test);
 }
 
-// Test that the updateId notification actually sends the same ObjectId that
-// was sent to the Observer.
+// Test that the OnUpdatedTopics() notification actually sends the same Topic
+// that was sent to the Observer.
 // The ObserverTest rebuilds the map that was sent in pieces by the logger.
-TEST(InvalidationLoggerTest, TestUpdateIdsMap) {
+TEST(InvalidationLoggerTest, TestUpdatedTopicsMap) {
   InvalidationLogger log;
   InvalidationLoggerObserverTest observer_test;
   std::map<std::string, syncer::Topics> send_test_map;

components/invalidation/impl/invalidation_service_test_template.h

@@ -153,7 +153,7 @@ TYPED_TEST_P(InvalidationServiceTest, Basic) {
   expected_invalidations.Insert(
       syncer::Invalidation::Init(this->topic3, 3, "3"));
 
-  // Removed object IDs should not be notified, newly-added ones should.
+  // Removed Topics 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()));
@@ -269,8 +269,8 @@ TYPED_TEST_P(InvalidationServiceTest, MultipleHandlers) {
   invalidator->UnregisterInvalidationHandler(&handler1);
 }
 
-// Multiple registrations by different handlers on the same object ID should
-// return false.
+// Multiple registrations by different handlers on the same Topic should return
+// false.
 TYPED_TEST_P(InvalidationServiceTest, MultipleRegistrations) {
   invalidation::InvalidationService* const invalidator =
       this->CreateAndInitializeInvalidationService();

components/invalidation/impl/invalidation_test_util.cc

@@ -74,7 +74,7 @@ InvalidationEqMatcher::InvalidationEqMatcher(const Invalidation& expected)
 bool InvalidationEqMatcher::MatchAndExplain(
     const Invalidation& actual,
     MatchResultListener* listener) const {
-  if (!(expected_.object_id() == actual.object_id()))
+  if (expected_.topic() != actual.topic())
     return false;
   if (expected_.is_unknown_version() && actual.is_unknown_version())
     return true;

components/invalidation/impl/invalidator_registrar_with_memory_unittest.cc

@@ -13,23 +13,30 @@
 #include "components/invalidation/public/invalidator_state.h"
 #include "components/invalidation/public/topic_invalidation_map.h"
 #include "components/prefs/testing_pref_service.h"
-#include "google/cacheinvalidation/include/types.h"
-#include "google/cacheinvalidation/types.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
+Topics TopicSetToTopics(const TopicSet& topic_set,
+                        InvalidationHandler* handler) {
+  DCHECK(handler);
+  Topics result;
+  for (const Topic& topic : topic_set) {
+    result.emplace(topic, TopicMetadata{handler->IsPublicTopic(topic)});
+  }
+  return result;
+}
+
 // Initialize the invalidator, register a handler, register some topics for that
 // handler, and then unregister the handler, dispatching invalidations in
 // between. The handler should only see invalidations when it's registered and
 // its topics are registered.
 TEST(InvalidatorRegistrarWithMemoryTest, Basic) {
-  const invalidation::ObjectId id1(ipc::invalidation::ObjectSource::TEST, "a");
-  const invalidation::ObjectId id2(ipc::invalidation::ObjectSource::TEST, "b");
-  const invalidation::ObjectId id3(ipc::invalidation::ObjectSource::TEST, "c");
-  const invalidation::ObjectId id4(ipc::invalidation::ObjectSource::TEST, "d");
+  const Topic kTopic1 = "a";
+  const Topic kTopic2 = "b";
+  const Topic kTopic3 = "c";
 
   TestingPrefServiceSimple pref_service;
   InvalidatorRegistrarWithMemory::RegisterProfilePrefs(pref_service.registry());
@@ -41,35 +48,35 @@ TEST(InvalidatorRegistrarWithMemoryTest, Basic) {
   invalidator->RegisterHandler(&handler);
 
   TopicInvalidationMap invalidation_map;
-  invalidation_map.Insert(Invalidation::Init(id1, 1, "1"));
-  invalidation_map.Insert(Invalidation::Init(id2, 2, "2"));
-  invalidation_map.Insert(Invalidation::Init(id3, 3, "3"));
+  invalidation_map.Insert(Invalidation::Init(kTopic1, 1, "1"));
+  invalidation_map.Insert(Invalidation::Init(kTopic2, 2, "2"));
+  invalidation_map.Insert(Invalidation::Init(kTopic3, 3, "3"));
 
   // Should be ignored since no topics are registered to |handler|.
   invalidator->DispatchInvalidationsToHandlers(invalidation_map);
   EXPECT_EQ(0, handler.GetInvalidationCount());
 
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler, ConvertIdsToTopics({id1, id2}, &handler)));
+      &handler, TopicSetToTopics({kTopic1, kTopic2}, &handler)));
 
   invalidator->UpdateInvalidatorState(INVALIDATIONS_ENABLED);
   EXPECT_EQ(INVALIDATIONS_ENABLED, handler.GetInvalidatorState());
 
   TopicInvalidationMap expected_invalidations;
-  expected_invalidations.Insert(Invalidation::Init(id1, 1, "1"));
-  expected_invalidations.Insert(Invalidation::Init(id2, 2, "2"));
+  expected_invalidations.Insert(Invalidation::Init(kTopic1, 1, "1"));
+  expected_invalidations.Insert(Invalidation::Init(kTopic2, 2, "2"));
 
   invalidator->DispatchInvalidationsToHandlers(invalidation_map);
   EXPECT_EQ(1, handler.GetInvalidationCount());
   EXPECT_EQ(expected_invalidations, handler.GetLastInvalidationMap());
 
-  // Remove id1, add id3.
+  // Remove kTopic1, add kTopic3.
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler, ConvertIdsToTopics({id2, id3}, &handler)));
+      &handler, TopicSetToTopics({kTopic2, kTopic3}, &handler)));
 
   expected_invalidations = TopicInvalidationMap();
-  expected_invalidations.Insert(Invalidation::Init(id2, 2, "2"));
-  expected_invalidations.Insert(Invalidation::Init(id3, 3, "3"));
+  expected_invalidations.Insert(Invalidation::Init(kTopic2, 2, "2"));
+  expected_invalidations.Insert(Invalidation::Init(kTopic3, 3, "3"));
 
   // Removed topic should not be notified, newly-added ones should.
   invalidator->DispatchInvalidationsToHandlers(invalidation_map);
@@ -95,10 +102,10 @@ TEST(InvalidatorRegistrarWithMemoryTest, Basic) {
 // invalidations, and the ones that have registered topics should receive
 // invalidations for those topics.
 TEST(InvalidatorRegistrarWithMemoryTest, MultipleHandlers) {
-  const invalidation::ObjectId id1(ipc::invalidation::ObjectSource::TEST, "a");
-  const invalidation::ObjectId id2(ipc::invalidation::ObjectSource::TEST, "b");
-  const invalidation::ObjectId id3(ipc::invalidation::ObjectSource::TEST, "c");
-  const invalidation::ObjectId id4(ipc::invalidation::ObjectSource::TEST, "d");
+  const Topic kTopic1 = "a";
+  const Topic kTopic2 = "b";
+  const Topic kTopic3 = "c";
+  const Topic kTopic4 = "d";
 
   TestingPrefServiceSimple pref_service;
   InvalidatorRegistrarWithMemory::RegisterProfilePrefs(pref_service.registry());
@@ -117,12 +124,12 @@ TEST(InvalidatorRegistrarWithMemoryTest, MultipleHandlers) {
   invalidator->RegisterHandler(&handler4);
 
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler1, ConvertIdsToTopics({id1, id2}, &handler1)));
+      &handler1, TopicSetToTopics({kTopic1, kTopic2}, &handler1)));
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler2, ConvertIdsToTopics({id3}, &handler2)));
+      &handler2, TopicSetToTopics({kTopic3}, &handler2)));
   // Don't register any IDs for handler3.
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler4, ConvertIdsToTopics({id4}, &handler4)));
+      &handler4, TopicSetToTopics({kTopic4}, &handler4)));
 
   invalidator->UnregisterHandler(&handler4);
 
@@ -133,22 +140,22 @@ TEST(InvalidatorRegistrarWithMemoryTest, MultipleHandlers) {
   EXPECT_EQ(TRANSIENT_INVALIDATION_ERROR, handler4.GetInvalidatorState());
 
   TopicInvalidationMap invalidation_map;
-  invalidation_map.Insert(Invalidation::Init(id1, 1, "1"));
-  invalidation_map.Insert(Invalidation::Init(id2, 2, "2"));
-  invalidation_map.Insert(Invalidation::Init(id3, 3, "3"));
-  invalidation_map.Insert(Invalidation::Init(id4, 4, "4"));
+  invalidation_map.Insert(Invalidation::Init(kTopic1, 1, "1"));
+  invalidation_map.Insert(Invalidation::Init(kTopic2, 2, "2"));
+  invalidation_map.Insert(Invalidation::Init(kTopic3, 3, "3"));
+  invalidation_map.Insert(Invalidation::Init(kTopic4, 4, "4"));
 
   invalidator->DispatchInvalidationsToHandlers(invalidation_map);
 
   TopicInvalidationMap expected_invalidations1;
-  expected_invalidations1.Insert(Invalidation::Init(id1, 1, "1"));
-  expected_invalidations1.Insert(Invalidation::Init(id2, 2, "2"));
+  expected_invalidations1.Insert(Invalidation::Init(kTopic1, 1, "1"));
+  expected_invalidations1.Insert(Invalidation::Init(kTopic2, 2, "2"));
 
   EXPECT_EQ(1, handler1.GetInvalidationCount());
   EXPECT_EQ(expected_invalidations1, handler1.GetLastInvalidationMap());
 
   TopicInvalidationMap expected_invalidations2;
-  expected_invalidations2.Insert(Invalidation::Init(id3, 3, "3"));
+  expected_invalidations2.Insert(Invalidation::Init(kTopic3, 3, "3"));
 
   EXPECT_EQ(1, handler2.GetInvalidationCount());
   EXPECT_EQ(expected_invalidations2, handler2.GetLastInvalidationMap());
@@ -170,7 +177,7 @@ TEST(InvalidatorRegistrarWithMemoryTest, MultipleHandlers) {
 // Multiple registrations by different handlers on the same topic should
 // return false.
 TEST(InvalidatorRegistrarWithMemoryTest, MultipleRegistrations) {
-  const invalidation::ObjectId id1(ipc::invalidation::ObjectSource::TEST, "a");
+  const Topic kTopic1 = "a";
 
   TestingPrefServiceSimple pref_service;
   InvalidatorRegistrarWithMemory::RegisterProfilePrefs(pref_service.registry());
@@ -187,9 +194,9 @@ TEST(InvalidatorRegistrarWithMemoryTest, MultipleRegistrations) {
   // Registering both handlers for the same topic. First call should succeed,
   // second should fail.
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler1, ConvertIdsToTopics({id1}, &handler1)));
+      &handler1, TopicSetToTopics({kTopic1}, &handler1)));
   EXPECT_FALSE(invalidator->UpdateRegisteredTopics(
-      &handler2, ConvertIdsToTopics({id1}, &handler2)));
+      &handler2, TopicSetToTopics({kTopic1}, &handler2)));
 
   // |handler1| should still own subscription to the topic and deregistration
   // of its topics should update subscriptions.
@@ -203,9 +210,9 @@ TEST(InvalidatorRegistrarWithMemoryTest, MultipleRegistrations) {
 // Make sure that passing an empty set to UpdateRegisteredTopics clears the
 // corresponding entries for the handler.
 TEST(InvalidatorRegistrarWithMemoryTest, EmptySetUnregisters) {
-  const invalidation::ObjectId id1(ipc::invalidation::ObjectSource::TEST, "a");
-  const invalidation::ObjectId id2(ipc::invalidation::ObjectSource::TEST, "b");
-  const invalidation::ObjectId id3(ipc::invalidation::ObjectSource::TEST, "c");
+  const Topic kTopic1 = "a";
+  const Topic kTopic2 = "b";
+  const Topic kTopic3 = "c";
 
   TestingPrefServiceSimple pref_service;
   InvalidatorRegistrarWithMemory::RegisterProfilePrefs(pref_service.registry());
@@ -222,9 +229,9 @@ TEST(InvalidatorRegistrarWithMemoryTest, EmptySetUnregisters) {
   invalidator->RegisterHandler(&handler2);
 
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler1, ConvertIdsToTopics({id1, id2}, &handler1)));
+      &handler1, TopicSetToTopics({kTopic1, kTopic2}, &handler1)));
   EXPECT_TRUE(invalidator->UpdateRegisteredTopics(
-      &handler2, ConvertIdsToTopics({id3}, &handler2)));
+      &handler2, TopicSetToTopics({kTopic3}, &handler2)));
 
   // Unregister the topics for the first observer. It should not receive any
   // further invalidations.
@@ -236,9 +243,9 @@ TEST(InvalidatorRegistrarWithMemoryTest, EmptySetUnregisters) {
 
   {
     TopicInvalidationMap invalidation_map;
-    invalidation_map.Insert(Invalidation::Init(id1, 1, "1"));
-    invalidation_map.Insert(Invalidation::Init(id2, 2, "2"));
-    invalidation_map.Insert(Invalidation::Init(id3, 3, "3"));
+    invalidation_map.Insert(Invalidation::Init(kTopic1, 1, "1"));
+    invalidation_map.Insert(Invalidation::Init(kTopic2, 2, "2"));
+    invalidation_map.Insert(Invalidation::Init(kTopic3, 3, "3"));
     invalidator->DispatchInvalidationsToHandlers(invalidation_map);
     EXPECT_EQ(0, handler1.GetInvalidationCount());
     EXPECT_EQ(1, handler2.GetInvalidationCount());

components/invalidation/impl/single_object_invalidation_set_unittest.cc

@@ -7,7 +7,6 @@
 #include <memory>
 
 #include "components/invalidation/impl/invalidation_test_util.h"
-#include "google/cacheinvalidation/types.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
@@ -16,20 +15,19 @@ namespace {
 
 class SingleObjectInvalidationSetTest : public testing::Test {
  public:
-  SingleObjectInvalidationSetTest()
-      : kId(ipc::invalidation::ObjectSource::TEST, "one") {
-  }
+  SingleObjectInvalidationSetTest() = default;
+
  protected:
-  const invalidation::ObjectId kId;
+  const Topic kTopic = "one";
 };
 
 TEST_F(SingleObjectInvalidationSetTest, InsertionAndOrdering) {
   SingleObjectInvalidationSet l1;
   SingleObjectInvalidationSet l2;
 
-  Invalidation inv0 = Invalidation::InitUnknownVersion(kId);
-  Invalidation inv1 = Invalidation::Init(kId, 1, "one");
-  Invalidation inv2 = Invalidation::Init(kId, 5, "five");
+  Invalidation inv0 = Invalidation::InitUnknownVersion(kTopic);
+  Invalidation inv1 = Invalidation::Init(kTopic, 1, "one");
+  Invalidation inv2 = Invalidation::Init(kTopic, 5, "five");
 
   l1.Insert(inv0);
   l1.Insert(inv1);
@@ -64,10 +62,10 @@ TEST_F(SingleObjectInvalidationSetTest, StartWithUnknownVersion) {
   SingleObjectInvalidationSet list;
   EXPECT_FALSE(list.StartsWithUnknownVersion());
 
-  list.Insert(Invalidation::Init(kId, 1, "one"));
+  list.Insert(Invalidation::Init(kTopic, 1, "one"));
   EXPECT_FALSE(list.StartsWithUnknownVersion());
 
-  list.Insert(Invalidation::InitUnknownVersion(kId));
+  list.Insert(Invalidation::InitUnknownVersion(kTopic));
   EXPECT_TRUE(list.StartsWithUnknownVersion());
 
   list.Clear();

components/invalidation/impl/topic_invalidation_map_unittest.cc

@@ -6,7 +6,6 @@
 
 #include <memory>
 
-#include "google/cacheinvalidation/types.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {

components/invalidation/impl/unacked_invalidation_set.cc

@@ -120,10 +120,10 @@ void UnackedInvalidationSet::Truncate(size_t max_size) {
   // amount of information has been lost by ensuring this list begins with
   // an UnknownVersion invalidation.  We remove the oldest remaining
   // invalidation to make room for it.
-  invalidation::ObjectId id = invalidations_.begin()->object_id();
+  Topic topic = invalidations_.begin()->topic();
   invalidations_.erase(*invalidations_.begin());
 
-  Invalidation unknown_version = Invalidation::InitUnknownVersion(id);
+  Invalidation unknown_version = Invalidation::InitUnknownVersion(topic);
   invalidations_.insert(unknown_version);
 }
 

components/invalidation/impl/unacked_invalidation_set_unittest.cc

@@ -35,7 +35,6 @@ class UnackedInvalidationSetTest : public testing::Test {
   }
 
   const Topic kTopic = "ASDF";
-  const invalidation::ObjectId kObjectId = ConvertTopicToId(kTopic);
   UnackedInvalidationSet unacked_invalidations_;
 };
 
@@ -48,7 +47,7 @@ TEST_F(UnackedInvalidationSetTest, Empty) {
 
 // Test storage and retrieval of a single invalidation.
 TEST_F(UnackedInvalidationSetTest, OneInvalidation) {
-  Invalidation inv1 = Invalidation::Init(kObjectId, 10, "payload");
+  Invalidation inv1 = Invalidation::Init(kTopic, 10, "payload");
   unacked_invalidations_.Add(inv1);
 
   SingleObjectInvalidationSet set = GetStoredInvalidations();
@@ -58,7 +57,7 @@ TEST_F(UnackedInvalidationSetTest, OneInvalidation) {
 
 // Test that calling Clear() returns us to the empty state.
 TEST_F(UnackedInvalidationSetTest, Clear) {
-  Invalidation inv1 = Invalidation::Init(kObjectId, 10, "payload");
+  Invalidation inv1 = Invalidation::Init(kTopic, 10, "payload");
   unacked_invalidations_.Add(inv1);
   unacked_invalidations_.Clear();
 
@@ -67,9 +66,9 @@ TEST_F(UnackedInvalidationSetTest, Clear) {
 
 // Test that repeated unknown version invalidations are squashed together.
 TEST_F(UnackedInvalidationSetTest, UnknownVersions) {
-  Invalidation inv1 = Invalidation::Init(kObjectId, 10, "payload");
-  Invalidation inv2 = Invalidation::InitUnknownVersion(kObjectId);
-  Invalidation inv3 = Invalidation::InitUnknownVersion(kObjectId);
+  Invalidation inv1 = Invalidation::Init(kTopic, 10, "payload");
+  Invalidation inv2 = Invalidation::InitUnknownVersion(kTopic);
+  Invalidation inv3 = Invalidation::InitUnknownVersion(kTopic);
   unacked_invalidations_.Add(inv1);
   unacked_invalidations_.Add(inv2);
   unacked_invalidations_.Add(inv3);
@@ -84,7 +83,7 @@ TEST_F(UnackedInvalidationSetTest, NoTruncation) {
   size_t kMax = UnackedInvalidationSet::kMaxBufferedInvalidations;
 
   for (size_t i = 0; i < kMax; ++i) {
-    Invalidation inv = Invalidation::Init(kObjectId, i, "payload");
+    Invalidation inv = Invalidation::Init(kTopic, i, "payload");
     unacked_invalidations_.Add(inv);
   }
 
@@ -100,7 +99,7 @@ TEST_F(UnackedInvalidationSetTest, Truncation) {
   size_t kMax = UnackedInvalidationSet::kMaxBufferedInvalidations;
 
   for (size_t i = 0; i < kMax + 1; ++i) {
-    Invalidation inv = Invalidation::Init(kObjectId, i, "payload");
+    Invalidation inv = Invalidation::Init(kTopic, i, "payload");
     unacked_invalidations_.Add(inv);
   }
 
@@ -118,7 +117,7 @@ TEST_F(UnackedInvalidationSetTest, RegistrationAndTruncation) {
   size_t kMax = UnackedInvalidationSet::kMaxBufferedInvalidations;
 
   for (size_t i = 0; i < kMax + 1; ++i) {
-    Invalidation inv = Invalidation::Init(kObjectId, i, "payload");
+    Invalidation inv = Invalidation::Init(kTopic, i, "payload");
     unacked_invalidations_.Add(inv);
   }
 
@@ -146,8 +145,8 @@ TEST_F(UnackedInvalidationSetTest, Acknowledge) {
   // Not that it makes much of a difference in behavior.
   unacked_invalidations_.SetHandlerIsRegistered();
 
-  Invalidation inv1 = Invalidation::Init(kObjectId, 10, "payload");
-  Invalidation inv2 = Invalidation::InitUnknownVersion(kObjectId);
+  Invalidation inv1 = Invalidation::Init(kTopic, 10, "payload");
+  Invalidation inv2 = Invalidation::InitUnknownVersion(kTopic);
   AckHandle inv1_handle = inv1.ack_handle();
 
   unacked_invalidations_.Add(inv1);
@@ -169,8 +168,8 @@ TEST_F(UnackedInvalidationSetTest, Drop) {
   // Not that it makes much of a difference in behavior.
   unacked_invalidations_.SetHandlerIsRegistered();
 
-  Invalidation inv1 = Invalidation::Init(kObjectId, 10, "payload");
-  Invalidation inv2 = Invalidation::Init(kObjectId, 15, "payload");
+  Invalidation inv1 = Invalidation::Init(kTopic, 10, "payload");
+  Invalidation inv2 = Invalidation::Init(kTopic, 15, "payload");
   AckHandle inv1_handle = inv1.ack_handle();
 
   unacked_invalidations_.Add(inv1);

components/invalidation/public/BUILD.gn

@@ -25,10 +25,7 @@ static_library("public") {
     "topic_invalidation_map.cc",
     "topic_invalidation_map.h",
   ]
-  public_deps = [
-    "//google_apis",
-    "//third_party/cacheinvalidation",
-  ]
+  public_deps = [ "//google_apis" ]
   deps = [
     "//base",
     "//base:i18n",

components/invalidation/public/invalidation.cc

@@ -19,44 +19,45 @@
 namespace syncer {
 
 namespace {
+
 const char kObjectIdKey[] = "objectId";
 const char kIsUnknownVersionKey[] = "isUnknownVersion";
 const char kVersionKey[] = "version";
 const char kPayloadKey[] = "payload";
 const int64_t kInvalidVersion = -1;
-}
 
-// static
-Invalidation Invalidation::Init(const invalidation::ObjectId& id,
-                                int64_t version,
-                                const std::string& payload) {
-  return Invalidation(id, false, version, payload, AckHandle::CreateUnique());
+// Fills base::DictionaryValue as if legacy ObjectID still would be in use.
+// Used to provide values for chrome://invalidations page.
+std::unique_ptr<base::DictionaryValue> TopicToObjectIDValue(
+    const Topic& topic) {
+  auto value = std::make_unique<base::DictionaryValue>();
+  // Source has been deprecated, pass 0 instead.
+  value->SetInteger("source", 0);
+  value->SetString("name", topic);
+  return value;
 }
 
+}  // namespace
+
 // static
 Invalidation Invalidation::Init(const Topic& topic,
                                 int64_t version,
                                 const std::string& payload) {
-  return Invalidation::Init(ConvertTopicToId(topic), version, payload);
-}
-
-// static
-Invalidation Invalidation::InitUnknownVersion(
-    const invalidation::ObjectId& id) {
-  return Invalidation(
-      id, true, kInvalidVersion, std::string(), AckHandle::CreateUnique());
+  return Invalidation(topic, /*is_unknown_version=*/false, version, payload,
+                      AckHandle::CreateUnique());
 }
 
 // static
 Invalidation Invalidation::InitUnknownVersion(const Topic& topic) {
-  return InitUnknownVersion(ConvertTopicToId(topic));
+  return Invalidation(topic, /*is_unknown_version=*/true, kInvalidVersion,
+                      std::string(), AckHandle::CreateUnique());
 }
 
 // static
 Invalidation Invalidation::InitFromDroppedInvalidation(
     const Invalidation& dropped) {
-  return Invalidation(
-      dropped.id_, true, kInvalidVersion, std::string(), dropped.ack_handle_);
+  return Invalidation(dropped.topic(), /*is_unknown_version=*/true,
+                      kInvalidVersion, std::string(), dropped.ack_handle_);
 }
 
 Invalidation::Invalidation(const Invalidation& other) = default;
@@ -64,11 +65,7 @@ Invalidation::Invalidation(const Invalidation& other) = default;
 Invalidation::~Invalidation() = default;
 
 Topic Invalidation::topic() const {
-  return id_.name();
-}
-
-invalidation::ObjectId Invalidation::object_id() const {
-  return id_;
+  return topic_;
 }
 
 bool Invalidation::is_unknown_version() const {
@@ -117,13 +114,17 @@ void Invalidation::Drop() {
 }
 
 bool Invalidation::Equals(const Invalidation& other) const {
-  return id_ == other.id_ && is_unknown_version_ == other.is_unknown_version_ &&
+  return topic_ == other.topic_ &&
+         is_unknown_version_ == other.is_unknown_version_ &&
          version_ == other.version_ && payload_ == other.payload_;
 }
 
 std::unique_ptr<base::DictionaryValue> Invalidation::ToValue() const {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->Set(kObjectIdKey, ObjectIdToValue(id_));
+  auto value = std::make_unique<base::DictionaryValue>();
+  // TODO(crbug.com/1056181): ObjectID has been deprecated, but the value here
+  // used in the js counterpart (chrome://invalidations). Replace ObjectID with
+  // Topic here together with js counterpart update.
+  value->Set(kObjectIdKey, TopicToObjectIDValue(topic_));
   if (is_unknown_version_) {
     value->SetBoolean(kIsUnknownVersionKey, true);
   } else {
@@ -142,12 +143,12 @@ std::string Invalidation::ToString() const {
   return output;
 }
 
-Invalidation::Invalidation(const invalidation::ObjectId& id,
+Invalidation::Invalidation(const Topic& topic,
                            bool is_unknown_version,
                            int64_t version,
                            const std::string& payload,
                            AckHandle ack_handle)
-    : id_(id),
+    : topic_(topic),
       is_unknown_version_(is_unknown_version),
       version_(version),
       payload_(payload),

components/invalidation/public/invalidation.h

@@ -17,7 +17,6 @@
 #include "components/invalidation/public/invalidation.h"
 #include "components/invalidation/public/invalidation_export.h"
 #include "components/invalidation/public/invalidation_util.h"
-#include "google/cacheinvalidation/include/types.h"
 
 namespace syncer {
 
@@ -29,17 +28,9 @@ class AckHandler;
 class INVALIDATION_EXPORT Invalidation {
  public:
   // Factory functions.
-  // TODO(crbug.com/1029698): all ObjectID-based factory functions should be
-  // eventually replaced with Topic-based alternative. The end goal is to avoid
-  // any mentions of ObjectID here and in the whole components/invalidation
-  // directory.
-  static Invalidation Init(const invalidation::ObjectId& id,
-                           int64_t version,
-                           const std::string& payload);
   static Invalidation Init(const Topic& topic,
                            int64_t version,
                            const std::string& payload);
-  static Invalidation InitUnknownVersion(const invalidation::ObjectId& id);
   static Invalidation InitUnknownVersion(const Topic& topic);
   static Invalidation InitFromDroppedInvalidation(const Invalidation& dropped);
 
@@ -50,7 +41,6 @@ class INVALIDATION_EXPORT Invalidation {
   bool Equals(const Invalidation& other) const;
 
   Topic topic() const;
-  invalidation::ObjectId object_id() const;
   bool is_unknown_version() const;
 
   // Safe to call only if is_unknown_version() returns false.
@@ -104,14 +94,14 @@ class INVALIDATION_EXPORT Invalidation {
   std::string ToString() const;
 
  private:
-  Invalidation(const invalidation::ObjectId& id,
+  Invalidation(const Topic& topic,
                bool is_unknown_version,
                int64_t version,
                const std::string& payload,
                AckHandle ack_handle);
 
-  // The ObjectId to which this invalidation belongs.
-  invalidation::ObjectId id_;
+  // The Topic to which this invalidation belongs.
+  Topic topic_;
 
   // This flag is set to true if this is an unknown version invalidation.
   bool is_unknown_version_;

components/invalidation/public/invalidation_util.cc

@@ -13,23 +13,13 @@
 #include "base/values.h"
 #include "components/invalidation/public/invalidation.h"
 #include "components/invalidation/public/invalidation_handler.h"
-#include "google/cacheinvalidation/include/types.h"
 
 namespace syncer {
 
-const int kDeprecatedSourceForFCM = 2000;
-
-bool ObjectIdLessThan::operator()(const invalidation::ObjectId& lhs,
-                                  const invalidation::ObjectId& rhs) const {
-  return (lhs.source() < rhs.source()) ||
-         (lhs.source() == rhs.source() && lhs.name() < rhs.name());
-}
-
 bool InvalidationVersionLessThan::operator()(const Invalidation& a,
                                              const Invalidation& b) const {
-  DCHECK(a.object_id() == b.object_id())
-      << "a: " << ObjectIdToString(a.object_id()) << ", "
-      << "b: " << ObjectIdToString(a.object_id());
+  DCHECK(a.topic() == b.topic()) << "a: " << a.topic() << ", "
+                                 << "b: " << b.topic();
 
   if (a.is_unknown_version() && !b.is_unknown_version())
     return true;
@@ -47,57 +37,6 @@ bool operator==(const TopicMetadata& lhs, const TopicMetadata& rhs) {
   return lhs.is_public == rhs.is_public;
 }
 
-std::unique_ptr<base::DictionaryValue> ObjectIdToValue(
-    const invalidation::ObjectId& object_id) {
-  std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
-  value->SetInteger("source", object_id.source());
-  value->SetString("name", object_id.name());
-  return value;
-}
-
-bool ObjectIdFromValue(const base::DictionaryValue& value,
-                       invalidation::ObjectId* out) {
-  *out = invalidation::ObjectId();
-  std::string name;
-  int source = 0;
-  if (!value.GetInteger("source", &source) || !value.GetString("name", &name)) {
-    return false;
-  }
-  *out = invalidation::ObjectId(source, name);
-  return true;
-}
-
-std::string ObjectIdToString(const invalidation::ObjectId& object_id) {
-  std::string str;
-  base::JSONWriter::Write(*ObjectIdToValue(object_id), &str);
-  return str;
-}
-
-Topics ConvertIdsToTopics(ObjectIdSet ids, InvalidationHandler* handler) {
-  Topics topics;
-  for (const auto& id : ids)
-    topics.emplace(id.name(), TopicMetadata{handler->IsPublicTopic(id.name())});
-  return topics;
-}
-
-ObjectIdSet ConvertTopicsToIds(TopicSet topics) {
-  ObjectIdSet ids;
-  for (const auto& topic : topics)
-    ids.insert(invalidation::ObjectId(kDeprecatedSourceForFCM, topic));
-  return ids;
-}
-
-ObjectIdSet ConvertTopicsToIds(Topics topics) {
-  ObjectIdSet ids;
-  for (const auto& topic : topics)
-    ids.insert(invalidation::ObjectId(kDeprecatedSourceForFCM, topic.first));
-  return ids;
-}
-
-invalidation::ObjectId ConvertTopicToId(const Topic& topic) {
-  return invalidation::ObjectId(kDeprecatedSourceForFCM, topic);
-}
-
 HandlerOwnerType OwnerNameToHandlerType(const std::string& owner_name) {
   if (owner_name == "Cloud")
     return HandlerOwnerType::kCloud;

components/invalidation/public/invalidation_util.h

@@ -17,24 +17,8 @@
 #include "base/values.h"
 #include "components/invalidation/public/invalidation_export.h"
 
-namespace base {
-class DictionaryValue;
-}  // namespace base
-
-namespace invalidation {
-class ObjectId;
-}  // namespace invalidation
-
 namespace syncer {
 
-// FCMInvalidationService and deprecated TiclInvalidationService uses ObjectId
-// to keep track of objects to invalidate. There are 2 fields in ObjectId:
-// source and name. TiclInvalidationService expects both of them, while
-// FCMInvalidationService only works with the name. So InvalidationService
-// assigns the value of source to kDeprecatedSourceForFCM when FCM (Firebase
-// Cloud Messaging) is enabled.
-extern const int kDeprecatedSourceForFCM;
-
 // Used by UMA histogram, so entries shouldn't be reordered or removed.
 enum class HandlerOwnerType {
   kCloud = 0,
@@ -52,19 +36,11 @@ enum class HandlerOwnerType {
 };
 
 class Invalidation;
-class InvalidationHandler;
-
-struct INVALIDATION_EXPORT ObjectIdLessThan {
-  bool operator()(const invalidation::ObjectId& lhs,
-                  const invalidation::ObjectId& rhs) const;
-};
 
 struct INVALIDATION_EXPORT InvalidationVersionLessThan {
   bool operator()(const Invalidation& a, const Invalidation& b) const;
 };
 
-typedef std::set<invalidation::ObjectId, ObjectIdLessThan> ObjectIdSet;
-
 using Topic = std::string;
 // It should be std::set, since std::set_difference is used for it.
 using TopicSet = std::set<std::string>;
@@ -80,21 +56,6 @@ INVALIDATION_EXPORT bool operator==(const TopicMetadata&, const TopicMetadata&);
 
 using Topics = std::map<std::string, TopicMetadata>;
 
-// Caller owns the returned DictionaryValue.
-std::unique_ptr<base::DictionaryValue> ObjectIdToValue(
-    const invalidation::ObjectId& object_id);
-
-bool ObjectIdFromValue(const base::DictionaryValue& value,
-                       invalidation::ObjectId* out);
-
-INVALIDATION_EXPORT std::string ObjectIdToString(
-    const invalidation::ObjectId& object_id);
-
-ObjectIdSet ConvertTopicsToIds(TopicSet topics);
-ObjectIdSet ConvertTopicsToIds(Topics topics);
-invalidation::ObjectId ConvertTopicToId(const Topic& topic);
-Topics ConvertIdsToTopics(ObjectIdSet ids, InvalidationHandler* handler);
-
 HandlerOwnerType OwnerNameToHandlerType(const std::string& owner_name);
 
 // Returns a |Topic| contained within both |lhs| and |rhs| or null if |lhs| and

components/invalidation/public/single_object_invalidation_set.h

@@ -20,7 +20,7 @@ class ListValue;
 
 namespace syncer {
 
-// Holds a list of invalidations that all share the same Object ID.
+// Holds a list of invalidations that all share the same Topic.
 //
 // The list is kept sorted by version to make it easier to perform common
 // operations, like checking for an unknown version invalidation or fetching the

components/invalidation/public/topic_invalidation_map.cc

@@ -29,7 +29,7 @@ bool TopicInvalidationMap::Empty() const {
 }
 
 void TopicInvalidationMap::Insert(const Invalidation& invalidation) {
-  map_[invalidation.object_id().name()].Insert(invalidation);
+  map_[invalidation.topic()].Insert(invalidation);
 }
 
 TopicInvalidationMap TopicInvalidationMap::GetSubsetWithTopics(

components/invalidation/public/topic_invalidation_map.h

@@ -20,7 +20,7 @@ class ListValue;
 
 namespace syncer {
 
-// A set of notifications with some helper methods to organize them by object ID
+// A set of notifications with some helper methods to organize them by Topic
 // and version number.
 class INVALIDATION_EXPORT TopicInvalidationMap {
  public:

components/sync/base/invalidation_helper.cc

@@ -6,8 +6,6 @@
 
 #include <string>
 
-#include "google/cacheinvalidation/types.pb.h"
-
 namespace syncer {
 
 TopicSet ModelTypeSetToTopicSet(ModelTypeSet model_types) {