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"
 #include "base/trace_event/trace_event.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/signin/core/browser/account_info_fetcher.h"
+#include "components/signin/core/browser/account_seeding_tracker.h"
 #include "components/signin/core/browser/account_tracker_service.h"
 #include "components/signin/core/browser/child_account_info_fetcher.h"
 #include "components/signin/core/browser/refresh_token_annotation_request.h"
 #include "components/signin/core/browser/signin_client.h"
 #include "components/signin/core/common/signin_switches.h"
 #include "net/url_request/url_request_context_getter.h"
 
 namespace {
 
 const base::TimeDelta kRefreshFromTokenServiceDelay =
@@ skipping 24 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),
-      child_info_request_(nullptr) {}
+      child_info_request_(nullptr),
+      account_seeding_tracker_(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) {
   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;
+  account_seeding_tracker_.reset(
+      new AccountSeedingTracker(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);
 }
@@ skipping 23 matching lines @@
 
 bool AccountFetcherService::IsAllUserInfoFetched() const {
   return user_info_requests_.empty();
 }
 
 void AccountFetcherService::FetchUserInfoBeforeSignin(
     const std::string& account_id) {
   RefreshAccountInfo(account_id, false);
 }
 
+#if defined(OS_ANDROID)
+void AccountFetcherService::OnAccountsSeeded() {
+  std::vector<std::string> newly_seeded_acounts(
+      account_seeding_tracker_->GetNewlySeededAccounts());
+  for (const std::string& account : newly_seeded_acounts)
+    StartFetchingUserInfo(account);
+  UpdateChildInfo();
+}
+
+bool AccountFetcherService::AreAllAccountsSeeded() {
+  return account_seeding_tracker_->AreAllAccountsSeeded();
+}
+#endif
+
 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
 // dependency on signin_manager which we get around by only allowing a single
 // account. This is possible since we only support a single account to be a
 // child anyway.
 void AccountFetcherService::UpdateChildInfo() {
   DCHECK(CalledOnValidThread());
   std::vector<std::string> accounts = token_service_->GetAccounts();
   if (accounts.size() == 1) {
     const std::string& candidate = accounts[0];
     if (candidate == child_request_account_id_)
       return;
     if (!child_request_account_id_.empty())
       ResetChildInfo();
     if (!AccountSupportsUserInfo(candidate))
       return;
+    if (!account_seeding_tracker_->IsAccountSeeded(candidate))
+      return;
     child_request_account_id_ = candidate;
     StartFetchingChildInfo(candidate);
   } else {
     ResetChildInfo();
   }
 }
 
 void AccountFetcherService::RefreshAllAccountsAndScheduleNext() {
   DCHECK(network_fetches_enabled_);
   RefreshAllAccountInfo(false);
@@ skipping 18 matching lines @@
 }
 
 // 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;
   }
+  if (!account_seeding_tracker_->IsAccountSeeded(account_id))
+    return;
 
   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();
   }
 }
@@ skipping 116 matching lines @@
   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.
   RefreshAllAccountInfo(true);
   UpdateChildInfo();
 }