[Desktop] Add diagnostics about loading the refresh tokens.

chrome/browser/signin/mutable_profile_oauth2_token_service_delegate.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 "chrome/browser/signin/mutable_profile_oauth2_token_service_delegate.h"
 
 #include <stddef.h>
 
 #include "base/macros.h"
 #include "base/profiler/scoped_tracker.h"
@@ skipping 23 matching lines @@
 }
 
 bool IsLegacyServiceId(const std::string& account_id) {
   return account_id.compare(0u, kAccountIdPrefixLength, kAccountIdPrefix) != 0;
 }
 
 std::string RemoveAccountIdPrefix(const std::string& prefixed_account_id) {
   return prefixed_account_id.substr(kAccountIdPrefixLength);
 }
 
+OAuth2TokenServiceDelegate::LoadCredentialsState
+LoadCredentialsStateFromTokenResult(TokenServiceTable::Result token_result) {
+  switch (token_result) {
+    case TokenServiceTable::TOKEN_DB_RESULT_SQL_INVALID_STATEMENT:
+    case TokenServiceTable::TOKEN_DB_RESULT_BAD_ENTRY:
+      return OAuth2TokenServiceDelegate::
+          LOAD_CREDENTIALS_FINISHED_WITH_DB_ERRORS;
+    case TokenServiceTable::TOKEN_DB_RESULT_DECRYPT_ERROR:
+      return OAuth2TokenServiceDelegate::
+          LOAD_CREDENTIALS_FINISHED_WITH_DECRYPT_ERRORS;
+    case TokenServiceTable::TOKEN_DB_RESULT_SUCCESS:
+      return OAuth2TokenServiceDelegate::LOAD_CREDENTIALS_FINISHED_WITH_SUCCESS;
+  }
+  NOTREACHED();
+  return OAuth2TokenServiceDelegate::LOAD_CREDENTIALS_UNKNOWN;
+}
+
 }  // namespace
 
 // This class sends a request to GAIA to revoke the given refresh token from
 // the server.  This is a best effort attempt only.  This class deletes itself
 // when done successfully or otherwise.
 class MutableProfileOAuth2TokenServiceDelegate::RevokeServerRefreshToken
     : public GaiaAuthConsumer {
  public:
   RevokeServerRefreshToken(
       MutableProfileOAuth2TokenServiceDelegate* token_service_delegate,
@@ skipping 68 matching lines @@
 MutableProfileOAuth2TokenServiceDelegate::AccountStatus::GetAuthStatus() const {
   return last_auth_error_;
 }
 
 MutableProfileOAuth2TokenServiceDelegate::
     MutableProfileOAuth2TokenServiceDelegate(
         SigninClient* client,
         SigninErrorController* signin_error_controller,
         AccountTrackerService* account_tracker_service)
     : web_data_service_request_(0),
+      load_credentials_state_(LOAD_CREDENTIALS_NOT_STARTED),
       backoff_entry_(&backoff_policy_),
       backoff_error_(GoogleServiceAuthError::NONE),
       client_(client),
       signin_error_controller_(signin_error_controller),
       account_tracker_service_(account_tracker_service) {
   VLOG(1) << "MutablePO2TS::MutablePO2TS";
   DCHECK(client);
   DCHECK(signin_error_controller);
   // It's okay to fill the backoff policy after being used in construction.
   backoff_policy_.num_errors_to_ignore = 0;
@@ skipping 95 matching lines @@
     account_ids.push_back(token.first);
   }
   return account_ids;
 }
 
 net::URLRequestContextGetter*
 MutableProfileOAuth2TokenServiceDelegate::GetRequestContext() const {
   return client_->GetURLRequestContext();
 }
 
+OAuth2TokenServiceDelegate::LoadCredentialsState
+MutableProfileOAuth2TokenServiceDelegate::GetLoadCredentialsState() const {
+  return load_credentials_state_;
+}
+
 void MutableProfileOAuth2TokenServiceDelegate::LoadCredentials(
     const std::string& primary_account_id) {
+  if (load_credentials_state_ == LOAD_CREDENTIALS_IN_PROGRESS) {
+    VLOG(1) << "Load credentials operation already in progress";
+    return;
+  }
+
+  load_credentials_state_ = LOAD_CREDENTIALS_IN_PROGRESS;
   if (primary_account_id.empty()) {
+    load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_SUCCESS;
     FireRefreshTokensLoaded();
     return;
   }
+
   ValidateAccountId(primary_account_id);
   DCHECK(loading_primary_account_id_.empty());
   DCHECK_EQ(0, web_data_service_request_);
 
   refresh_tokens_.clear();
 
+  scoped_refptr<TokenWebData> token_web_data = client_->GetDatabase();
+  if (!token_web_data) {
+    // This case only exists in unit tests that do not care about loading
+    // credentials.
+    load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_UNKNOWN_ERRORS;
+    FireRefreshTokensLoaded();
+    return;
+  }
+
   // If the account_id is an email address, then canonicalize it.  This
   // is to support legacy account_ids, and will not be needed after
   // switching to gaia-ids.
   if (primary_account_id.find('@') != std::string::npos) {
     loading_primary_account_id_ = gaia::CanonicalizeEmail(primary_account_id);
   } else {
     loading_primary_account_id_ = primary_account_id;
   }
 
-  scoped_refptr<TokenWebData> token_web_data = client_->GetDatabase();
-  if (token_web_data.get())
-    web_data_service_request_ = token_web_data->GetAllTokens(this);
+  web_data_service_request_ = token_web_data->GetAllTokens(this);
 }
 
 void MutableProfileOAuth2TokenServiceDelegate::OnWebDataServiceRequestDone(
     WebDataServiceBase::Handle handle,
     std::unique_ptr<WDTypedResult> result) {
   VLOG(1) << "MutablePO2TS::OnWebDataServiceRequestDone. Result type: "
           << (result.get() == nullptr ? -1 : (int)result->GetType());
 
   // TODO(robliao): Remove ScopedTracker below once https://crbug.com/422460 is
   // fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422460 MutableProfileOAuth2Token...::OnWebDataServiceRequestDone"));
 
   DCHECK_EQ(web_data_service_request_, handle);
   web_data_service_request_ = 0;
 
   if (result) {
     DCHECK(result->GetType() == TOKEN_RESULT);
-    const WDResult<std::map<std::string, std::string>>* token_result =
-        static_cast<const WDResult<std::map<std::string, std::string>>*>(
-            result.get());
-    LoadAllCredentialsIntoMemory(token_result->GetValue());
+    const WDResult<TokenResult>* token_result =
+        static_cast<const WDResult<TokenResult>*>(result.get());
+    LoadAllCredentialsIntoMemory(token_result->GetValue().tokens);
+    load_credentials_state_ =
+        LoadCredentialsStateFromTokenResult(token_result->GetValue().db_result);
+  } else {
+    load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_UNKNOWN_ERRORS;
   }
+  FireRefreshTokensLoaded();
 
   // Make sure that we have an entry for |loading_primary_account_id_| in the
   // map.  The entry could be missing if there is a corruption in the token DB
   // while this profile is connected to an account.
   DCHECK(!loading_primary_account_id_.empty());
   if (refresh_tokens_.count(loading_primary_account_id_) == 0) {
     refresh_tokens_[loading_primary_account_id_].reset(new AccountStatus(
         signin_error_controller_, loading_primary_account_id_, std::string()));
   }
 
@@ skipping 88 matching lines @@
         }
       }
     }
 
     if (!old_login_token.empty()) {
       DCHECK(!loading_primary_account_id_.empty());
       if (refresh_tokens_.count(loading_primary_account_id_) == 0)
         UpdateCredentials(loading_primary_account_id_, old_login_token);
     }
   }
-
-  FireRefreshTokensLoaded();
 }
 
 void MutableProfileOAuth2TokenServiceDelegate::UpdateCredentials(
     const std::string& account_id,
     const std::string& refresh_token) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!account_id.empty());
   DCHECK(!refresh_token.empty());
   ValidateAccountId(account_id);
 
@@ skipping 110 matching lines @@
     net::NetworkChangeNotifier::ConnectionType type) {
   // If our network has changed, reset the backoff timer so that errors caused
   // by a previous lack of network connectivity don't prevent new requests.
   backoff_entry_.Reset();
 }
 
 const net::BackoffEntry*
     MutableProfileOAuth2TokenServiceDelegate::BackoffEntry() const {
   return &backoff_entry_;
 }