Separate invalidator and sync client ID (part 2/2)

sync/notifier/p2p_invalidator_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 "sync/notifier/p2p_invalidator.h"
 
 #include <cstddef>
 
 #include "jingle/notifier/listener/fake_push_client.h"
 #include "sync/internal_api/public/base/model_type.h"
 #include "sync/internal_api/public/base/model_type_invalidation_map.h"
 #include "sync/notifier/fake_invalidation_handler.h"
 #include "sync/notifier/invalidator_test_template.h"
 #include "sync/notifier/object_id_invalidation_map_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace syncer {
 
 namespace {
 
 class P2PInvalidatorTestDelegate {
  public:
   P2PInvalidatorTestDelegate() : fake_push_client_(NULL) {}
 
   ~P2PInvalidatorTestDelegate() {
     DestroyInvalidator();
   }
 
   void CreateInvalidator(
+      const std::string& invalidator_client_id,
       const std::string& initial_state,
       const base::WeakPtr<InvalidationStateTracker>&
           invalidation_state_tracker) {
     DCHECK(!fake_push_client_);
     DCHECK(!invalidator_.get());
     fake_push_client_ = new notifier::FakePushClient();
     invalidator_.reset(
         new P2PInvalidator(
             scoped_ptr<notifier::PushClient>(fake_push_client_),
+            invalidator_client_id,
             NOTIFY_OTHERS));
   }
 
   P2PInvalidator* GetInvalidator() {
     return invalidator_.get();
   }
 
   notifier::FakePushClient* GetPushClient() {
     return fake_push_client_;
   }
@@ skipping 28 matching lines @@
  private:
   // Owned by |invalidator_|.
   notifier::FakePushClient* fake_push_client_;
   scoped_ptr<P2PInvalidator> invalidator_;
 };
 
 class P2PInvalidatorTest : public testing::Test {
  protected:
   P2PInvalidatorTest()
       : next_sent_notification_to_reflect_(0) {
-    delegate_.CreateInvalidator("fake_state",
+    delegate_.CreateInvalidator("sender",
+                                "fake_state",
                                 base::WeakPtr<InvalidationStateTracker>());
     delegate_.GetInvalidator()->RegisterHandler(&fake_handler_);
   }
 
   virtual ~P2PInvalidatorTest() {
     delegate_.GetInvalidator()->UnregisterHandler(&fake_handler_);
   }
 
   ModelTypeInvalidationMap MakeInvalidationMap(ModelTypeSet types) {
     return ModelTypeSetToInvalidationMap(types, std::string());
@@ skipping 109 matching lines @@
 // UpdateEnabledTypes().
 TEST_F(P2PInvalidatorTest, NotificationsBasic) {
   const ModelTypeSet enabled_types(BOOKMARKS, PREFERENCES);
 
   P2PInvalidator* const invalidator = delegate_.GetInvalidator();
   notifier::FakePushClient* const push_client = delegate_.GetPushClient();
 
   invalidator->UpdateRegisteredIds(&fake_handler_,
                                    ModelTypeSetToObjectIdSet(enabled_types));
 
-  invalidator->SetUniqueId("sender");
-
   const char kEmail[] = "foo@bar.com";
   const char kToken[] = "token";
   invalidator->UpdateCredentials(kEmail, kToken);
   {
     notifier::Subscription expected_subscription;
     expected_subscription.channel = kSyncP2PNotificationChannel;
     expected_subscription.from = kEmail;
     EXPECT_TRUE(notifier::SubscriptionListsEqual(
         push_client->subscriptions(),
         notifier::SubscriptionList(1, expected_subscription)));
@@ skipping 36 matching lines @@
   const ObjectIdInvalidationMap& invalidation_map =
       ObjectIdSetToInvalidationMap(
           ModelTypeSetToObjectIdSet(changed_types), "");
 
   P2PInvalidator* const invalidator = delegate_.GetInvalidator();
   notifier::FakePushClient* const push_client = delegate_.GetPushClient();
 
   invalidator->UpdateRegisteredIds(&fake_handler_,
                                    ModelTypeSetToObjectIdSet(enabled_types));
 
-  invalidator->SetUniqueId("sender");
   invalidator->UpdateCredentials("foo@bar.com", "fake_token");
 
   ReflectSentNotifications();
   push_client->EnableNotifications();
   EXPECT_EQ(INVALIDATIONS_ENABLED, fake_handler_.GetInvalidatorState());
 
   ReflectSentNotifications();
   EXPECT_EQ(1, fake_handler_.GetInvalidationCount());
   EXPECT_THAT(
       ModelTypeInvalidationMapToObjectIdInvalidationMap(
@@ skipping 68 matching lines @@
   EXPECT_EQ(5, fake_handler_.GetInvalidationCount());
 }
 
 INSTANTIATE_TYPED_TEST_CASE_P(
     P2PInvalidatorTest, InvalidatorTest,
     P2PInvalidatorTestDelegate);
 
 }  // namespace
 
 }  // namespace syncer