favor DCHECK_CURRENTLY_ON for better logs in chrome/browser/chromeos/

chrome/browser/chromeos/login/signin/oauth2_token_fetcher.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 "chrome/browser/chromeos/login/signin/oauth2_token_fetcher.h"
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "chromeos/network/network_handler.h"
 #include "chromeos/network/network_state.h"
@@ skipping 24 matching lines @@
       retry_count_(0) {
   DCHECK(delegate);
 }
 
 OAuth2TokenFetcher::~OAuth2TokenFetcher() {
 }
 
 void OAuth2TokenFetcher::StartExchangeFromCookies(
     const std::string& session_index,
     const std::string& signin_scoped_device_id) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   session_index_ = session_index;
   signin_scoped_device_id_ = signin_scoped_device_id;
   // Delay the verification if the network is not connected or on a captive
   // portal.
   const NetworkState* default_network =
       NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (!default_network ||
       default_network->connection_state() == shill::kStatePortal) {
     // If network is offline, defer the token fetching until online.
     VLOG(1) << "Network is offline.  Deferring OAuth2 token fetch.";
     BrowserThread::PostDelayedTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&OAuth2TokenFetcher::StartExchangeFromCookies,
                    AsWeakPtr(),
                    session_index,
                    signin_scoped_device_id),
         base::TimeDelta::FromMilliseconds(kRequestRestartDelay));
     return;
   }
   auth_fetcher_.StartCookieForOAuthLoginTokenExchangeWithDeviceId(
       session_index, signin_scoped_device_id);
 }
 
 void OAuth2TokenFetcher::StartExchangeFromAuthCode(
     const std::string& auth_code) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   auth_code_ = auth_code;
   // Delay the verification if the network is not connected or on a captive
   // portal.
   const NetworkState* default_network =
       NetworkHandler::Get()->network_state_handler()->DefaultNetwork();
   if (!default_network ||
       default_network->connection_state() == shill::kStatePortal) {
     // If network is offline, defer the token fetching until online.
     VLOG(1) << "Network is offline.  Deferring OAuth2 token fetch.";
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&OAuth2TokenFetcher::StartExchangeFromAuthCode,
                    AsWeakPtr(),
                    auth_code),
         base::TimeDelta::FromMilliseconds(kRequestRestartDelay));
     return;
   }
   auth_fetcher_.StartAuthCodeForOAuth2TokenExchange(auth_code);
 }
 
 void OAuth2TokenFetcher::OnClientOAuthSuccess(
     const GaiaAuthConsumer::ClientOAuthResult& oauth_tokens) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   VLOG(1) << "Got OAuth2 tokens!";
   retry_count_ = 0;
   oauth_tokens_ = oauth_tokens;
   delegate_->OnOAuth2TokensAvailable(oauth_tokens_);
 }
 
 void OAuth2TokenFetcher::OnClientOAuthFailure(
     const GoogleServiceAuthError& error) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RetryOnError(error,
                auth_code_.empty()
                    ? base::Bind(&OAuth2TokenFetcher::StartExchangeFromCookies,
                                 AsWeakPtr(),
                                 session_index_,
                                 signin_scoped_device_id_)
                    : base::Bind(&OAuth2TokenFetcher::StartExchangeFromAuthCode,
                                 AsWeakPtr(),
                                 auth_code_),
                base::Bind(&Delegate::OnOAuth2TokensFetchFailed,
                           base::Unretained(delegate_)));
 }
 
 void OAuth2TokenFetcher::RetryOnError(const GoogleServiceAuthError& error,
                                       const base::Closure& task,
                                       const base::Closure& error_handler) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if ((error.state() == GoogleServiceAuthError::CONNECTION_FAILED ||
        error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE ||
        error.state() == GoogleServiceAuthError::REQUEST_CANCELED) &&
       retry_count_ < kMaxRequestAttemptCount) {
     retry_count_++;
     BrowserThread::PostDelayedTask(
         BrowserThread::UI, FROM_HERE, task,
         base::TimeDelta::FromMilliseconds(kRequestRestartDelay));
     return;
   }
   LOG(ERROR) << "Unrecoverable error or retry count max reached. State: "
              << error.state() << ", network error: " << error.network_error()
              << ", message: " << error.error_message();
   error_handler.Run();
 }
 
 }  // namespace chromeos