[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 110 matching lines @@
 GoogleServiceAuthError
 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),
+      web_data_service_request_(0),
       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) {
+  DCHECK_EQ(LOAD_CREDENTIALS_NOT_STARTED, load_credentials_state_);
   if (primary_account_id.empty()) {
+    load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_SUCCESS;
     FireRefreshTokensLoaded();
     return;
   }
+
+  load_credentials_state_ = LOAD_CREDENTIALS_IN_PROGRESS;
+
   ValidateAccountId(primary_account_id);
   DCHECK(loading_primary_account_id_.empty());
   DCHECK_EQ(0, web_data_service_request_);
 
   refresh_tokens_.clear();
 
   // 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) {
@@ skipping 17 matching lines @@
   // 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);
+    switch (token_result->GetValue().db_result) {
+      case TokenServiceTable::TOKEN_DB_RESULT_SQL_INVALID_STATEMENT:
+      case TokenServiceTable::TOKEN_DB_RESULT_BAD_ENTRY:
+        load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_DB_ERRORS;
+        break;
+      case TokenServiceTable::TOKEN_DB_RESULT_DECRYPT_ERROR:
+        load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_DECRYPT_ERRORS;
+        break;
+      case TokenServiceTable::TOKEN_DB_RESULT_SUCCESS:
+        load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_SUCCESS;
+        break;
+    }
+    FireRefreshTokensLoaded();
+  } else {
+    load_credentials_state_ = LOAD_CREDENTIALS_FINISHED_WITH_UNKNOWN_ERRORS;
+    // TODO(msarda): Should |FireRefreshTokensLoaded| be called on this branch
+    // as well?

[Roger Tawa OOO till Jul 10th, 2017/02/02 18:58:25]

I'm not sure why you wouldn't fire the event here too.  The error may be
unknown, but an error happened.  And the event is fired for errors.  Was this
causing specific problems elsewhere?

[msarda, 2017/02/03 09:07:09]

It did not cause any specific errors. I did not fire the event here as that
would be a behaviour change for the token service and I did not want that to be
part of this CL.

But I'll probably do that change after your comment.

   }
 
   // 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 89 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_;
 }