Delay fetching account info until OnRefreshTokensLoaded().

components/signin/core/browser/account_tracker_service.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 "components/signin/core/browser/account_tracker_service.h"
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 123 matching lines @@
          ++it) {
       const AccountState& state = it->second;
       if (gaia::AreEmailsSame(state.info.email, email))
         return state.info;
     }
   }
 
   return AccountInfo();
 }
 
+bool AccountTrackerService::IsTrackingAccount(
+    const std::string& account_id) const {
+  return ContainsKey(accounts_, account_id);
+}
+
+bool AccountTrackerService::HasIdNameMappingForAccount(
+    const std::string& account_id) const {
+  AccountInfo account = GetAccountInfo(account_id);
+  return !account.email.empty() && !account.gaia.empty();

[gogerald1, 2015/10/13 16:34:53]

This is always true, if IsMigratable() is true and account_id is one of the
account in ATS. Otherwise the data was corrupted.

[nyquist, 2015/10/15 19:33:45]

I thought GetAccountInfo(...) returns an empty struct if the account does not
exist in the mapping?

+}
+
+bool AccountTrackerService::HasIdNameMappingForAllAccounts() const {
+  for (const auto& account : accounts_) {
+    const AccountInfo& account_info = account.second.info;
+    if (account_info.email.empty() || account_info.gaia.empty())

[gogerald1, 2015/10/13 16:34:53]

Same as above comments

+      return false;
+  }
+  return true;
+}
+
 AccountTrackerService::AccountIdMigrationState
 AccountTrackerService::GetMigrationState() const {
   return GetMigrationState(signin_client_->GetPrefs());
 }
 
 void AccountTrackerService::SetMigrationState(AccountIdMigrationState state) {
   signin_client_->GetPrefs()->SetInteger(prefs::kAccountIdMigrationState,
                                          state);
 }
 
