[GCM] Passing GCMClient::AccountTokenInfo list to GCMDriver

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/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 50 matching lines @@
   for (std::map<std::string, std::string>::const_iterator iter = data.begin();
        iter != data.end();
        ++iter) {
     mcs_proto::AppData* app_data = data_message.add_app_data();
     app_data->set_key(iter->first);
     app_data->set_value(iter->second);
   }
   return MCSMessage(kDataMessageStanzaTag, data_message);
 }
 
+GCMClient::AccountTokenInfo MakeAccountToken(const std::string& email,
+                                             const std::string& token) {
+  GCMClient::AccountTokenInfo account_token;
+  account_token.email = email;
+  account_token.access_token = token;
+  return account_token;
+}
+
+std::map<std::string, std::string> MakeEmailToTokenMap(
+    const std::vector<GCMClient::AccountTokenInfo>& account_tokens) {
+  std::map<std::string, std::string> email_token_map;
+  for (std::vector<GCMClient::AccountTokenInfo>::const_iterator iter =
+           account_tokens.begin(); iter != account_tokens.end(); ++iter) {
+    email_token_map[iter->email] = iter->access_token;
+  }
+  return email_token_map;
+}
+
 class FakeMCSClient : public MCSClient {
  public:
   FakeMCSClient(base::Clock* clock,
                 ConnectionFactory* connection_factory,
                 GCMStore* gcm_store,
                 GCMStatsRecorder* recorder);
   virtual ~FakeMCSClient();
   virtual void Login(uint64 android_id, uint64 security_token) OVERRIDE;
   virtual void SendMessage(const MCSMessage& message) OVERRIDE;
 
@@ skipping 755 matching lines @@
   settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
-  std::map<std::string, std::string> account_tokens;
-  account_tokens["test_user1@gmail.com"] = "token1";
-  account_tokens["test_user2@gmail.com"] = "token2";
-  gcm_client()->SetAccountsForCheckin(account_tokens);
+  std::vector<GCMClient::AccountTokenInfo> account_tokens;
+  account_tokens.push_back(MakeAccountToken("test_user1@gmail.com", "token1"));
+  account_tokens.push_back(MakeAccountToken("test_user2@gmail.com", "token2"));
+  gcm_client()->SetAccountTokens(account_tokens);
 
   EXPECT_TRUE(device_checkin_info().last_checkin_accounts.empty());
   EXPECT_TRUE(device_checkin_info().accounts_set);
-  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+  EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
+            device_checkin_info().account_tokens);
 
   PumpLoopUntilIdle();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   accounts.insert("test_user2@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
   EXPECT_TRUE(device_checkin_info().accounts_set);
-  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+  EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
+            device_checkin_info().account_tokens);
 }
 
 // This test only checks that periodic checkin happens.
 TEST_F(GCMClientImplCheckinTest, CheckinWhenAccountRemoved) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
-  std::map<std::string, std::string> account_tokens;
-  account_tokens["test_user1@gmail.com"] = "token1";
-  account_tokens["test_user2@gmail.com"] = "token2";
-  gcm_client()->SetAccountsForCheckin(account_tokens);
+  std::vector<GCMClient::AccountTokenInfo> account_tokens;
+  account_tokens.push_back(MakeAccountToken("test_user1@gmail.com", "token1"));
+  account_tokens.push_back(MakeAccountToken("test_user2@gmail.com", "token2"));
+  gcm_client()->SetAccountTokens(account_tokens);
   PumpLoopUntilIdle();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
   EXPECT_EQ(2UL, device_checkin_info().last_checkin_accounts.size());
   EXPECT_TRUE(device_checkin_info().accounts_set);
-  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+  EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
+            device_checkin_info().account_tokens);
 
-  account_tokens.erase(account_tokens.find("test_user2@gmail.com"));
-  gcm_client()->SetAccountsForCheckin(account_tokens);
+  account_tokens.erase(account_tokens.begin() + 1);
+  gcm_client()->SetAccountTokens(account_tokens);
 
   PumpLoopUntilIdle();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
   EXPECT_TRUE(device_checkin_info().accounts_set);
-  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+  EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
+            device_checkin_info().account_tokens);
 }
 
 // This test only checks that periodic checkin happens.
 TEST_F(GCMClientImplCheckinTest, CheckinWhenAccountReplaced) {
   std::map<std::string, std::string> settings;
   settings["checkin_interval"] = base::IntToString(kSettingsCheckinInterval);
   settings["checkin_url"] = "http://alternative.url/checkin";
   settings["gcm_hostname"] = "alternative.gcm.host";
   settings["gcm_secure_port"] = "7777";
   settings["gcm_registration_url"] = "http://alternative.url/registration";
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
-  std::map<std::string, std::string> account_tokens;
-  account_tokens["test_user1@gmail.com"] = "token1";
-  gcm_client()->SetAccountsForCheckin(account_tokens);
+  std::vector<GCMClient::AccountTokenInfo> account_tokens;
+  account_tokens.push_back(MakeAccountToken("test_user1@gmail.com", "token1"));
+  gcm_client()->SetAccountTokens(account_tokens);
 
   PumpLoopUntilIdle();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
   std::set<std::string> accounts;
   accounts.insert("test_user1@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
 
   // This should trigger another checkin, because the list of accounts is
   // different.
-  account_tokens.erase(account_tokens.find("test_user1@gmail.com"));
-  account_tokens["test_user2@gmail.com"] = "token2";
-  gcm_client()->SetAccountsForCheckin(account_tokens);
+  account_tokens.clear();
+  account_tokens.push_back(MakeAccountToken("test_user2@gmail.com", "token2"));
+  gcm_client()->SetAccountTokens(account_tokens);
 
   PumpLoopUntilIdle();
   CompleteCheckin(kDeviceAndroidId,
                   kDeviceSecurityToken,
                   GServicesSettings::CalculateDigest(settings),
                   settings);
 
   accounts.clear();
   accounts.insert("test_user2@gmail.com");
   EXPECT_EQ(accounts, device_checkin_info().last_checkin_accounts);
   EXPECT_TRUE(device_checkin_info().accounts_set);
-  EXPECT_EQ(account_tokens, device_checkin_info().account_tokens);
+  EXPECT_EQ(MakeEmailToTokenMap(account_tokens),
+            device_checkin_info().account_tokens);
 }
 
 class GCMClientImplStartAndStopTest : public GCMClientImplTest {
 public:
   GCMClientImplStartAndStopTest();
   virtual ~GCMClientImplStartAndStopTest();
 
   virtual void SetUp() OVERRIDE;
 };
 
@@ skipping 36 matching lines @@
 TEST_F(GCMClientImplStartAndStopTest, StartStopAndRestartImmediately) {
   // Start the GCM and then stop and restart it immediately.
   gcm_client()->Start();
   gcm_client()->Stop();
   gcm_client()->Start();
 
   PumpLoopUntilIdle();
 }
 
 }  // namespace gcm