Delay fetching account info until OnRefreshTokensLoaded().

components/signin/core/browser/account_fetcher_service.cc

 // Copyright 2015 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/signin/core/browser/account_fetcher_service.h"
 
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 37 matching lines @@
     "account_tracker_service_last_update";
 
 // AccountFetcherService implementation
 AccountFetcherService::AccountFetcherService()
     : account_tracker_service_(nullptr),
       token_service_(nullptr),
       signin_client_(nullptr),
       invalidation_service_(nullptr),
       network_fetches_enabled_(false),
       shutdown_called_(false),
+      scheduled_refresh_enabled_(true),
       child_info_request_(nullptr) {}
 
 AccountFetcherService::~AccountFetcherService() {
   DCHECK(shutdown_called_);
 }
 
 // static
 void AccountFetcherService::RegisterPrefs(
     user_prefs::PrefRegistrySyncable* user_prefs) {
   user_prefs->RegisterInt64Pref(kLastUpdatePref, 0);
 }
 
 void AccountFetcherService::Initialize(
     SigninClient* signin_client,
     OAuth2TokenService* token_service,
-    AccountTrackerService* account_tracker_service,
-    invalidation::InvalidationService* invalidation_service) {
+    AccountTrackerService* account_tracker_service) {
   DCHECK(signin_client);
   DCHECK(!signin_client_);
   signin_client_ = signin_client;
-  invalidation_service_ = invalidation_service;
   DCHECK(account_tracker_service);
   DCHECK(!account_tracker_service_);
   account_tracker_service_ = account_tracker_service;
   DCHECK(token_service);
   DCHECK(!token_service_);
   token_service_ = token_service;
   token_service_->AddObserver(this);
 
   last_updated_ = base::Time::FromInternalValue(
       signin_client_->GetPrefs()->GetInt64(kLastUpdatePref));
-
-  RefreshAllAccountInfo(true);
 }
 
 void AccountFetcherService::Shutdown() {
   token_service_->RemoveObserver(this);
   // child_info_request_ is an invalidation handler and needs to be
   // unregistered during the lifetime of the invalidation service.
   child_info_request_.reset();
+  invalidation_service_ = nullptr;
   shutdown_called_ = true;
 }
 
-void AccountFetcherService::EnableNetworkFetches() {
-  DCHECK(CalledOnValidThread());
-  DCHECK(!network_fetches_enabled_);
-  network_fetches_enabled_ = true;
-  // If there are accounts in |pending_user_info_fetches_|, they were deemed
-  // invalid after being loaded from prefs and need to be fetched now instead of
-  // waiting after the timer.
-  for (const std::string& account_id : pending_user_info_fetches_)
-    StartFetchingUserInfo(account_id);
-  pending_user_info_fetches_.clear();
-
-  // Now that network fetches are enabled, schedule the next refresh.
-  ScheduleNextRefresh();
-}
-
 bool AccountFetcherService::IsAllUserInfoFetched() const {
   return user_info_requests_.empty();
 }
 
 void AccountFetcherService::FetchUserInfoBeforeSignin(
     const std::string& account_id) {
+  DCHECK(network_fetches_enabled_);
   RefreshAccountInfo(account_id, false);
 }
 
+void AccountFetcherService::SetupInvalidations(
+    invalidation::InvalidationService* invalidation_service) {
+  DCHECK(!invalidation_service_);
+  DCHECK(!child_info_request_);
+  invalidation_service_ = invalidation_service;
+}
+
+void AccountFetcherService::DisableScheduledRefreshForTesting() {
+  DCHECK(!timer_.IsRunning());
+  DCHECK(!network_fetches_enabled_);
+  scheduled_refresh_enabled_ = false;
+}
+
 void AccountFetcherService::RefreshAllAccountInfo(bool only_fetch_if_invalid) {
   std::vector<std::string> accounts = token_service_->GetAccounts();
   for (std::vector<std::string>::const_iterator it = accounts.begin();
        it != accounts.end(); ++it) {
     RefreshAccountInfo(*it, only_fetch_if_invalid);
   }
 }
 
 // Child account status is refreshed through invalidations which are only
 // available for the primary account. Finding the primary account requires a
