Delay fetching account info until OnRefreshTokensLoaded().

components/signin/core/browser/account_tracker_service_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 <algorithm>
 #include <vector>
 
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/prefs/testing_pref_service.h"
@@ skipping 253 matching lines @@
     signin_client_.reset(new TestSigninClient(&pref_service_));
     signin_client_.get()->SetURLRequestContext(
         new net::TestURLRequestContextGetter(message_loop_.task_runner()));
 
     account_tracker_.reset(new AccountTrackerService());
     account_tracker_->Initialize(signin_client_.get());
 
     account_fetcher_.reset(new AccountFetcherService());
     account_fetcher_->Initialize(signin_client_.get(),
                                  fake_oauth2_token_service_.get(),
-                                 account_tracker_.get(), nullptr);
+                                 account_tracker_.get());
 
-    account_fetcher_->EnableNetworkFetches();
+    account_fetcher_->OnRefreshTokensLoaded();
   }
 
   void TearDown() override {
     account_fetcher_->Shutdown();
     account_tracker_->Shutdown();
   }
 
   void SimulateTokenAvailable(const std::string& account_id) {
     fake_oauth2_token_service_->AddAccount(account_id);
   }
@@ skipping 159 matching lines @@
 
 TEST_F(AccountTrackerServiceTest, TokenAlreadyExists) {
   SimulateTokenAvailable("alpha");
   AccountTrackerService tracker;
   AccountTrackerObserver observer;
   AccountFetcherService fetcher;
 
   tracker.AddObserver(&observer);
   tracker.Initialize(signin_client());
 
-  fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-  fetcher.EnableNetworkFetches();
+  fetcher.Initialize(signin_client(), token_service(), &tracker);
+  fetcher.OnRefreshTokensLoaded();
   ASSERT_FALSE(fetcher.IsAllUserInfoFetched());
   ASSERT_TRUE(observer.CheckEvents());
   tracker.RemoveObserver(&observer);
   tracker.Shutdown();
   fetcher.Shutdown();
 }
 
 TEST_F(AccountTrackerServiceTest, TwoTokenAvailable_TwoUserInfo) {
   AccountTrackerObserver observer;
   account_tracker()->AddObserver(&observer);
@@ skipping 60 matching lines @@
 TEST_F(AccountTrackerServiceTest, GetAccountInfo_TokenAvailable_EnableNetwork) {
   // Shutdown the network-enabled tracker built into the test case.
   TearDown();
 
   // Create an account tracker and an account fetcher service but do not enable
   // network fetches.
   AccountTrackerService tracker;
   tracker.Initialize(signin_client());
 
   AccountFetcherService fetcher_service;
-  fetcher_service.Initialize(signin_client(), token_service(), &tracker,
-                             nullptr);
+  fetcher_service.Initialize(signin_client(), token_service(), &tracker);
 
   SimulateTokenAvailable("alpha");
   IssueAccessToken("alpha");
   // No fetcher has been created yet.
   net::TestURLFetcher* fetcher = test_fetcher_factory()->GetFetcherByID(
       gaia::GaiaOAuthClient::kUrlFetcherId);
   ASSERT_FALSE(fetcher);
 
-  // Enable the network to create the fetcher then issue the access token.
-  fetcher_service.EnableNetworkFetches();
+  // Enable the network fetches and refresh invalid accounts information.
+  fetcher_service.OnRefreshTokensLoaded();
 
   // Fetcher was created and executes properly.
   ReturnOAuthUrlFetchSuccess("alpha");
 
   AccountInfo info = tracker.GetAccountInfo("alpha");
   CheckAccountDetails("alpha", info);
   fetcher_service.Shutdown();
   tracker.Shutdown();
 }
 
@@ skipping 56 matching lines @@
     ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, "alpha"),
                                      TrackingEvent(UPDATED, "beta")));
     tracker.RemoveObserver(&observer);
 
     std::vector<AccountInfo> infos = tracker.GetAccounts();
     ASSERT_EQ(2u, infos.size());
     CheckAccountDetails("alpha", infos[0]);
     CheckAccountDetails("beta", infos[1]);
 
     FakeAccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-    fetcher.EnableNetworkFetches();
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
+    fetcher.OnRefreshTokensLoaded();
     // Remove an account.
     // This will allow testing removal as well as child accounts which is only
     // allowed for a single account.
     SimulateTokenRevoked("alpha");
     fetcher.FakeSetIsChildAccount("beta", true);
 
     fetcher.Shutdown();
     tracker.Shutdown();
  }
 
