[GCM] Handling connection events in GCMAccountTracker

components/gcm_driver/gcm_account_mapper_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_account_mapper.h"
 
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
 #include "google_apis/gcm/engine/account_mapping.h"
 #include "google_apis/gcm/engine/gcm_store.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
 const char kGCMAccountMapperSenderId[] = "745476177629";
-const char kGCMAccountMapperAppId[] = "com.google.android.gms";
 const char kRegistrationId[] = "reg_id";
 
 AccountMapping MakeAccountMapping(const std::string& account_id,
                                   AccountMapping::MappingStatus status,
                                   const base::Time& status_change_timestamp,
                                   const std::string& last_message_id) {
   AccountMapping account_mapping;
   account_mapping.account_id = account_id;
   account_mapping.email = account_id + "@gmail.com";
   // account_mapping.access_token intentionally left empty.
@@ skipping 235 matching lines @@
 GCMAccountMapperTest::GCMAccountMapperTest() {
   Restart();
 }
 
 GCMAccountMapperTest::~GCMAccountMapperTest() {
 }
 
 void GCMAccountMapperTest::Restart() {
   if (account_mapper_)
     account_mapper_->ShutdownHandler();
+  gcm_driver_.RemoveAppHandler(kGCMAccountMapperAppId);
   account_mapper_.reset(new GCMAccountMapper(&gcm_driver_));
   scoped_ptr<base::SimpleTestClock> clock(new base::SimpleTestClock);
   clock_ = clock.get();
   account_mapper_->SetClockForTesting(clock.PassAs<base::Clock>());
 }
 
 // Tests the initialization of account mappings (from the store) when empty.
 // It also checks that initialization triggers registration ID request.
 TEST_F(GCMAccountMapperTest, InitializeAccountMappingsEmpty) {
   EXPECT_FALSE(gcm_driver().registration_id_requested());
@@ skipping 142 matching lines @@
   EXPECT_EQ(account_token.account_id, iter->account_id);
   EXPECT_EQ(account_token.access_token, iter->access_token);
   EXPECT_EQ(AccountMapping::ADDING, iter->status);
   EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
   EXPECT_EQ(gcm_driver().last_message_id(), iter->last_message_id);
 }
 
 // Tests status change from ADDING to MAPPED (Message is acknowledged).
 TEST_F(GCMAccountMapperTest, AddMappingMessageAcknowledged) {
   mapper()->Initialize(GCMAccountMapper::AccountMappings());
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
   gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
 
   std::vector<GCMClient::AccountTokenInfo> account_tokens;
   GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo("acc_id");
   account_tokens.push_back(account_token);
   mapper()->SetAccountTokens(account_tokens);
 
   clock()->SetNow(base::Time::Now());
   gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
   clock()->SetNow(base::Time::Now());
@@ skipping 16 matching lines @@
   EXPECT_EQ(account_token.access_token, iter->access_token);
   EXPECT_EQ(AccountMapping::MAPPED, iter->status);
   EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
   EXPECT_TRUE(iter->last_message_id.empty());
 }
 
 // Tests status change form ADDING to MAPPED (When message was acknowledged,
 // after Chrome was restarted).
 TEST_F(GCMAccountMapperTest, AddMappingMessageAckedAfterRestart) {
   mapper()->Initialize(GCMAccountMapper::AccountMappings());
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
   gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
 
   std::vector<GCMClient::AccountTokenInfo> account_tokens;
   GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo("acc_id");
   account_tokens.push_back(account_token);
   mapper()->SetAccountTokens(account_tokens);
 
   clock()->SetNow(base::Time::Now());
   gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
 
   Restart();
   GCMAccountMapper::AccountMappings stored_mappings;
   stored_mappings.push_back(gcm_driver().last_account_mapping());
   mapper()->Initialize(stored_mappings);
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
 
   clock()->SetNow(base::Time::Now());
   gcm_driver().AcknowledgeSend(gcm_driver().last_message_id());
 
   EXPECT_EQ(account_token.email, gcm_driver().last_account_mapping().email);
   EXPECT_EQ(account_token.account_id,
             gcm_driver().last_account_mapping().account_id);
   EXPECT_EQ(account_token.access_token,
             gcm_driver().last_account_mapping().access_token);
   EXPECT_EQ(AccountMapping::MAPPED, gcm_driver().last_account_mapping().status);
   EXPECT_EQ(clock()->Now(),
             gcm_driver().last_account_mapping().status_change_timestamp);
   EXPECT_TRUE(gcm_driver().last_account_mapping().last_message_id.empty());
 
   GCMAccountMapper::AccountMappings mappings = GetAccounts();
   GCMAccountMapper::AccountMappings::const_iterator iter = mappings.begin();
   EXPECT_EQ(account_token.email, iter->email);
   EXPECT_EQ(account_token.account_id, iter->account_id);
   EXPECT_EQ(account_token.access_token, iter->access_token);
   EXPECT_EQ(AccountMapping::MAPPED, iter->status);
   EXPECT_EQ(clock()->Now(), iter->status_change_timestamp);
   EXPECT_TRUE(iter->last_message_id.empty());
 }
 
 // Tests a case when ADD message times out for a new account.
 TEST_F(GCMAccountMapperTest, AddMappingMessageSendErrorForNewAccount) {
   mapper()->Initialize(GCMAccountMapper::AccountMappings());
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
   gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
 
   std::vector<GCMClient::AccountTokenInfo> account_tokens;
   GCMClient::AccountTokenInfo account_token = MakeAccountTokenInfo("acc_id");
   account_tokens.push_back(account_token);
   mapper()->SetAccountTokens(account_tokens);
 
   clock()->SetNow(base::Time::Now());
   gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
 
@@ skipping 13 matching lines @@
   // Start with one account that is mapped.
   base::Time status_change_timestamp = base::Time::Now();
   AccountMapping mapping = MakeAccountMapping("acc_id",
                                               AccountMapping::MAPPED,
                                               status_change_timestamp,
                                               "add_message_id");
 
   GCMAccountMapper::AccountMappings stored_mappings;
   stored_mappings.push_back(mapping);
   mapper()->Initialize(stored_mappings);
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
   gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
 
   clock()->SetNow(base::Time::Now());
   gcm_driver().MessageSendError("add_message_id");
 
   // No new message is sent because of the send error, as the token is stale.
   // Because the account was new, the entry should be deleted.
   EXPECT_TRUE(gcm_driver().last_message_id().empty());
 
   GCMAccountMapper::AccountMappings mappings = GetAccounts();
@@ skipping 87 matching lines @@
 TEST_F(GCMAccountMapperTest, RemoveMappingMessageAcknowledged) {
   // Start with one account that is mapped.
   AccountMapping mapping = MakeAccountMapping("acc_id",
                                               AccountMapping::MAPPED,
                                               base::Time::Now(),
                                               std::string());
 
   GCMAccountMapper::AccountMappings stored_mappings;
   stored_mappings.push_back(mapping);
   mapper()->Initialize(stored_mappings);
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
   gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
   clock()->SetNow(base::Time::Now());
 
   mapper()->SetAccountTokens(std::vector<GCMClient::AccountTokenInfo>());
   gcm_driver().CompleteSend(gcm_driver().last_message_id(), GCMClient::SUCCESS);
   gcm_driver().AcknowledgeSend(gcm_driver().last_message_id());
 
   EXPECT_EQ(mapping.account_id, gcm_driver().last_removed_account_id());
 
   GCMAccountMapper::AccountMappings mappings = GetAccounts();
   EXPECT_TRUE(mappings.empty());
 }
 
 // Tests that account removing proceeds, when a removing message is acked after
 // Chrome was restarted.
 TEST_F(GCMAccountMapperTest, RemoveMappingMessageAckedAfterRestart) {
   // Start with one account that is mapped.
   AccountMapping mapping = MakeAccountMapping("acc_id",
                                               AccountMapping::REMOVING,
                                               base::Time::Now(),
                                               "remove_message_id");
 
   GCMAccountMapper::AccountMappings stored_mappings;
   stored_mappings.push_back(mapping);
   mapper()->Initialize(stored_mappings);
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
 
   gcm_driver().AcknowledgeSend("remove_message_id");
 
   EXPECT_EQ(mapping.account_id, gcm_driver().last_removed_account_id());
 
   GCMAccountMapper::AccountMappings mappings = GetAccounts();
   EXPECT_TRUE(mappings.empty());
 }
 
 // Tests that account removing proceeds, when a removing message is acked after
 // Chrome was restarted.
 TEST_F(GCMAccountMapperTest, RemoveMappingMessageSendError) {
   // Start with one account that is mapped.
   base::Time status_change_timestamp = base::Time::Now();
   AccountMapping mapping = MakeAccountMapping("acc_id",
                                               AccountMapping::REMOVING,
                                               status_change_timestamp,
                                               "remove_message_id");
 
   GCMAccountMapper::AccountMappings stored_mappings;
   stored_mappings.push_back(mapping);
   mapper()->Initialize(stored_mappings);
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
 
   clock()->SetNow(base::Time::Now());
   gcm_driver().MessageSendError("remove_message_id");
 
   EXPECT_TRUE(gcm_driver().last_removed_account_id().empty());
 
   EXPECT_EQ(mapping.account_id, gcm_driver().last_account_mapping().account_id);
   EXPECT_EQ(mapping.email, gcm_driver().last_account_mapping().email);
   EXPECT_EQ(AccountMapping::REMOVING,
             gcm_driver().last_account_mapping().status);
@@ skipping 94 matching lines @@
   base::Time half_hour_ago = clock()->Now() - base::TimeDelta::FromMinutes(30);
   GCMAccountMapper::AccountMappings stored_mappings;
   stored_mappings.push_back(MakeAccountMapping(
       "acc_id_0", AccountMapping::ADDING, half_hour_ago, "acc_id_0_msg"));
   stored_mappings.push_back(MakeAccountMapping(
       "acc_id_1", AccountMapping::MAPPED, half_hour_ago, "acc_id_1_msg"));
   stored_mappings.push_back(MakeAccountMapping(
       "acc_id_2", AccountMapping::REMOVING, half_hour_ago, "acc_id_2_msg"));
 
   mapper()->Initialize(stored_mappings);
+  gcm_driver().AddAppHandler(kGCMAccountMapperAppId, mapper());
   gcm_driver().CompleteRegister(kRegistrationId, GCMClient::SUCCESS);
 
   GCMAccountMapper::AccountMappings expected_mappings(stored_mappings);
 
   // Finish messages after a restart.
   clock()->SetNow(base::Time::Now());
   gcm_driver().AcknowledgeSend(expected_mappings[0].last_message_id);
   expected_mappings[0].status_change_timestamp = clock()->Now();
   expected_mappings[0].status = AccountMapping::MAPPED;
   expected_mappings[0].last_message_id.clear();
@@ skipping 72 matching lines @@
   expected_mappings[1].status_change_timestamp = clock()->Now();
   expected_mappings[1].status = AccountMapping::MAPPED;
   expected_mappings[2].status_change_timestamp = clock()->Now();
   expected_mappings[2].status = AccountMapping::MAPPED;
 
   VerifyMappings(
       expected_mappings, GetAccounts(), "Step 6, Three mapped accounts");
 }
 
 }  // namespace gcm