@@ skipping 21 matching lines @@
 void AccountFetcherService::RefreshAllAccountsAndScheduleNext() {
   DCHECK(network_fetches_enabled_);
   RefreshAllAccountInfo(false);
   last_updated_ = base::Time::Now();
   signin_client_->GetPrefs()->SetInt64(kLastUpdatePref,
                                        last_updated_.ToInternalValue());
   ScheduleNextRefresh();
 }
 
 void AccountFetcherService::ScheduleNextRefresh() {
+  if (!scheduled_refresh_enabled_)
+    return;
   DCHECK(!timer_.IsRunning());
   DCHECK(network_fetches_enabled_);
 
   const base::TimeDelta time_since_update = base::Time::Now() - last_updated_;
   if(time_since_update > kRefreshFromTokenServiceDelay) {
     RefreshAllAccountsAndScheduleNext();
   } else {
     timer_.Start(FROM_HERE, kRefreshFromTokenServiceDelay - time_since_update,
                  this,
                  &AccountFetcherService::RefreshAllAccountsAndScheduleNext);
   }
 }
 
 // Starts fetching user information. This is called periodically to refresh.
 void AccountFetcherService::StartFetchingUserInfo(
     const std::string& account_id) {
   DCHECK(CalledOnValidThread());
-  if (!network_fetches_enabled_) {
-    pending_user_info_fetches_.push_back(account_id);
-    return;
-  }
+  DCHECK(network_fetches_enabled_);
 
   if (!ContainsKey(user_info_requests_, account_id)) {
     DVLOG(1) << "StartFetching " << account_id;
     scoped_ptr<AccountInfoFetcher> fetcher(new AccountInfoFetcher(
         token_service_, signin_client_->GetURLRequestContext(), this,
         account_id));
     user_info_requests_.set(account_id, fetcher.Pass());
     user_info_requests_.get(account_id)->Start();
   }
 }
 
 // Starts fetching whether this is a child account. Handles refresh internally.
 void AccountFetcherService::StartFetchingChildInfo(
     const std::string& account_id) {
   child_info_request_.reset(ChildAccountInfoFetcher::CreateFrom(
       child_request_account_id_, this, token_service_,
       signin_client_->GetURLRequestContext(), invalidation_service_));
 }
 
 void AccountFetcherService::ResetChildInfo() {
   if (!child_request_account_id_.empty())
     SetIsChildAccount(child_request_account_id_, false);
   child_request_account_id_.clear();
   child_info_request_.reset();
 }
 
 void AccountFetcherService::RefreshAccountInfo(const std::string& account_id,
                                                bool only_fetch_if_invalid) {
+  DCHECK(network_fetches_enabled_);
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "422460 AccountFetcherService::OnRefreshTokenAvailable"));
-
-  TRACE_EVENT1("AccountFetcherService",
-               "AccountFetcherService::RefreshAccountInfo",
-               "account_id",
-               account_id);
-  DVLOG(1) << "AVAILABLE " << account_id;
+          "422460 AccountFetcherService::RefreshAccountInfo"));
 
   account_tracker_service_->StartTrackingAccount(account_id);
   const AccountInfo& info =
       account_tracker_service_->GetAccountInfo(account_id);
   if (!AccountSupportsUserInfo(account_id))
     return;
 
 // |only_fetch_if_invalid| is false when the service is due for a timed update.
 #if defined(OS_ANDROID)
   // TODO(mlerman): Change this condition back to info.IsValid() and ensure the
@@ skipping 50 matching lines @@
 
 void AccountFetcherService::OnUserInfoFetchFailure(
     const std::string& account_id) {
   LOG(WARNING) << "Failed to get UserInfo for " << account_id;
   account_tracker_service_->NotifyAccountUpdateFailed(account_id);
   user_info_requests_.erase(account_id);
 }
 
 void AccountFetcherService::OnRefreshTokenAvailable(
     const std::string& account_id) {
+  TRACE_EVENT1("AccountFetcherService",
+               "AccountFetcherService::OnRefreshTokenAvailable",
+               "account_id",
+               account_id);
+  DVLOG(1) << "AVAILABLE " << account_id;
+
   // The SigninClient needs a "final init" in order to perform some actions
   // (such as fetching the signin token "handle" in order to look for password
   // changes) once everything is initialized and the refresh token is present.
   signin_client_->DoFinalInit();
+
+  if (!network_fetches_enabled_)
+    return;
   RefreshAccountInfo(account_id, true);
   UpdateChildInfo();
 }
 
 void AccountFetcherService::OnRefreshTokenRevoked(
     const std::string& account_id) {
   TRACE_EVENT1("AccountFetcherService",
                "AccountFetcherService::OnRefreshTokenRevoked",
                "account_id",
                account_id);
+  DVLOG(1) << "REVOKED " << account_id;
 
-  DVLOG(1) << "REVOKED " << account_id;
+  if (!network_fetches_enabled_)
+    return;
   user_info_requests_.erase(account_id);
   UpdateChildInfo();
   account_tracker_service_->StopTrackingAccount(account_id);
 }
 
 void AccountFetcherService::OnRefreshTokensLoaded() {
-  // OnRefreshTokenAvailable has been called for all accounts by this point.
-  // Maybe remove this after further investigation.
+  DCHECK(CalledOnValidThread());
+  if (!network_fetches_enabled_) {
+    network_fetches_enabled_ = true;
+    ScheduleNextRefresh();
+  }
   RefreshAllAccountInfo(true);
   UpdateChildInfo();
 }