@@ skipping 28 matching lines @@
   EXPECT_EQ(email, infos[0].email);
 }
 
 TEST_F(AccountTrackerServiceTest, UpgradeToFullAccountInfo) {
   // Start by simulating an incomplete account info and let it be saved to
   // prefs.
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-    fetcher.EnableNetworkFetches();
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
+    fetcher.OnRefreshTokensLoaded();
     SimulateTokenAvailable("incomplete");
     ReturnOAuthUrlFetchSuccessIncomplete("incomplete");
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
     // Validate that the loaded AccountInfo from prefs is considered invalid.
     std::vector<AccountInfo> infos = tracker.GetAccounts();
     ASSERT_EQ(1u, infos.size());
     ASSERT_FALSE(infos[0].IsValid());
 
     // Enable network fetches and simulate the same account getting a refresh
     // token containing all the info.
-    fetcher.EnableNetworkFetches();
+    fetcher.OnRefreshTokensLoaded();
     SimulateTokenAvailable("incomplete");
     ReturnOAuthUrlFetchSuccess("incomplete");
 
     // Validate that the account is now considered valid.
     infos = tracker.GetAccounts();
     ASSERT_EQ(1u, infos.size());
     ASSERT_TRUE(infos[0].IsValid());
 
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 
   // Reinstantiate a tracker to validate that the AccountInfo saved to prefs is
   // now the upgraded one, considered valid.
   {
     AccountTrackerService tracker;
     AccountTrackerObserver observer;
     tracker.AddObserver(&observer);
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
 
     ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, "incomplete")));
     // Enabling network fetches shouldn't cause any actual fetch since the
     // AccountInfos loaded from prefs should be valid.
-    fetcher.EnableNetworkFetches();
+    fetcher.OnRefreshTokensLoaded();
 
     std::vector<AccountInfo> infos = tracker.GetAccounts();
     ASSERT_EQ(1u, infos.size());
     ASSERT_TRUE(infos[0].IsValid());
     // Check that no network fetches were made.
     ASSERT_TRUE(observer.CheckEvents());
 
     tracker.RemoveObserver(&observer);
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 }
 
 TEST_F(AccountTrackerServiceTest, TimerRefresh) {
   // Start by creating a tracker and adding a couple accounts to be persisted to
   // prefs.
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-    fetcher.EnableNetworkFetches();
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
+    fetcher.OnRefreshTokensLoaded();
     SimulateTokenAvailable("alpha");
     ReturnOAuthUrlFetchSuccess("alpha");
     SimulateTokenAvailable("beta");
     ReturnOAuthUrlFetchSuccess("beta");
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 
   // Rewind the time by half a day, which shouldn't be enough to trigger a
   // network refresh.
   base::Time fake_update = base::Time::Now() - base::TimeDelta::FromHours(12);
   signin_client()->GetPrefs()->SetInt64(
       AccountFetcherService::kLastUpdatePref,
       fake_update.ToInternalValue());
 
   // Instantiate a new ATS, making sure the persisted accounts are still there
   // and that no network fetches happen.
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
 
     ASSERT_TRUE(fetcher.IsAllUserInfoFetched());
     std::vector<AccountInfo> infos = tracker.GetAccounts();
     ASSERT_EQ(2u, infos.size());
     ASSERT_TRUE(infos[0].IsValid());
     ASSERT_TRUE(infos[1].IsValid());
 
-    fetcher.EnableNetworkFetches();
+    fetcher.OnRefreshTokensLoaded();
     ASSERT_TRUE(fetcher.IsAllUserInfoFetched());
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 
   // Rewind the last updated time enough to trigger a network refresh.
   fake_update = base::Time::Now() - base::TimeDelta::FromHours(25);
   signin_client()->GetPrefs()->SetInt64(
       AccountFetcherService::kLastUpdatePref,
       fake_update.ToInternalValue());
 
   // Instantiate a new tracker and validate that even though the AccountInfos
   // are still valid, the network fetches are started.
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
 
     ASSERT_TRUE(fetcher.IsAllUserInfoFetched());
     std::vector<AccountInfo> infos = tracker.GetAccounts();
     ASSERT_EQ(2u, infos.size());
     ASSERT_TRUE(infos[0].IsValid());
     ASSERT_TRUE(infos[1].IsValid());
 
-    fetcher.EnableNetworkFetches();
+    fetcher.OnRefreshTokensLoaded();
     ASSERT_FALSE(fetcher.IsAllUserInfoFetched());
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 }
 
 TEST_F(AccountTrackerServiceTest, LegacyDottedAccountIds) {
   // Start by creating a tracker and adding an account with a dotted account id
   // because of an old bug in token service.  The token service would also add
   // a correct non-dotted account id for the same account.
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-    fetcher.EnableNetworkFetches();
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
+    fetcher.OnRefreshTokensLoaded();
     SimulateTokenAvailable("foo.bar@gmail.com");
     SimulateTokenAvailable("foobar@gmail.com");
     ReturnOAuthUrlFetchSuccess("foo.bar@gmail.com");
     ReturnOAuthUrlFetchSuccess("foobar@gmail.com");
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 
   // Remove the bad account now from the token service to simulate that it
   // has been "fixed".
   SimulateTokenRevoked("foo.bar@gmail.com");
 
   // Instantiate a new tracker and validate that it has only one account, and
   // it is the correct non dotted one.
   {
     AccountTrackerService tracker;
     tracker.Initialize(signin_client());
     AccountFetcherService fetcher;
-    fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
+    fetcher.Initialize(signin_client(), token_service(), &tracker);
 
     ASSERT_TRUE(fetcher.IsAllUserInfoFetched());
     std::vector<AccountInfo> infos = tracker.GetAccounts();
     ASSERT_EQ(1u, infos.size());
     ASSERT_STREQ("foobar@gmail.com", infos[0].account_id.c_str());
     tracker.Shutdown();
     fetcher.Shutdown();
   }
 }
 
