[Sync] Rename classes in sync/ that start with Chrome

sync/notifier/sync_invalidation_client_unittest.cc

 // Copyright (c) 2012 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 <cstddef>
 #include <set>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "google/cacheinvalidation/include/invalidation-client.h"
 #include "google/cacheinvalidation/include/types.h"
 #include "jingle/notifier/listener/fake_push_client.h"
 #include "sync/internal_api/public/util/weak_handle.h"
-#include "sync/notifier/chrome_invalidation_client.h"
 #include "sync/notifier/fake_invalidation_state_tracker.h"
 #include "sync/notifier/invalidation_util.h"
+#include "sync/notifier/sync_invalidation_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 using invalidation::AckHandle;
 using invalidation::ObjectId;
 
 const char kClientId[] = "client_id";
@@ skipping 94 matching lines @@
   }
 
  private:
   bool started_;
   ObjectIdSet registered_ids_;
   AckHandleSet acked_handles_;
 };
 
 // Fake listener tkat keeps track of invalidation counts, payloads,
 // and state.
-class FakeListener : public ChromeInvalidationClient::Listener {
+class FakeListener : public SyncInvalidationClient::Listener {
  public:
   FakeListener() : reason_(TRANSIENT_NOTIFICATION_ERROR) {}
   virtual ~FakeListener() {}
 
   int GetInvalidationCount(const ObjectId& id) const {
     ObjectIdCountMap::const_iterator it = invalidation_counts_.find(id);
     return (it == invalidation_counts_.end()) ? 0 : it->second;
   }
 
   std::string GetPayload(const ObjectId& id) const {
     ObjectIdStateMap::const_iterator it = states_.find(id);
     return (it == states_.end()) ? "" : it->second.payload;
   }
 
   // NO_NOTIFICATION_ERROR is the enabled state.
   NotificationsDisabledReason GetNotificationsDisabledReason() const {
     return reason_;
   }
 
-  // ChromeInvalidationClient::Listener implementation.
+  // SyncInvalidationClient::Listener implementation.
 
   virtual void OnInvalidate(const ObjectIdStateMap& id_state_map) OVERRIDE {
     for (ObjectIdStateMap::const_iterator it = id_state_map.begin();
          it != id_state_map.end(); ++it) {
       ++invalidation_counts_[it->first];
       states_[it->first] = it->second;
     }
   }
 
   virtual void OnNotificationsEnabled() {
@@ skipping 15 matching lines @@
     FakeInvalidationClient** fake_invalidation_client,
     invalidation::SystemResources* resources,
     int client_type,
     const invalidation::string& client_name,
     const invalidation::string& application_name,
     invalidation::InvalidationListener* listener) {
   *fake_invalidation_client = new FakeInvalidationClient();
   return *fake_invalidation_client;
 }
 
-class ChromeInvalidationClientTest : public testing::Test {
+class SyncInvalidationClientTest : public testing::Test {
  protected:
-  ChromeInvalidationClientTest()
+  SyncInvalidationClientTest()
       : kBookmarksId_(kChromeSyncSourceId, "BOOKMARK"),
         kPreferencesId_(kChromeSyncSourceId, "PREFERENCE"),
         kExtensionsId_(kChromeSyncSourceId, "EXTENSION"),
         kAppsId_(kChromeSyncSourceId, "APP"),
         fake_push_client_(new notifier::FakePushClient()),
         fake_invalidation_client_(NULL),
         client_(scoped_ptr<notifier::PushClient>(fake_push_client_)) {}
 
   virtual void SetUp() {
     StartClient();
@@ skipping 119 matching lines @@
 
   MessageLoop message_loop_;
 
   FakeListener fake_listener_;
   FakeInvalidationStateTracker fake_tracker_;
   notifier::FakePushClient* const fake_push_client_;
 
  protected:
   // Tests need to access these directly.
   FakeInvalidationClient* fake_invalidation_client_;
-  ChromeInvalidationClient client_;
+  SyncInvalidationClient client_;
 };
 
 // Write a new state to the client.  It should propagate to the
 // tracker.
-TEST_F(ChromeInvalidationClientTest, WriteState) {
+TEST_F(SyncInvalidationClientTest, WriteState) {
   WriteState(kNewState);
 
   EXPECT_EQ(kNewState, GetInvalidationState());
 }
 
 // Invalidation tests.
 
 // Fire an invalidation without a payload.  It should be processed,
 // the payload should remain empty, and the version should be updated.
-TEST_F(ChromeInvalidationClientTest, InvalidateNoPayload) {
+TEST_F(SyncInvalidationClientTest, InvalidateNoPayload) {
   const ObjectId& id = kBookmarksId_;
 
   FireInvalidate(id, kVersion1, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
 }
 
 // Fire an invalidation with an empty payload.  It should be
 // processed, the payload should remain empty, and the version should
 // be updated.
-TEST_F(ChromeInvalidationClientTest, InvalidateEmptyPayload) {
+TEST_F(SyncInvalidationClientTest, InvalidateEmptyPayload) {
   const ObjectId& id = kBookmarksId_;
 
   FireInvalidate(id, kVersion1, "");
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
 }
 
 // Fire an invalidation with a payload.  It should be processed, and
 // both the payload and the version should be updated.
-TEST_F(ChromeInvalidationClientTest, InvalidateWithPayload) {
+TEST_F(SyncInvalidationClientTest, InvalidateWithPayload) {
   const ObjectId& id = kPreferencesId_;
 
   FireInvalidate(id, kVersion1, kPayload1);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ(kPayload1, GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
 }
 
 // Fire an invalidation with a payload.  It should still be processed,
 // and both the payload and the version should be updated.
-TEST_F(ChromeInvalidationClientTest, InvalidateUnregistered) {
+TEST_F(SyncInvalidationClientTest, InvalidateUnregistered) {
   const ObjectId kUnregisteredId(
       kChromeSyncSourceId, "unregistered");
   const ObjectId& id = kUnregisteredId;
 
   EXPECT_EQ(0, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kMinVersion, GetMaxVersion(id));
 
   FireInvalidate(id, kVersion1, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kVersion1, GetMaxVersion(id));
 }
 
 // Fire an invalidation, then fire another one with a lower version.
 // The first one should be processed and should update the payload and
 // version, but the second one shouldn't.
-TEST_F(ChromeInvalidationClientTest, InvalidateVersion) {
+TEST_F(SyncInvalidationClientTest, InvalidateVersion) {
   const ObjectId& id = kPreferencesId_;
 
   FireInvalidate(id, kVersion2, kPayload2);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ(kPayload2, GetPayload(id));
   EXPECT_EQ(kVersion2, GetMaxVersion(id));
 
   FireInvalidate(id, kVersion1, kPayload1);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ(kPayload2, GetPayload(id));
   EXPECT_EQ(kVersion2, GetMaxVersion(id));
 }
 
 // Fire an invalidation with an unknown version twice.  It shouldn't
 // update the payload or version either time, but it should still be
 // processed.
-TEST_F(ChromeInvalidationClientTest, InvalidateUnknownVersion) {
+TEST_F(SyncInvalidationClientTest, InvalidateUnknownVersion) {
   const ObjectId& id = kBookmarksId_;
 
   FireInvalidateUnknownVersion(id);
 
   EXPECT_EQ(1, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kMinVersion, GetMaxVersion(id));
 
   FireInvalidateUnknownVersion(id);
 
   EXPECT_EQ(2, GetInvalidationCount(id));
   EXPECT_EQ("", GetPayload(id));
   EXPECT_EQ(kMinVersion, GetMaxVersion(id));
 }
 
 // Fire an invalidation for all enabled IDs.  It shouldn't update the
 // payload or version, but it should still invalidate the IDs.
-TEST_F(ChromeInvalidationClientTest, InvalidateAll) {
+TEST_F(SyncInvalidationClientTest, InvalidateAll) {
   FireInvalidateAll();
 
   for (ObjectIdSet::const_iterator it = registered_ids_.begin();
        it != registered_ids_.end(); ++it) {
     EXPECT_EQ(1, GetInvalidationCount(*it));
     EXPECT_EQ("", GetPayload(*it));
     EXPECT_EQ(kMinVersion, GetMaxVersion(*it));
   }
 }
 
 // Comprehensive test of various scenarios for multiple IDs.
-TEST_F(ChromeInvalidationClientTest, InvalidateMultipleIds) {
+TEST_F(SyncInvalidationClientTest, InvalidateMultipleIds) {
   FireInvalidate(kBookmarksId_, 3, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(3, GetMaxVersion(kBookmarksId_));
 
   FireInvalidate(kExtensionsId_, 2, NULL);
 
   EXPECT_EQ(1, GetInvalidationCount(kExtensionsId_));
   EXPECT_EQ("", GetPayload(kExtensionsId_));
@@ skipping 45 matching lines @@
   EXPECT_EQ(3, GetInvalidationCount(kBookmarksId_));
   EXPECT_EQ("", GetPayload(kBookmarksId_));
   EXPECT_EQ(4, GetMaxVersion(kBookmarksId_));
 }
 
 // Registration tests.
 
 // With IDs already registered, enable notifications then ready the
 // client.  The IDs should be registered only after the client is
 // readied.
-TEST_F(ChromeInvalidationClientTest, RegisterEnableReady) {
+TEST_F(SyncInvalidationClientTest, RegisterEnableReady) {
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   EnableNotifications();
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // With IDs already registered, ready the client then enable
 // notifications.  The IDs should be registered after the client is
 // readied.
-TEST_F(ChromeInvalidationClientTest, RegisterReadyEnable) {
+TEST_F(SyncInvalidationClientTest, RegisterReadyEnable) {
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 
   EnableNotifications();
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // Unregister the IDs, enable notifications, re-register the IDs, then
 // ready the client.  The IDs should be registered only after the
 // client is readied.
-TEST_F(ChromeInvalidationClientTest, EnableRegisterReady) {
+TEST_F(SyncInvalidationClientTest, EnableRegisterReady) {
   client_.UpdateRegisteredIds(ObjectIdSet());
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   EnableNotifications();
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.UpdateRegisteredIds(registered_ids_);
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // Unregister the IDs, enable notifications, ready the client, then
 // re-register the IDs.  The IDs should be registered only after the
 // client is readied.
-TEST_F(ChromeInvalidationClientTest, EnableReadyRegister) {
+TEST_F(SyncInvalidationClientTest, EnableReadyRegister) {
   client_.UpdateRegisteredIds(ObjectIdSet());
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   EnableNotifications();
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.UpdateRegisteredIds(registered_ids_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // Unregister the IDs, ready the client, enable notifications, then
 // re-register the IDs.  The IDs should be registered only after the
 // client is readied.
-TEST_F(ChromeInvalidationClientTest, ReadyEnableRegister) {
+TEST_F(SyncInvalidationClientTest, ReadyEnableRegister) {
   client_.UpdateRegisteredIds(ObjectIdSet());
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   EnableNotifications();
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.UpdateRegisteredIds(registered_ids_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // Unregister the IDs, ready the client, re-register the IDs, then
 // enable notifications. The IDs should be registered only after the
 // client is readied.
 //
 // This test is important: see http://crbug.com/139424.
-TEST_F(ChromeInvalidationClientTest, ReadyRegisterEnable) {
+TEST_F(SyncInvalidationClientTest, ReadyRegisterEnable) {
   client_.UpdateRegisteredIds(ObjectIdSet());
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.UpdateRegisteredIds(registered_ids_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 
   EnableNotifications();
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // With IDs already registered, ready the client, restart the client,
 // then re-ready it.  The IDs should still be registered.
-TEST_F(ChromeInvalidationClientTest, RegisterTypesPreserved) {
+TEST_F(SyncInvalidationClientTest, RegisterTypesPreserved) {
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 
   RestartClient();
 
   EXPECT_TRUE(GetRegisteredIds().empty());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(registered_ids_, GetRegisteredIds());
 }
 
 // Without readying the client, disable notifications, then enable
 // them.  The listener should still think notifications are disabled.
-TEST_F(ChromeInvalidationClientTest, EnableNotificationsNotReady) {
+TEST_F(SyncInvalidationClientTest, EnableNotificationsNotReady) {
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             GetNotificationsDisabledReason());
 
   DisableNotifications(
       notifier::TRANSIENT_NOTIFICATION_ERROR);
 
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             GetNotificationsDisabledReason());
 
   DisableNotifications(
       notifier::NOTIFICATION_CREDENTIALS_REJECTED);
 
   EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED,
             GetNotificationsDisabledReason());
 
   EnableNotifications();
 
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR,
             GetNotificationsDisabledReason());
 }
 
 // Enable notifications then Ready the invalidation client.  The
 // listener should then be ready.
-TEST_F(ChromeInvalidationClientTest, EnableNotificationsThenReady) {
+TEST_F(SyncInvalidationClientTest, EnableNotificationsThenReady) {
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 
   EnableNotifications();
 
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 }
 
 // Ready the invalidation client then enable notifications.  The
 // listener should then be ready.
-TEST_F(ChromeInvalidationClientTest, ReadyThenEnableNotifications) {
+TEST_F(SyncInvalidationClientTest, ReadyThenEnableNotifications) {
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(TRANSIENT_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 
   EnableNotifications();
 
   EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 }
 
 // Enable notifications and ready the client.  Then disable
 // notifications with an auth error and re-enable notifications.  The
 // listener should go into an auth error mode and then back out.
-TEST_F(ChromeInvalidationClientTest, PushClientAuthError) {
+TEST_F(SyncInvalidationClientTest, PushClientAuthError) {
   EnableNotifications();
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 
   DisableNotifications(
       notifier::NOTIFICATION_CREDENTIALS_REJECTED);
 
   EXPECT_EQ(NOTIFICATION_CREDENTIALS_REJECTED,
             GetNotificationsDisabledReason());
 
   EnableNotifications();
 
   EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 }
 
 // Enable notifications and ready the client.  Then simulate an auth
 // error from the invalidation client.  Simulate some notification
 // events, then re-ready the client.  The listener should go into an
 // auth error mode and come out of it only after the client is ready.
-TEST_F(ChromeInvalidationClientTest, InvalidationClientAuthError) {
+TEST_F(SyncInvalidationClientTest, InvalidationClientAuthError) {
   EnableNotifications();
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 
   client_.InformError(
       fake_invalidation_client_,
       invalidation::ErrorInfo(
           invalidation::ErrorReason::AUTH_FAILURE,
           false /* is_transient */,
@@ skipping 21 matching lines @@
             GetNotificationsDisabledReason());
 
   client_.Ready(fake_invalidation_client_);
 
   EXPECT_EQ(NO_NOTIFICATION_ERROR, GetNotificationsDisabledReason());
 }
 
 }  // namespace
 
 }  // namespace syncer