[GCM] Passing GCMClient::AccountTokenInfo list to GCMDriver

chrome/browser/services/gcm/gcm_account_tracker_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 "chrome/browser/services/gcm/gcm_account_tracker.h"
 
 #include <map>
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
@@ skipping 19 matching lines @@
 
 std::string GetValidTokenInfoResponse(const std::string account_key) {
   return std::string("{ \"id\": \"") + AccountKeyToObfuscatedId(account_key) +
          "\" }";
 }
 
 std::string MakeAccessToken(const std::string& account_key) {
   return "access_token-" + account_key;
 }
 
+GCMClient::AccountTokenInfo MakeAccountToken(const std::string& account_key) {
+  GCMClient::AccountTokenInfo token_info;
+  token_info.account_id = account_key;
+  token_info.email = account_key;
+  token_info.access_token = MakeAccessToken(account_key);
+  return token_info;
+}
+
+void VerifyAccountTokens(
+    const std::vector<GCMClient::AccountTokenInfo>& expected_tokens,
+    const std::vector<GCMClient::AccountTokenInfo>& actual_tokens) {
+  EXPECT_EQ(expected_tokens.size(), actual_tokens.size());
+  for (std::vector<GCMClient::AccountTokenInfo>::const_iterator
+           expected_iter = expected_tokens.begin(),
+           actual_iter = actual_tokens.begin();
+       expected_iter != expected_tokens.end() &&
+           actual_iter != actual_tokens.end();
+       ++expected_iter, ++actual_iter) {
+    EXPECT_EQ(expected_iter->account_id, actual_iter->account_id);
+    EXPECT_EQ(expected_iter->email, actual_iter->email);
+    EXPECT_EQ(expected_iter->access_token, actual_iter->access_token);
+  }
+}
+
 }  // namespace
 
 class GCMAccountTrackerTest : public testing::Test {
  public:
   GCMAccountTrackerTest();
   virtual ~GCMAccountTrackerTest();
 
   // Callback for the account tracker.
-  void UpdateAccounts(const std::map<std::string, std::string>& accounts);
+  void UpdateAccounts(const std::vector<GCMClient::AccountTokenInfo>& accounts);
 
   // Helpers to pass fake events to the tracker. Tests should have either a pair
   // of Start/FinishAccountSignIn or SignInAccount per account. Don't mix.
   // Call to SignOutAccount is not mandatory.
   void StartAccountSignIn(const std::string& account_key);
   void FinishAccountSignIn(const std::string& account_key);
   void SignInAccount(const std::string& account_key);
   void SignOutAccount(const std::string& account_key);
 
   // Helpers for dealing with OAuth2 access token requests.
   void IssueAccessToken(const std::string& account_key);
   void IssueError(const std::string& account_key);
 
   // Test results and helpers.
   void ResetResults();
   bool update_accounts_called() const { return update_accounts_called_; }
-  const std::map<std::string, std::string>& accounts() const {
+  const std::vector<GCMClient::AccountTokenInfo>& accounts() const {
     return accounts_;
   }
 
   // Accessor to account tracker.
   GCMAccountTracker* tracker() { return tracker_.get(); }
 
  private:
-  std::map<std::string, std::string> accounts_;
+  std::vector<GCMClient::AccountTokenInfo> accounts_;
   bool update_accounts_called_;
 
   base::MessageLoop message_loop_;
   net::TestURLFetcherFactory test_fetcher_factory_;
   scoped_ptr<FakeOAuth2TokenService> fake_token_service_;
   scoped_ptr<FakeIdentityProvider> fake_identity_provider_;
   scoped_ptr<GCMAccountTracker> tracker_;
 };
 
 GCMAccountTrackerTest::GCMAccountTrackerTest()
@@ skipping 13 matching lines @@
       base::Bind(&GCMAccountTrackerTest::UpdateAccounts,
                  base::Unretained(this))));
 }
 
 GCMAccountTrackerTest::~GCMAccountTrackerTest() {
   if (tracker_)
     tracker_->Shutdown();
 }
 
 void GCMAccountTrackerTest::UpdateAccounts(
-    const std::map<std::string, std::string>& accounts) {
+    const std::vector<GCMClient::AccountTokenInfo>& accounts) {
   update_accounts_called_ = true;
   accounts_ = accounts;
 }
 
 void GCMAccountTrackerTest::ResetResults() {
   accounts_.clear();
   update_accounts_called_ = false;
 }
 
 void GCMAccountTrackerTest::StartAccountSignIn(const std::string& account_key) {
@@ skipping 52 matching lines @@
   // We don't have any accounts to report, but given the inner account tracker
   // is still working we don't make a call with empty accounts list.
   EXPECT_FALSE(update_accounts_called());
 
   // This concludes the work of inner account tracker.
   FinishAccountSignIn(kAccountId1);
   IssueAccessToken(kAccountId1);
 
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  VerifyAccountTokens(expected_accounts, accounts());
   tracker()->Stop();
 }
 
 TEST_F(GCMAccountTrackerTest, MultipleAccounts) {
   StartAccountSignIn(kAccountId1);
   StartAccountSignIn(kAccountId2);
 
   tracker()->Start();
   EXPECT_FALSE(update_accounts_called());
 
   FinishAccountSignIn(kAccountId1);
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(update_accounts_called());
 
   FinishAccountSignIn(kAccountId2);
   IssueAccessToken(kAccountId2);
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  expected_accounts[kAccountId2] = MakeAccessToken(kAccountId2);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  expected_accounts.push_back(MakeAccountToken(kAccountId2));
+  VerifyAccountTokens(expected_accounts, accounts());
 
   tracker()->Stop();
 }
 
 TEST_F(GCMAccountTrackerTest, AccountAdded) {
   tracker()->Start();
   ResetResults();
 
   SignInAccount(kAccountId1);
   EXPECT_FALSE(update_accounts_called());
 
   IssueAccessToken(kAccountId1);
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  VerifyAccountTokens(expected_accounts, accounts());
 
   tracker()->Stop();
 }
 
 TEST_F(GCMAccountTrackerTest, AccountRemoved) {
   SignInAccount(kAccountId1);
   SignInAccount(kAccountId2);
 
   tracker()->Start();
   IssueAccessToken(kAccountId1);
   IssueAccessToken(kAccountId2);
   EXPECT_TRUE(update_accounts_called());
 
   ResetResults();
   EXPECT_FALSE(update_accounts_called());
 
   SignOutAccount(kAccountId2);
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  VerifyAccountTokens(expected_accounts, accounts());
 
   tracker()->Stop();
 }
 
 TEST_F(GCMAccountTrackerTest, GetTokenFailed) {
   SignInAccount(kAccountId1);
   SignInAccount(kAccountId2);
 
   tracker()->Start();
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(update_accounts_called());
 
   IssueError(kAccountId2);
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  VerifyAccountTokens(expected_accounts, accounts());
 
   tracker()->Stop();
 }
 
 TEST_F(GCMAccountTrackerTest, GetTokenFailedAccountRemoved) {
   SignInAccount(kAccountId1);
   SignInAccount(kAccountId2);
 
   tracker()->Start();
   IssueAccessToken(kAccountId1);
   IssueError(kAccountId2);
 
   ResetResults();
   SignOutAccount(kAccountId2);
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  VerifyAccountTokens(expected_accounts, accounts());
 
   tracker()->Stop();
 }
 
 TEST_F(GCMAccountTrackerTest, AccountRemovedWhileRequestsPending) {
   SignInAccount(kAccountId1);
   SignInAccount(kAccountId2);
 
   tracker()->Start();
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(update_accounts_called());
 
   SignOutAccount(kAccountId2);
   IssueAccessToken(kAccountId2);
   EXPECT_TRUE(update_accounts_called());
 
-  std::map<std::string, std::string> expected_accounts;
-  expected_accounts[kAccountId1] = MakeAccessToken(kAccountId1);
-  EXPECT_EQ(expected_accounts, accounts());
+  std::vector<GCMClient::AccountTokenInfo> expected_accounts;
+  expected_accounts.push_back(MakeAccountToken(kAccountId1));
+  VerifyAccountTokens(expected_accounts, accounts());
 
   tracker()->Stop();
 }
 
 // TODO(fgorski): Add test for adding account after removal >> make sure it does
 // not mark removal.
 
 }  // namespace gcm