components/gcm_driver/gcm_account_tracker_unittest.cc - chromium/src - Git at Google

 // 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_tracker.h"

 #include <map>
 #include <memory>
 #include <string>
 #include <utility>

 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "components/gcm_driver/fake_gcm_driver.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
 #include "components/signin/core/browser/fake_signin_manager.h"
 #include "components/signin/core/browser/test_signin_client.h"
 #include "components/sync_preferences/testing_pref_service_syncable.h"
 #include "google_apis/gaia/fake_oauth2_token_service.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace gcm {

 namespace {

 #if defined(OS_CHROMEOS)
 using SigninManagerForTest = FakeSigninManagerBase;
 #else
 using SigninManagerForTest = FakeSigninManager;
 #endif  // OS_CHROMEOS

 const char kAccountId1[] = "account_1";
 const char kAccountId2[] = "account_2";

 std::string AccountKeyToObfuscatedId(const std::string& email) {
   return "obfid-" + email;
 }

 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);
   }
 }

 // This version of FakeGCMDriver is customized around handling accounts and
 // connection events for testing GCMAccountTracker.
 class CustomFakeGCMDriver : public FakeGCMDriver {
  public:
   CustomFakeGCMDriver();
   ~CustomFakeGCMDriver() override;

   // GCMDriver overrides:
   void SetAccountTokens(
       const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
   void AddConnectionObserver(GCMConnectionObserver* observer) override;
   void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
   bool IsConnected() const override { return connected_; }
   base::Time GetLastTokenFetchTime() override;
   void SetLastTokenFetchTime(const base::Time& time) override;

   // Test results and helpers.
   void SetConnected(bool connected);
   void ResetResults();
   bool update_accounts_called() const { return update_accounts_called_; }
   const std::vector<GCMClient::AccountTokenInfo>& accounts() const {
     return accounts_;
   }
   const GCMConnectionObserver* last_connection_observer() const {
     return last_connection_observer_;
   }
   const GCMConnectionObserver* last_removed_connection_observer() const {
     return removed_connection_observer_;
   }

  private:
   bool connected_;
   std::vector<GCMClient::AccountTokenInfo> accounts_;
   bool update_accounts_called_;
   GCMConnectionObserver* last_connection_observer_;
   GCMConnectionObserver* removed_connection_observer_;
   net::IPEndPoint ip_endpoint_;
   base::Time last_token_fetch_time_;

   DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
 };

 CustomFakeGCMDriver::CustomFakeGCMDriver()
     : connected_(true),
       update_accounts_called_(false),
       last_connection_observer_(nullptr),
       removed_connection_observer_(nullptr) {}

 CustomFakeGCMDriver::~CustomFakeGCMDriver() {
 }

 void CustomFakeGCMDriver::SetAccountTokens(
     const std::vector<GCMClient::AccountTokenInfo>& accounts) {
   update_accounts_called_ = true;
   accounts_ = accounts;
 }

 void CustomFakeGCMDriver::AddConnectionObserver(
     GCMConnectionObserver* observer) {
   last_connection_observer_ = observer;
 }

 void CustomFakeGCMDriver::RemoveConnectionObserver(
     GCMConnectionObserver* observer) {
   removed_connection_observer_ = observer;
 }

 void CustomFakeGCMDriver::SetConnected(bool connected) {
   connected_ = connected;
   if (connected && last_connection_observer_)
     last_connection_observer_->OnConnected(ip_endpoint_);
 }

 void CustomFakeGCMDriver::ResetResults() {
   accounts_.clear();
   update_accounts_called_ = false;
   last_connection_observer_ = nullptr;
   removed_connection_observer_ = nullptr;
 }


 base::Time CustomFakeGCMDriver::GetLastTokenFetchTime() {
   return last_token_fetch_time_;
 }

 void CustomFakeGCMDriver::SetLastTokenFetchTime(const base::Time& time) {
   last_token_fetch_time_ = time;
 }

 }  // namespace

 class GCMAccountTrackerTest : public testing::Test {
  public:
   GCMAccountTrackerTest();
   ~GCMAccountTrackerTest() override;

   // Helpers to pass fake info to the tracker. Tests should have either a pair
   // of Start(Primary)/FinishAccountAddition or Add(Primary)Account per
   // account. Don't mix.
   // Call to RemoveAccount is not mandatory.
   void StartAccountAddition(const std::string& account_key);
   void StartPrimaryAccountAddition(const std::string& account_key);
   void FinishAccountAddition(const std::string& account_key);
   void AddAccount(const std::string& account_key);
   void AddPrimaryAccount(const std::string& account_key);
   void RemoveAccount(const std::string& account_key);

   // Helpers for dealing with OAuth2 access token requests.
   void IssueAccessToken(const std::string& account_key);
   void IssueExpiredAccessToken(const std::string& account_key);
   void IssueError(const std::string& account_key);

   // Accessors to account tracker and gcm driver.
   GCMAccountTracker* tracker() { return tracker_.get(); }
   CustomFakeGCMDriver* driver() { return &driver_; }

   // Accessors to private methods of account tracker.
   bool IsFetchingRequired() const;
   bool IsTokenReportingRequired() const;
   base::TimeDelta GetTimeToNextTokenReporting() const;

  private:
   CustomFakeGCMDriver driver_;

   base::MessageLoop message_loop_;
   net::TestURLFetcherFactory test_fetcher_factory_;
   sync_preferences::TestingPrefServiceSyncable pref_service_;
   AccountTrackerService account_tracker_service_;
   std::unique_ptr<TestSigninClient> test_signin_client_;
   std::unique_ptr<SigninManagerForTest> fake_signin_manager_;
   std::unique_ptr<FakeProfileOAuth2TokenService> fake_token_service_;
   std::unique_ptr<GCMAccountTracker> tracker_;
 };

 GCMAccountTrackerTest::GCMAccountTrackerTest() {
   fake_token_service_.reset(new FakeProfileOAuth2TokenService());

   test_signin_client_.reset(new TestSigninClient(&pref_service_));
 #if defined(OS_CHROMEOS)
   fake_signin_manager_.reset(new SigninManagerForTest(
       test_signin_client_.get(), &account_tracker_service_));
 #else
   fake_signin_manager_.reset(new SigninManagerForTest(
       test_signin_client_.get(), fake_token_service_.get(),
       &account_tracker_service_, nullptr));
 #endif

   AccountTrackerService::RegisterPrefs(pref_service_.registry());
   SigninManagerBase::RegisterProfilePrefs(pref_service_.registry());
   SigninManagerBase::RegisterPrefs(pref_service_.registry());
   account_tracker_service_.Initialize(test_signin_client_.get());

   std::unique_ptr<AccountTracker> gaia_account_tracker(new AccountTracker(
       fake_signin_manager_.get(), fake_token_service_.get(),
       new net::TestURLRequestContextGetter(message_loop_.task_runner())));

   tracker_.reset(new GCMAccountTracker(std::move(gaia_account_tracker),
                                        fake_token_service_.get(), &driver_));
 }

 GCMAccountTrackerTest::~GCMAccountTrackerTest() {
   if (tracker_)
     tracker_->Shutdown();
 }

 void GCMAccountTrackerTest::StartAccountAddition(
     const std::string& account_key) {
   fake_token_service_->UpdateCredentials(account_key, "fake_refresh_token");
 }

 void GCMAccountTrackerTest::StartPrimaryAccountAddition(
     const std::string& account_key) {
 // NOTE: Setting of the primary account info must be done first on ChromeOS
 // to ensure that AccountTracker and GCMAccountTracker respond as expected
 // when the token is added to the token service.
 // TODO(blundell): On non-ChromeOS, it would be good to add tests wherein
 // setting of the primary account is done afterward to check that the flow
 // that ensues from the GoogleSigninSucceeded callback firing works as
 // expected.
 #if defined(OS_CHROMEOS)
   fake_signin_manager_->SignIn(account_key);
 #else
   fake_signin_manager_->SignIn(account_key, account_key, "" /* password */);
 #endif
   StartAccountAddition(account_key);
 }

 void GCMAccountTrackerTest::FinishAccountAddition(
     const std::string& account_key) {
   IssueAccessToken(account_key);

   net::TestURLFetcher* fetcher = test_fetcher_factory_.GetFetcherByID(
       gaia::GaiaOAuthClient::kUrlFetcherId);
   ASSERT_TRUE(fetcher);
   fetcher->set_response_code(net::HTTP_OK);
   fetcher->SetResponseString(GetValidTokenInfoResponse(account_key));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
 }

 void GCMAccountTrackerTest::AddPrimaryAccount(const std::string& account_key) {
   StartPrimaryAccountAddition(account_key);
   FinishAccountAddition(account_key);
 }

 void GCMAccountTrackerTest::AddAccount(const std::string& account_key) {
   StartAccountAddition(account_key);
   FinishAccountAddition(account_key);
 }

 void GCMAccountTrackerTest::RemoveAccount(const std::string& account_key) {
   fake_token_service_->RevokeCredentials(account_key);
 }

 void GCMAccountTrackerTest::IssueAccessToken(const std::string& account_key) {
   fake_token_service_->IssueAllTokensForAccount(
       account_key, MakeAccessToken(account_key), base::Time::Max());
 }

 void GCMAccountTrackerTest::IssueExpiredAccessToken(
     const std::string& account_key) {
   fake_token_service_->IssueAllTokensForAccount(
       account_key, MakeAccessToken(account_key), base::Time::Now());
 }

 void GCMAccountTrackerTest::IssueError(const std::string& account_key) {
   fake_token_service_->IssueErrorForAllPendingRequestsForAccount(
       account_key,
       GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
 }

 bool GCMAccountTrackerTest::IsFetchingRequired() const {
   return tracker_->IsTokenFetchingRequired();
 }

 bool GCMAccountTrackerTest::IsTokenReportingRequired() const {
   return tracker_->IsTokenReportingRequired();
 }

 base::TimeDelta GCMAccountTrackerTest::GetTimeToNextTokenReporting() const {
   return tracker_->GetTimeToNextTokenReporting();
 }

 TEST_F(GCMAccountTrackerTest, NoAccounts) {
   EXPECT_FALSE(driver()->update_accounts_called());
   tracker()->Start();
   // Callback should not be called if there where no accounts provided.
   EXPECT_FALSE(driver()->update_accounts_called());
   EXPECT_TRUE(driver()->accounts().empty());
 }

 // Verifies that callback is called after a token is issued for a single account
 // with a specific scope. In this scenario, the underlying account tracker is
 // still working when the CompleteCollectingTokens is called for the first time.
 TEST_F(GCMAccountTrackerTest, SingleAccount) {
   StartPrimaryAccountAddition(kAccountId1);

   tracker()->Start();
   // 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(driver()->update_accounts_called());

   // This concludes the work of inner account tracker.
   FinishAccountAddition(kAccountId1);
   IssueAccessToken(kAccountId1);

   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 TEST_F(GCMAccountTrackerTest, MultipleAccounts) {
   StartPrimaryAccountAddition(kAccountId1);

   StartAccountAddition(kAccountId2);

   tracker()->Start();
   EXPECT_FALSE(driver()->update_accounts_called());

   FinishAccountAddition(kAccountId1);
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(driver()->update_accounts_called());

   FinishAccountAddition(kAccountId2);
   IssueAccessToken(kAccountId2);
   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   expected_accounts.push_back(MakeAccountToken(kAccountId2));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 TEST_F(GCMAccountTrackerTest, AccountAdded) {
   tracker()->Start();
   driver()->ResetResults();

   AddPrimaryAccount(kAccountId1);
   EXPECT_FALSE(driver()->update_accounts_called());

   IssueAccessToken(kAccountId1);
   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 TEST_F(GCMAccountTrackerTest, AccountRemoved) {
   AddPrimaryAccount(kAccountId1);
   AddAccount(kAccountId2);

   tracker()->Start();
   IssueAccessToken(kAccountId1);
   IssueAccessToken(kAccountId2);
   EXPECT_TRUE(driver()->update_accounts_called());

   driver()->ResetResults();
   EXPECT_FALSE(driver()->update_accounts_called());

   RemoveAccount(kAccountId2);
   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 TEST_F(GCMAccountTrackerTest, GetTokenFailed) {
   AddPrimaryAccount(kAccountId1);
   AddAccount(kAccountId2);

   tracker()->Start();
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(driver()->update_accounts_called());

   IssueError(kAccountId2);

   // Failed token is not retried any more. Account marked as removed.
   EXPECT_EQ(0UL, tracker()->get_pending_token_request_count());
   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 TEST_F(GCMAccountTrackerTest, GetTokenFailedAccountRemoved) {
   AddPrimaryAccount(kAccountId1);
   AddAccount(kAccountId2);

   tracker()->Start();
   IssueAccessToken(kAccountId1);

   driver()->ResetResults();
   RemoveAccount(kAccountId2);
   IssueError(kAccountId2);

   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 TEST_F(GCMAccountTrackerTest, AccountRemovedWhileRequestsPending) {
   AddPrimaryAccount(kAccountId1);
   AddAccount(kAccountId2);

   tracker()->Start();
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(driver()->update_accounts_called());

   RemoveAccount(kAccountId2);
   IssueAccessToken(kAccountId2);
   EXPECT_TRUE(driver()->update_accounts_called());

   std::vector<GCMClient::AccountTokenInfo> expected_accounts;
   expected_accounts.push_back(MakeAccountToken(kAccountId1));
   VerifyAccountTokens(expected_accounts, driver()->accounts());
 }

 // Makes sure that tracker observes GCM connection when running.
 TEST_F(GCMAccountTrackerTest, TrackerObservesConnection) {
   EXPECT_EQ(nullptr, driver()->last_connection_observer());
   tracker()->Start();
   EXPECT_EQ(tracker(), driver()->last_connection_observer());
   tracker()->Shutdown();
   EXPECT_EQ(tracker(), driver()->last_removed_connection_observer());
 }

 // Makes sure that token fetching happens only after connection is established.
 TEST_F(GCMAccountTrackerTest, PostponeTokenFetchingUntilConnected) {
   driver()->SetConnected(false);
   StartPrimaryAccountAddition(kAccountId1);
   tracker()->Start();
   FinishAccountAddition(kAccountId1);

   EXPECT_EQ(0UL, tracker()->get_pending_token_request_count());
   driver()->SetConnected(true);

   EXPECT_EQ(1UL, tracker()->get_pending_token_request_count());
 }

 TEST_F(GCMAccountTrackerTest, InvalidateExpiredTokens) {
   StartPrimaryAccountAddition(kAccountId1);
   StartAccountAddition(kAccountId2);
   tracker()->Start();
   FinishAccountAddition(kAccountId1);
   FinishAccountAddition(kAccountId2);

   EXPECT_EQ(2UL, tracker()->get_pending_token_request_count());

   IssueExpiredAccessToken(kAccountId1);
   IssueAccessToken(kAccountId2);
   // Because the first token is expired, we expect the sanitize to kick in and
   // clean it up before the SetAccessToken is called. This also means a new
   // token request will be issued
   EXPECT_FALSE(driver()->update_accounts_called());
   EXPECT_EQ(1UL, tracker()->get_pending_token_request_count());
 }

 // Testing for whether there are still more tokens to be fetched. Typically the
 // need for token fetching triggers immediate request, unless there is no
 // connection, that is why connection is set on and off in this test.
 TEST_F(GCMAccountTrackerTest, IsTokenFetchingRequired) {
   tracker()->Start();
   driver()->SetConnected(false);
   EXPECT_FALSE(IsFetchingRequired());
   StartPrimaryAccountAddition(kAccountId1);
   FinishAccountAddition(kAccountId1);
   EXPECT_TRUE(IsFetchingRequired());

   driver()->SetConnected(true);
   EXPECT_FALSE(IsFetchingRequired());  // Indicates that fetching has started.
   IssueAccessToken(kAccountId1);
   EXPECT_FALSE(IsFetchingRequired());

   driver()->SetConnected(false);
   StartAccountAddition(kAccountId2);
   FinishAccountAddition(kAccountId2);
   EXPECT_TRUE(IsFetchingRequired());

   IssueExpiredAccessToken(kAccountId2);
   // Make sure that if the token was expired it is still needed.
   EXPECT_TRUE(IsFetchingRequired());
 }

 // Tests what is the expected time to the next token fetching.
 TEST_F(GCMAccountTrackerTest, GetTimeToNextTokenReporting) {
   tracker()->Start();
   // At this point the last token fetch time is never.
   EXPECT_EQ(base::TimeDelta(), GetTimeToNextTokenReporting());

   // Regular case. The tokens have been just reported.
   driver()->SetLastTokenFetchTime(base::Time::Now());
   EXPECT_TRUE(GetTimeToNextTokenReporting() <=
                   base::TimeDelta::FromSeconds(12 * 60 * 60));

   // A case when gcm driver is not yet initialized.
   driver()->SetLastTokenFetchTime(base::Time::Max());
   EXPECT_EQ(base::TimeDelta::FromSeconds(12 * 60 * 60),
             GetTimeToNextTokenReporting());

   // A case when token reporting calculation is expected to result in more than
   // 12 hours, in which case we expect exactly 12 hours.
   driver()->SetLastTokenFetchTime(base::Time::Now() +
       base::TimeDelta::FromDays(2));
   EXPECT_EQ(base::TimeDelta::FromSeconds(12 * 60 * 60),
             GetTimeToNextTokenReporting());
 }

 // Tests conditions when token reporting is required.
 TEST_F(GCMAccountTrackerTest, IsTokenReportingRequired) {
   tracker()->Start();
   // Required because it is overdue.
   EXPECT_TRUE(IsTokenReportingRequired());

   // Not required because it just happened.
   driver()->SetLastTokenFetchTime(base::Time::Now());
   EXPECT_FALSE(IsTokenReportingRequired());

   AddPrimaryAccount(kAccountId1);
   IssueAccessToken(kAccountId1);
   driver()->ResetResults();
   // Reporting was triggered, which means testing for required will give false,
   // but we have the update call.
   RemoveAccount(kAccountId1);
   EXPECT_TRUE(driver()->update_accounts_called());
   EXPECT_FALSE(IsTokenReportingRequired());
 }

 // TODO(fgorski): Add test for adding account after removal >> make sure it does
 // not mark removal.

 }  // namespace gcm
	// 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_tracker.h"

	#include <map>
	#include <memory>
	#include <string>
	#include <utility>

	#include "base/macros.h"
	#include "base/message_loop/message_loop.h"
	#include "components/gcm_driver/fake_gcm_driver.h"
	#include "components/signin/core/browser/account_tracker_service.h"
	#include "components/signin/core/browser/fake_profile_oauth2_token_service.h"
	#include "components/signin/core/browser/fake_signin_manager.h"
	#include "components/signin/core/browser/test_signin_client.h"
	#include "components/sync_preferences/testing_pref_service_syncable.h"
	#include "google_apis/gaia/fake_oauth2_token_service.h"
	#include "google_apis/gaia/google_service_auth_error.h"
	#include "net/http/http_status_code.h"
	#include "net/url_request/test_url_fetcher_factory.h"
	#include "net/url_request/url_request_test_util.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace gcm {

	namespace {

	#if defined(OS_CHROMEOS)
	using SigninManagerForTest = FakeSigninManagerBase;
	#else
	using SigninManagerForTest = FakeSigninManager;
	#endif // OS_CHROMEOS

	const char kAccountId1[] = "account_1";
	const char kAccountId2[] = "account_2";

	std::string AccountKeyToObfuscatedId(const std::string& email) {
	return "obfid-" + email;
	}

	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);
	}
	}

	// This version of FakeGCMDriver is customized around handling accounts and
	// connection events for testing GCMAccountTracker.
	class CustomFakeGCMDriver : public FakeGCMDriver {
	public:
	CustomFakeGCMDriver();
	~CustomFakeGCMDriver() override;

	// GCMDriver overrides:
	void SetAccountTokens(
	const std::vector<GCMClient::AccountTokenInfo>& account_tokens) override;
	void AddConnectionObserver(GCMConnectionObserver* observer) override;
	void RemoveConnectionObserver(GCMConnectionObserver* observer) override;
	bool IsConnected() const override { return connected_; }
	base::Time GetLastTokenFetchTime() override;
	void SetLastTokenFetchTime(const base::Time& time) override;

	// Test results and helpers.
	void SetConnected(bool connected);
	void ResetResults();
	bool update_accounts_called() const { return update_accounts_called_; }
	const std::vector<GCMClient::AccountTokenInfo>& accounts() const {
	return accounts_;
	}
	const GCMConnectionObserver* last_connection_observer() const {
	return last_connection_observer_;
	}
	const GCMConnectionObserver* last_removed_connection_observer() const {
	return removed_connection_observer_;
	}

	private:
	bool connected_;
	std::vector<GCMClient::AccountTokenInfo> accounts_;
	bool update_accounts_called_;
	GCMConnectionObserver* last_connection_observer_;
	GCMConnectionObserver* removed_connection_observer_;
	net::IPEndPoint ip_endpoint_;
	base::Time last_token_fetch_time_;

	DISALLOW_COPY_AND_ASSIGN(CustomFakeGCMDriver);
	};

	CustomFakeGCMDriver::CustomFakeGCMDriver()
	: connected_(true),
	update_accounts_called_(false),
	last_connection_observer_(nullptr),
	removed_connection_observer_(nullptr) {}

	CustomFakeGCMDriver::~CustomFakeGCMDriver() {
	}

	void CustomFakeGCMDriver::SetAccountTokens(
	const std::vector<GCMClient::AccountTokenInfo>& accounts) {
	update_accounts_called_ = true;
	accounts_ = accounts;
	}

	void CustomFakeGCMDriver::AddConnectionObserver(
	GCMConnectionObserver* observer) {
	last_connection_observer_ = observer;
	}

	void CustomFakeGCMDriver::RemoveConnectionObserver(
	GCMConnectionObserver* observer) {
	removed_connection_observer_ = observer;
	}

	void CustomFakeGCMDriver::SetConnected(bool connected) {
	connected_ = connected;
	if (connected && last_connection_observer_)
	last_connection_observer_->OnConnected(ip_endpoint_);
	}

	void CustomFakeGCMDriver::ResetResults() {
	accounts_.clear();
	update_accounts_called_ = false;
	last_connection_observer_ = nullptr;
	removed_connection_observer_ = nullptr;
	}


	base::Time CustomFakeGCMDriver::GetLastTokenFetchTime() {
	return last_token_fetch_time_;
	}

	void CustomFakeGCMDriver::SetLastTokenFetchTime(const base::Time& time) {
	last_token_fetch_time_ = time;
	}

	} // namespace

	class GCMAccountTrackerTest : public testing::Test {
	public:
	GCMAccountTrackerTest();
	~GCMAccountTrackerTest() override;

	// Helpers to pass fake info to the tracker. Tests should have either a pair
	// of Start(Primary)/FinishAccountAddition or Add(Primary)Account per
	// account. Don't mix.
	// Call to RemoveAccount is not mandatory.
	void StartAccountAddition(const std::string& account_key);
	void StartPrimaryAccountAddition(const std::string& account_key);
	void FinishAccountAddition(const std::string& account_key);
	void AddAccount(const std::string& account_key);
	void AddPrimaryAccount(const std::string& account_key);
	void RemoveAccount(const std::string& account_key);

	// Helpers for dealing with OAuth2 access token requests.
	void IssueAccessToken(const std::string& account_key);
	void IssueExpiredAccessToken(const std::string& account_key);
	void IssueError(const std::string& account_key);

	// Accessors to account tracker and gcm driver.
	GCMAccountTracker* tracker() { return tracker_.get(); }
	CustomFakeGCMDriver* driver() { return &driver_; }

	// Accessors to private methods of account tracker.
	bool IsFetchingRequired() const;
	bool IsTokenReportingRequired() const;
	base::TimeDelta GetTimeToNextTokenReporting() const;

	private:
	CustomFakeGCMDriver driver_;

	base::MessageLoop message_loop_;
	net::TestURLFetcherFactory test_fetcher_factory_;
	sync_preferences::TestingPrefServiceSyncable pref_service_;
	AccountTrackerService account_tracker_service_;
	std::unique_ptr<TestSigninClient> test_signin_client_;
	std::unique_ptr<SigninManagerForTest> fake_signin_manager_;
	std::unique_ptr<FakeProfileOAuth2TokenService> fake_token_service_;
	std::unique_ptr<GCMAccountTracker> tracker_;
	};

	GCMAccountTrackerTest::GCMAccountTrackerTest() {
	fake_token_service_.reset(new FakeProfileOAuth2TokenService());

	test_signin_client_.reset(new TestSigninClient(&pref_service_));
	#if defined(OS_CHROMEOS)
	fake_signin_manager_.reset(new SigninManagerForTest(
	test_signin_client_.get(), &account_tracker_service_));
	#else
	fake_signin_manager_.reset(new SigninManagerForTest(
	test_signin_client_.get(), fake_token_service_.get(),
	&account_tracker_service_, nullptr));
	#endif

	AccountTrackerService::RegisterPrefs(pref_service_.registry());
	SigninManagerBase::RegisterProfilePrefs(pref_service_.registry());
	SigninManagerBase::RegisterPrefs(pref_service_.registry());
	account_tracker_service_.Initialize(test_signin_client_.get());

	std::unique_ptr<AccountTracker> gaia_account_tracker(new AccountTracker(
	fake_signin_manager_.get(), fake_token_service_.get(),
	new net::TestURLRequestContextGetter(message_loop_.task_runner())));

	tracker_.reset(new GCMAccountTracker(std::move(gaia_account_tracker),
	fake_token_service_.get(), &driver_));
	}

	GCMAccountTrackerTest::~GCMAccountTrackerTest() {
	if (tracker_)
	tracker_->Shutdown();
	}

	void GCMAccountTrackerTest::StartAccountAddition(
	const std::string& account_key) {
	fake_token_service_->UpdateCredentials(account_key, "fake_refresh_token");
	}

	void GCMAccountTrackerTest::StartPrimaryAccountAddition(
	const std::string& account_key) {
	// NOTE: Setting of the primary account info must be done first on ChromeOS
	// to ensure that AccountTracker and GCMAccountTracker respond as expected
	// when the token is added to the token service.
	// TODO(blundell): On non-ChromeOS, it would be good to add tests wherein
	// setting of the primary account is done afterward to check that the flow
	// that ensues from the GoogleSigninSucceeded callback firing works as
	// expected.
	#if defined(OS_CHROMEOS)
	fake_signin_manager_->SignIn(account_key);
	#else
	fake_signin_manager_->SignIn(account_key, account_key, "" /* password */);
	#endif
	StartAccountAddition(account_key);
	}

	void GCMAccountTrackerTest::FinishAccountAddition(
	const std::string& account_key) {
	IssueAccessToken(account_key);

	net::TestURLFetcher* fetcher = test_fetcher_factory_.GetFetcherByID(
	gaia::GaiaOAuthClient::kUrlFetcherId);
	ASSERT_TRUE(fetcher);
	fetcher->set_response_code(net::HTTP_OK);
	fetcher->SetResponseString(GetValidTokenInfoResponse(account_key));
	fetcher->delegate()->OnURLFetchComplete(fetcher);
	}

	void GCMAccountTrackerTest::AddPrimaryAccount(const std::string& account_key) {
	StartPrimaryAccountAddition(account_key);
	FinishAccountAddition(account_key);
	}

	void GCMAccountTrackerTest::AddAccount(const std::string& account_key) {
	StartAccountAddition(account_key);
	FinishAccountAddition(account_key);
	}

	void GCMAccountTrackerTest::RemoveAccount(const std::string& account_key) {
	fake_token_service_->RevokeCredentials(account_key);
	}

	void GCMAccountTrackerTest::IssueAccessToken(const std::string& account_key) {
	fake_token_service_->IssueAllTokensForAccount(
	account_key, MakeAccessToken(account_key), base::Time::Max());
	}

	void GCMAccountTrackerTest::IssueExpiredAccessToken(
	const std::string& account_key) {
	fake_token_service_->IssueAllTokensForAccount(
	account_key, MakeAccessToken(account_key), base::Time::Now());
	}

	void GCMAccountTrackerTest::IssueError(const std::string& account_key) {
	fake_token_service_->IssueErrorForAllPendingRequestsForAccount(
	account_key,
	GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE));
	}

	bool GCMAccountTrackerTest::IsFetchingRequired() const {
	return tracker_->IsTokenFetchingRequired();
	}

	bool GCMAccountTrackerTest::IsTokenReportingRequired() const {
	return tracker_->IsTokenReportingRequired();
	}

	base::TimeDelta GCMAccountTrackerTest::GetTimeToNextTokenReporting() const {
	return tracker_->GetTimeToNextTokenReporting();
	}

	TEST_F(GCMAccountTrackerTest, NoAccounts) {
	EXPECT_FALSE(driver()->update_accounts_called());
	tracker()->Start();
	// Callback should not be called if there where no accounts provided.
	EXPECT_FALSE(driver()->update_accounts_called());
	EXPECT_TRUE(driver()->accounts().empty());
	}

	// Verifies that callback is called after a token is issued for a single account
	// with a specific scope. In this scenario, the underlying account tracker is
	// still working when the CompleteCollectingTokens is called for the first time.
	TEST_F(GCMAccountTrackerTest, SingleAccount) {
	StartPrimaryAccountAddition(kAccountId1);

	tracker()->Start();
	// 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(driver()->update_accounts_called());

	// This concludes the work of inner account tracker.
	FinishAccountAddition(kAccountId1);
	IssueAccessToken(kAccountId1);

	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	TEST_F(GCMAccountTrackerTest, MultipleAccounts) {
	StartPrimaryAccountAddition(kAccountId1);

	StartAccountAddition(kAccountId2);

	tracker()->Start();
	EXPECT_FALSE(driver()->update_accounts_called());

	FinishAccountAddition(kAccountId1);
	IssueAccessToken(kAccountId1);
	EXPECT_FALSE(driver()->update_accounts_called());

	FinishAccountAddition(kAccountId2);
	IssueAccessToken(kAccountId2);
	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	expected_accounts.push_back(MakeAccountToken(kAccountId2));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	TEST_F(GCMAccountTrackerTest, AccountAdded) {
	tracker()->Start();
	driver()->ResetResults();

	AddPrimaryAccount(kAccountId1);
	EXPECT_FALSE(driver()->update_accounts_called());

	IssueAccessToken(kAccountId1);
	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	TEST_F(GCMAccountTrackerTest, AccountRemoved) {
	AddPrimaryAccount(kAccountId1);
	AddAccount(kAccountId2);

	tracker()->Start();
	IssueAccessToken(kAccountId1);
	IssueAccessToken(kAccountId2);
	EXPECT_TRUE(driver()->update_accounts_called());

	driver()->ResetResults();
	EXPECT_FALSE(driver()->update_accounts_called());

	RemoveAccount(kAccountId2);
	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	TEST_F(GCMAccountTrackerTest, GetTokenFailed) {
	AddPrimaryAccount(kAccountId1);
	AddAccount(kAccountId2);

	tracker()->Start();
	IssueAccessToken(kAccountId1);
	EXPECT_FALSE(driver()->update_accounts_called());

	IssueError(kAccountId2);

	// Failed token is not retried any more. Account marked as removed.
	EXPECT_EQ(0UL, tracker()->get_pending_token_request_count());
	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	TEST_F(GCMAccountTrackerTest, GetTokenFailedAccountRemoved) {
	AddPrimaryAccount(kAccountId1);
	AddAccount(kAccountId2);

	tracker()->Start();
	IssueAccessToken(kAccountId1);

	driver()->ResetResults();
	RemoveAccount(kAccountId2);
	IssueError(kAccountId2);

	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	TEST_F(GCMAccountTrackerTest, AccountRemovedWhileRequestsPending) {
	AddPrimaryAccount(kAccountId1);
	AddAccount(kAccountId2);

	tracker()->Start();
	IssueAccessToken(kAccountId1);
	EXPECT_FALSE(driver()->update_accounts_called());

	RemoveAccount(kAccountId2);
	IssueAccessToken(kAccountId2);
	EXPECT_TRUE(driver()->update_accounts_called());

	std::vector<GCMClient::AccountTokenInfo> expected_accounts;
	expected_accounts.push_back(MakeAccountToken(kAccountId1));
	VerifyAccountTokens(expected_accounts, driver()->accounts());
	}

	// Makes sure that tracker observes GCM connection when running.
	TEST_F(GCMAccountTrackerTest, TrackerObservesConnection) {
	EXPECT_EQ(nullptr, driver()->last_connection_observer());
	tracker()->Start();
	EXPECT_EQ(tracker(), driver()->last_connection_observer());
	tracker()->Shutdown();
	EXPECT_EQ(tracker(), driver()->last_removed_connection_observer());
	}

	// Makes sure that token fetching happens only after connection is established.
	TEST_F(GCMAccountTrackerTest, PostponeTokenFetchingUntilConnected) {
	driver()->SetConnected(false);
	StartPrimaryAccountAddition(kAccountId1);
	tracker()->Start();
	FinishAccountAddition(kAccountId1);

	EXPECT_EQ(0UL, tracker()->get_pending_token_request_count());
	driver()->SetConnected(true);

	EXPECT_EQ(1UL, tracker()->get_pending_token_request_count());
	}

	TEST_F(GCMAccountTrackerTest, InvalidateExpiredTokens) {
	StartPrimaryAccountAddition(kAccountId1);
	StartAccountAddition(kAccountId2);
	tracker()->Start();
	FinishAccountAddition(kAccountId1);
	FinishAccountAddition(kAccountId2);

	EXPECT_EQ(2UL, tracker()->get_pending_token_request_count());

	IssueExpiredAccessToken(kAccountId1);
	IssueAccessToken(kAccountId2);
	// Because the first token is expired, we expect the sanitize to kick in and
	// clean it up before the SetAccessToken is called. This also means a new
	// token request will be issued
	EXPECT_FALSE(driver()->update_accounts_called());
	EXPECT_EQ(1UL, tracker()->get_pending_token_request_count());
	}

	// Testing for whether there are still more tokens to be fetched. Typically the
	// need for token fetching triggers immediate request, unless there is no
	// connection, that is why connection is set on and off in this test.
	TEST_F(GCMAccountTrackerTest, IsTokenFetchingRequired) {
	tracker()->Start();
	driver()->SetConnected(false);
	EXPECT_FALSE(IsFetchingRequired());
	StartPrimaryAccountAddition(kAccountId1);
	FinishAccountAddition(kAccountId1);
	EXPECT_TRUE(IsFetchingRequired());

	driver()->SetConnected(true);
	EXPECT_FALSE(IsFetchingRequired()); // Indicates that fetching has started.
	IssueAccessToken(kAccountId1);
	EXPECT_FALSE(IsFetchingRequired());

	driver()->SetConnected(false);
	StartAccountAddition(kAccountId2);
	FinishAccountAddition(kAccountId2);
	EXPECT_TRUE(IsFetchingRequired());

	IssueExpiredAccessToken(kAccountId2);
	// Make sure that if the token was expired it is still needed.
	EXPECT_TRUE(IsFetchingRequired());
	}

	// Tests what is the expected time to the next token fetching.
	TEST_F(GCMAccountTrackerTest, GetTimeToNextTokenReporting) {
	tracker()->Start();
	// At this point the last token fetch time is never.
	EXPECT_EQ(base::TimeDelta(), GetTimeToNextTokenReporting());

	// Regular case. The tokens have been just reported.
	driver()->SetLastTokenFetchTime(base::Time::Now());
	EXPECT_TRUE(GetTimeToNextTokenReporting() <=
	base::TimeDelta::FromSeconds(12 * 60 * 60));

	// A case when gcm driver is not yet initialized.
	driver()->SetLastTokenFetchTime(base::Time::Max());
	EXPECT_EQ(base::TimeDelta::FromSeconds(12 * 60 * 60),
	GetTimeToNextTokenReporting());

	// A case when token reporting calculation is expected to result in more than
	// 12 hours, in which case we expect exactly 12 hours.
	driver()->SetLastTokenFetchTime(base::Time::Now() +
	base::TimeDelta::FromDays(2));
	EXPECT_EQ(base::TimeDelta::FromSeconds(12 * 60 * 60),
	GetTimeToNextTokenReporting());
	}

	// Tests conditions when token reporting is required.
	TEST_F(GCMAccountTrackerTest, IsTokenReportingRequired) {
	tracker()->Start();
	// Required because it is overdue.
	EXPECT_TRUE(IsTokenReportingRequired());

	// Not required because it just happened.
	driver()->SetLastTokenFetchTime(base::Time::Now());
	EXPECT_FALSE(IsTokenReportingRequired());

	AddPrimaryAccount(kAccountId1);
	IssueAccessToken(kAccountId1);
	driver()->ResetResults();
	// Reporting was triggered, which means testing for required will give false,
	// but we have the update call.
	RemoveAccount(kAccountId1);
	EXPECT_TRUE(driver()->update_accounts_called());
	EXPECT_FALSE(IsTokenReportingRequired());
	}

	// TODO(fgorski): Add test for adding account after removal >> make sure it does
	// not mark removal.

	} // namespace gcm