Support getting and deleting token for Instance ID.

components/gcm_driver/gcm_client_impl_unittest.cc

 // Copyright 2014 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/gcm_driver/gcm_client_impl.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 230 matching lines @@
   GCMClientImplTest();
   ~GCMClientImplTest() override;
 
   void SetUp() override;
 
   void SetUpUrlFetcherFactory();
 
   void BuildGCMClient(base::TimeDelta clock_step);
   void InitializeGCMClient();
   void StartGCMClient();
+  void Register(const std::string& app_id,
+                const std::vector<std::string>& senders);
+  void Unregister(const std::string& app_id);
   void ReceiveMessageFromMCS(const MCSMessage& message);
   void ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status);
   void CompleteCheckin(uint64 android_id,
                        uint64 security_token,
                        const std::string& digest,
                        const std::map<std::string, std::string>& settings);
   void CompleteRegistration(const std::string& registration_id);
   void CompleteUnregistration(const std::string& app_id);
   void VerifyPendingRequestFetcherDeleted();
 
   bool ExistsRegistration(const std::string& app_id) const;
   void AddRegistration(const std::string& app_id,
                        const std::vector<std::string>& sender_ids,
                        const std::string& registration_id);
 
   // GCMClient::Delegate overrides (for verification).
-  void OnRegisterFinished(const std::string& app_id,
+  void OnRegisterFinished(const linked_ptr<RegistrationInfo>& registration_info,
                           const std::string& registration_id,
                           GCMClient::Result result) override;
-  void OnUnregisterFinished(const std::string& app_id,
-                            GCMClient::Result result) override;
+  void OnUnregisterFinished(
+      const linked_ptr<RegistrationInfo>& registration_info,
+      GCMClient::Result result) override;
   void OnSendFinished(const std::string& app_id,
                       const std::string& message_id,
                       GCMClient::Result result) override {}
   void OnMessageReceived(const std::string& registration_id,
                          const GCMClient::IncomingMessage& message) override;
   void OnMessagesDeleted(const std::string& app_id) override;
   void OnMessageSendError(
       const std::string& app_id,
       const gcm::GCMClient::SendErrorDetails& send_error_details) override;
   void OnSendAcknowledged(const std::string& app_id,
@@ skipping 202 matching lines @@
   fetcher->SetResponseString(response);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 void GCMClientImplTest::VerifyPendingRequestFetcherDeleted() {
   net::TestURLFetcher* fetcher = url_fetcher_factory_.GetFetcherByID(0);
   EXPECT_FALSE(fetcher);
 }
 
 bool GCMClientImplTest::ExistsRegistration(const std::string& app_id) const {
-  return gcm_client_->registrations_.count(app_id) > 0;
+  return ExistsGCMRegistrationInMap(gcm_client_->registrations_, app_id);
 }
 
 void GCMClientImplTest::AddRegistration(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     const std::string& registration_id) {
-  linked_ptr<RegistrationInfo> registration(new RegistrationInfo);
+  linked_ptr<GCMRegistrationInfo> registration(new GCMRegistrationInfo);
+  registration->app_id = app_id;
   registration->sender_ids = sender_ids;
-  registration->registration_id = registration_id;
-  gcm_client_->registrations_[app_id] = registration;
+  gcm_client_->registrations_[registration] = registration_id;
 }
 
 void GCMClientImplTest::InitializeGCMClient() {
   clock()->Advance(base::TimeDelta::FromMilliseconds(1));
 
   // Actual initialization.
   GCMClient::ChromeBuildInfo chrome_build_info;
   gcm_client_->Initialize(chrome_build_info,
                           temp_directory_.path(),
                           message_loop_.message_loop_proxy(),
                           url_request_context_getter_,
                           make_scoped_ptr<Encryptor>(new FakeEncryptor),
                           this);
 }
 
 void GCMClientImplTest::StartGCMClient() {
   // Start loading and check-in.
   gcm_client_->Start(GCMClient::IMMEDIATE_START);
 
   PumpLoopUntilIdle();
 }
 
+void GCMClientImplTest::Register(const std::string& app_id,
+                                 const std::vector<std::string>& senders) {
+  scoped_ptr<GCMRegistrationInfo> gcm_info(new GCMRegistrationInfo);
+  gcm_info->app_id = app_id;
+  gcm_info->sender_ids = senders;
+  gcm_client()->Register(make_linked_ptr<RegistrationInfo>(gcm_info.release()));
+}
+
+void GCMClientImplTest::Unregister(const std::string& app_id) {
+  scoped_ptr<GCMRegistrationInfo> gcm_info(new GCMRegistrationInfo);
+  gcm_info->app_id = app_id;
+  gcm_client()->Unregister(
+      make_linked_ptr<RegistrationInfo>(gcm_info.release()));
+}
+
 void GCMClientImplTest::ReceiveMessageFromMCS(const MCSMessage& message) {
   gcm_client_->recorder_.RecordConnectionInitiated(std::string());
   gcm_client_->recorder_.RecordConnectionSuccess();
   gcm_client_->OnMessageReceivedFromMCS(message);
 }
 
 void GCMClientImplTest::ReceiveOnMessageSentToMCS(
       const std::string& app_id,
       const std::string& message_id,
       const MCSClient::MessageSendStatus status) {
@@ skipping 11 matching lines @@
 
 void GCMClientImplTest::OnMessageReceived(
     const std::string& registration_id,
     const GCMClient::IncomingMessage& message) {
   last_event_ = MESSAGE_RECEIVED;
   last_app_id_ = registration_id;
   last_message_ = message;
   QuitLoop();
 }
 
-void GCMClientImplTest::OnRegisterFinished(const std::string& app_id,
-                                           const std::string& registration_id,
-                                           GCMClient::Result result) {
+void GCMClientImplTest::OnRegisterFinished(
+    const linked_ptr<RegistrationInfo>& registration_info,
+    const std::string& registration_id,
+    GCMClient::Result result) {
   last_event_ = REGISTRATION_COMPLETED;
-  last_app_id_ = app_id;
+  last_app_id_ = registration_info->app_id;
   last_registration_id_ = registration_id;
   last_result_ = result;
 }
 
-void GCMClientImplTest::OnUnregisterFinished(const std::string& app_id,
-                                             GCMClient::Result result) {
+void GCMClientImplTest::OnUnregisterFinished(
+    const linked_ptr<RegistrationInfo>& registration_info,
+    GCMClient::Result result) {
   last_event_ = UNREGISTRATION_COMPLETED;
-  last_app_id_ = app_id;
+  last_app_id_ = registration_info->app_id;
   last_result_ = result;
 }
 
 void GCMClientImplTest::OnMessagesDeleted(const std::string& app_id) {
   last_event_ = MESSAGES_DELETED;
   last_app_id_ = app_id;
 }
 
 void GCMClientImplTest::OnMessageSendError(
     const std::string& app_id,
@@ skipping 51 matching lines @@
   EXPECT_EQ(LOADING_COMPLETED, last_event());
   EXPECT_EQ(kDeviceAndroidId2, mcs_client()->last_android_id());
   EXPECT_EQ(kDeviceSecurityToken2, mcs_client()->last_security_token());
 }
 
 TEST_F(GCMClientImplTest, RegisterApp) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
-  gcm_client()->Register(kAppId, senders);
+  Register(kAppId, senders);
   CompleteRegistration("reg_id");
 
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, DISABLED_RegisterAppFromCache) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
-  gcm_client()->Register(kAppId, senders);
+  Register(kAppId, senders);
   CompleteRegistration("reg_id");
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ("reg_id", last_registration_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_EQ(REGISTRATION_COMPLETED, last_event());
 
   // Recreate GCMClient in order to load from the persistent store.
   BuildGCMClient(base::TimeDelta());
   InitializeGCMClient();
   StartGCMClient();
 
   EXPECT_TRUE(ExistsRegistration(kAppId));
 }
 
 TEST_F(GCMClientImplTest, UnregisterApp) {
   EXPECT_FALSE(ExistsRegistration(kAppId));
 
   std::vector<std::string> senders;
   senders.push_back("sender");
-  gcm_client()->Register(kAppId, senders);
+  Register(kAppId, senders);
   CompleteRegistration("reg_id");
   EXPECT_TRUE(ExistsRegistration(kAppId));
 
-  gcm_client()->Unregister(kAppId);
+  Unregister(kAppId);
   CompleteUnregistration(kAppId);
 
   EXPECT_EQ(UNREGISTRATION_COMPLETED, last_event());
   EXPECT_EQ(kAppId, last_app_id());
   EXPECT_EQ(GCMClient::SUCCESS, last_result());
   EXPECT_FALSE(ExistsRegistration(kAppId));
 }
 
 // Tests that stopping the GCMClient also deletes pending registration requests.
 // This is tested by checking that url fetcher contained in the request was
 // deleted.
 TEST_F(GCMClientImplTest, DeletePendingRequestsWhenStopping) {
   std::vector<std::string> senders;
   senders.push_back("sender");
-  gcm_client()->Register(kAppId, senders);
+  Register(kAppId, senders);
 
   gcm_client()->Stop();
   VerifyPendingRequestFetcherDeleted();
 }
 
 TEST_F(GCMClientImplTest, DispatchDownstreamMessage) {
   // Register to receive messages from kSender and kSender2 only.
   std::vector<std::string> senders;
   senders.push_back(kSender);
   senders.push_back(kSender2);
@@ skipping 429 matching lines @@
   // Start the GCM immediately and complete the checkin.
   gcm_client()->Start(GCMClient::IMMEDIATE_START);
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIAL_DEVICE_CHECKIN, gcm_client_state());
   DefaultCompleteCheckin();
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 
   // Registration.
   std::vector<std::string> senders;
   senders.push_back("sender");
-  gcm_client()->Register(kAppId, senders);
+ Register(kAppId, senders);
   CompleteRegistration("reg_id");
   EXPECT_EQ(GCMClientImpl::READY, gcm_client_state());
 
   // Stop the GCM.
   gcm_client()->Stop();
   PumpLoopUntilIdle();
   EXPECT_EQ(GCMClientImpl::INITIALIZED, gcm_client_state());
 
   // Delay start the GCM. GCM is indeed started without delay because the
   // registration record has been found.
@@ skipping 33 matching lines @@
   ASSERT_EQ(1UL, last_account_mappings().size());
   const AccountMapping& actual_mapping = last_account_mappings()[0];
   EXPECT_EQ(expected_mapping.account_id, actual_mapping.account_id);
   EXPECT_EQ(expected_mapping.email, actual_mapping.email);
   EXPECT_EQ(expected_mapping.status, actual_mapping.status);
   EXPECT_EQ(expected_mapping.status_change_timestamp,
             actual_mapping.status_change_timestamp);
 }
 
 }  // namespace gcm