@@ skipping 179 matching lines @@
     accounts.clear();
     accounts = tracker.GetAccounts();
     ASSERT_EQ(2u, accounts.size());
   }
 }
 
 TEST_F(AccountTrackerServiceTest, ChildAccountBasic) {
   AccountTrackerService tracker;
   tracker.Initialize(signin_client());
   FakeAccountFetcherService fetcher;
-  fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-  fetcher.EnableNetworkFetches();
+  fetcher.Initialize(signin_client(), token_service(), &tracker);
+  fetcher.OnRefreshTokensLoaded();
   AccountTrackerObserver observer;
   tracker.AddObserver(&observer);
   std::string child_id("child");
   {
     // Responses are processed iff there is a single account with a valid token
     // and the response is for that account.
     fetcher.FakeSetIsChildAccount(child_id, true);
     ASSERT_TRUE(observer.CheckEvents());
   }
   {
     SimulateTokenAvailable(child_id);
     IssueAccessToken(child_id);
     fetcher.FakeSetIsChildAccount(child_id, true);
     // Response was processed but observer is not notified as the account state
     // is invalid.
     ASSERT_TRUE(observer.CheckEvents());
     AccountInfo info = tracker.GetAccountInfo(child_id);
     ASSERT_TRUE(info.is_child_account);
     SimulateTokenRevoked(child_id);
   }
   tracker.RemoveObserver(&observer);
   fetcher.Shutdown();
   tracker.Shutdown();
 }
 
 TEST_F(AccountTrackerServiceTest, ChildAccountUpdatedAndRevoked) {
   AccountTrackerService tracker;
   tracker.Initialize(signin_client());
   FakeAccountFetcherService fetcher;
-  fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-  fetcher.EnableNetworkFetches();
+  fetcher.Initialize(signin_client(), token_service(), &tracker);
+  fetcher.OnRefreshTokensLoaded();
   AccountTrackerObserver observer;
   tracker.AddObserver(&observer);
   std::string child_id("child");
 
   SimulateTokenAvailable(child_id);
   IssueAccessToken(child_id);
   fetcher.FakeSetIsChildAccount(child_id, false);
   FakeUserInfoFetchSuccess(&fetcher, child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id)));
   AccountInfo info = tracker.GetAccountInfo(child_id);
   ASSERT_FALSE(info.is_child_account);
   SimulateTokenRevoked(child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(REMOVED, child_id)));
 
   tracker.RemoveObserver(&observer);
   fetcher.Shutdown();
   tracker.Shutdown();
 }
 
 TEST_F(AccountTrackerServiceTest, ChildAccountUpdatedAndRevokedWithUpdate) {
   AccountTrackerService tracker;
   tracker.Initialize(signin_client());
   FakeAccountFetcherService fetcher;
-  fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-  fetcher.EnableNetworkFetches();
+  fetcher.Initialize(signin_client(), token_service(), &tracker);
+  fetcher.OnRefreshTokensLoaded();
   AccountTrackerObserver observer;
   tracker.AddObserver(&observer);
   std::string child_id("child");
 
   SimulateTokenAvailable(child_id);
   IssueAccessToken(child_id);
   fetcher.FakeSetIsChildAccount(child_id, true);
   FakeUserInfoFetchSuccess(&fetcher, child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id)));
   AccountInfo info = tracker.GetAccountInfo(child_id);
   ASSERT_TRUE(info.is_child_account);
   SimulateTokenRevoked(child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id),
                                    TrackingEvent(REMOVED, child_id)));
 
   tracker.RemoveObserver(&observer);
   fetcher.Shutdown();
   tracker.Shutdown();
 }
 
 TEST_F(AccountTrackerServiceTest, ChildAccountUpdatedTwiceThenRevoked) {
   AccountTrackerService tracker;
   tracker.Initialize(signin_client());
   FakeAccountFetcherService fetcher;
-  fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-  fetcher.EnableNetworkFetches();
+  fetcher.Initialize(signin_client(), token_service(), &tracker);
+  fetcher.OnRefreshTokensLoaded();
   AccountTrackerObserver observer;
   tracker.AddObserver(&observer);
   std::string child_id("child");
 
   SimulateTokenAvailable(child_id);
   IssueAccessToken(child_id);
   // Observers notified the first time.
   FakeUserInfoFetchSuccess(&fetcher, child_id);
   // Since the account state is already valid, this will notify the
   // observers for the second time.
   fetcher.FakeSetIsChildAccount(child_id, true);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id),
                                    TrackingEvent(UPDATED, child_id)));
   SimulateTokenRevoked(child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id),
                                    TrackingEvent(REMOVED, child_id)));
 
   tracker.RemoveObserver(&observer);
   fetcher.Shutdown();
   tracker.Shutdown();
 }
 
 TEST_F(AccountTrackerServiceTest, ChildAccountGraduation) {
   AccountTrackerService tracker;
   tracker.Initialize(signin_client());
   FakeAccountFetcherService fetcher;
-  fetcher.Initialize(signin_client(), token_service(), &tracker, nullptr);
-  fetcher.EnableNetworkFetches();
+  fetcher.Initialize(signin_client(), token_service(), &tracker);
+  fetcher.OnRefreshTokensLoaded();
   AccountTrackerObserver observer;
   tracker.AddObserver(&observer);
   std::string child_id("child");
 
   SimulateTokenAvailable(child_id);
   IssueAccessToken(child_id);
 
   // Set and verify this is a child account.
   fetcher.FakeSetIsChildAccount(child_id, true);
   AccountInfo info = tracker.GetAccountInfo(child_id);
   ASSERT_TRUE(info.is_child_account);
   FakeUserInfoFetchSuccess(&fetcher, child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id)));
 
   // Now simulate child account graduation.
   fetcher.FakeSetIsChildAccount(child_id, false);
   info = tracker.GetAccountInfo(child_id);
   ASSERT_FALSE(info.is_child_account);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(UPDATED, child_id)));
 
   SimulateTokenRevoked(child_id);
   ASSERT_TRUE(observer.CheckEvents(TrackingEvent(REMOVED, child_id)));
 
   tracker.RemoveObserver(&observer);
   fetcher.Shutdown();
   tracker.Shutdown();
 }