@@ skipping 21 matching lines @@
 }
 
 void AccountTrackerService::NotifyAccountRemoved(const AccountState& state) {
   DCHECK(!state.info.gaia.empty());
   FOR_EACH_OBSERVER(
       Observer, observer_list_, OnAccountRemoved(state.info));
 }
 
 void AccountTrackerService::StartTrackingAccount(
     const std::string& account_id) {
-  if (!ContainsKey(accounts_, account_id)) {
+  if (!IsTrackingAccount(account_id)) {
     DVLOG(1) << "StartTracking " << account_id;
     AccountState state;
     state.info.account_id = account_id;
     state.info.is_child_account = false;
     accounts_.insert(make_pair(account_id, state));
   }
 }
 
 void AccountTrackerService::StopTrackingAccount(const std::string& account_id) {
   DVLOG(1) << "StopTracking " << account_id;
-  if (ContainsKey(accounts_, account_id)) {
+  if (IsTrackingAccount(account_id)) {
     AccountState& state = accounts_[account_id];
     RemoveFromPrefs(state);
     if (!state.info.gaia.empty())
       NotifyAccountRemoved(state);
 
     accounts_.erase(account_id);
   }
 }
 
 void AccountTrackerService::SetAccountStateFromUserInfo(
     const std::string& account_id,
     const base::DictionaryValue* user_info) {
-  DCHECK(ContainsKey(accounts_, account_id));
+  DCHECK(IsTrackingAccount(account_id));
   AccountState& state = accounts_[account_id];
 
   std::string gaia_id;
   std::string email;
   if (user_info->GetString("id", &gaia_id) &&
       user_info->GetString("email", &email)) {
     state.info.gaia = gaia_id;
     state.info.email = email;
 
     std::string hosted_domain;
@@ skipping 14 matching lines @@
       state.info.picture_url = kNoPictureURLFound;
     }
   }
   if (state.info.IsValid())
     NotifyAccountUpdated(state);
   SaveToPrefs(state);
 }
 
 void AccountTrackerService::SetIsChildAccount(const std::string& account_id,
                                               const bool& is_child_account) {
-  DCHECK(ContainsKey(accounts_, account_id));
+  DCHECK(IsTrackingAccount(account_id));
   AccountState& state = accounts_[account_id];
   if (state.info.is_child_account == is_child_account)
     return;
   state.info.is_child_account = is_child_account;
   if (state.info.IsValid())
     NotifyAccountUpdated(state);
   SaveToPrefs(state);
 }
 
 bool AccountTrackerService::IsMigratable() const {
 #if !defined(OS_CHROMEOS)
-  for (std::map<std::string, AccountState>::const_iterator it =
-           accounts_.begin();
-       it != accounts_.end(); ++it) {
-    const AccountState& state = it->second;
-    if ((it->first).empty() || state.info.gaia.empty())
-      return false;
-  }
-  return true;
+  return HasIdNameMappingForAllAccounts();
 #else
   return false;
 #endif
 }
 
 void AccountTrackerService::MigrateToGaiaId() {
   std::set<std::string> to_remove;
   std::map<std::string, AccountState> migrated_accounts;
   for (std::map<std::string, AccountState>::const_iterator it =
            accounts_.begin();
        it != accounts_.end(); ++it) {
     const AccountState& state = it->second;
     std::string account_id = it->first;
     if (account_id != state.info.gaia) {
       std::string new_account_id = state.info.gaia;
-      if (!ContainsKey(accounts_, new_account_id)) {
+      if (!IsTrackingAccount(new_account_id)) {
         AccountState new_state = state;
         new_state.info.account_id = new_account_id;
         migrated_accounts.insert(make_pair(new_account_id, new_state));
         SaveToPrefs(new_state);
       }
       to_remove.insert(account_id);
     }
   }
 
   // Remove any obsolete account.
   for (auto account_id : to_remove) {
-    if (ContainsKey(accounts_, account_id)) {
+    if (IsTrackingAccount(account_id)) {
       AccountState& state = accounts_[account_id];
       RemoveFromPrefs(state);
       accounts_.erase(account_id);
     }
   }
 
   for (std::map<std::string, AccountState>::const_iterator it =
            migrated_accounts.begin();
        it != migrated_accounts.end(); ++it) {
     accounts_.insert(*it);
@@ skipping 157 matching lines @@
       return gaia;
     default:
       NOTREACHED();
       return email;
   }
 }
 
 std::string AccountTrackerService::SeedAccountInfo(const std::string& gaia,
                                                    const std::string& email) {
   const std::string account_id = PickAccountIdForAccount(gaia, email);
-  const bool already_exists = ContainsKey(accounts_, account_id);
+  const bool already_exists = IsTrackingAccount(account_id);
   StartTrackingAccount(account_id);
   AccountState& state = accounts_[account_id];
   DCHECK(!already_exists || state.info.gaia.empty() || state.info.gaia == gaia);
   state.info.gaia = gaia;
   state.info.email = email;
   SaveToPrefs(state);
 
   DVLOG(1) << "AccountTrackerService::SeedAccountInfo"
            << " account_id=" << account_id
            << " gaia_id=" << gaia
            << " email=" << email;
 
   return account_id;
 }
 
 void AccountTrackerService::SeedAccountInfo(AccountInfo info) {
   info.account_id = PickAccountIdForAccount(info.gaia, info.email);
   if (info.hosted_domain.empty()) {
     info.hosted_domain = kNoHostedDomainFound;
   }
 
   if(info.IsValid()) {
-    if(!ContainsKey(accounts_, info.account_id)) {
+    if (!IsTrackingAccount(info.account_id)) {
       SeedAccountInfo(info.gaia, info.email);
     }
 
     AccountState& state = accounts_[info.account_id];
     state.info = info;
     NotifyAccountUpdated(state);
     SaveToPrefs(state);
   }
 }
 
 void AccountTrackerService::RemoveAccount(const std::string& account_id) {
   StopTrackingAccount(account_id);
 }