Convert chrome/common non-debug logs to debug logs.

chrome/common/net/gaia/gaia_auth_fetcher.cc

 // Copyright (c) 2011 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/common/net/gaia/gaia_auth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 287 matching lines @@
     const std::string& password,
     const char* const service,
     const std::string& login_token,
     const std::string& login_captcha,
     HostedAccountsSetting allow_hosted_accounts) {
 
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
   // This class is thread agnostic, so be sure to call this only on the
   // same thread each time.
-  VLOG(1) << "Starting new ClientLogin fetch for:" << username;
+  DVLOG(1) << "Starting new ClientLogin fetch for:" << username;
 
   // Must outlive fetcher_.
   request_body_ = MakeClientLoginBody(username,
                                       password,
                                       source_,
                                       service,
                                       login_token,
                                       login_captcha,
                                       allow_hosted_accounts);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    client_login_gurl_,
                                    false,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartIssueAuthToken(const std::string& sid,
                                           const std::string& lsid,
                                           const char* const service) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  VLOG(1) << "Starting IssueAuthToken for: " << service;
+  DVLOG(1) << "Starting IssueAuthToken for: " << service;
   requested_service_ = service;
   request_body_ = MakeIssueAuthTokenBody(sid, lsid, service);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    issue_auth_token_gurl_,
                                    false,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartGetUserInfo(const std::string& lsid,
                                        const std::string& info_key) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  VLOG(1) << "Starting GetUserInfo for lsid=" << lsid;
+  DVLOG(1) << "Starting GetUserInfo for lsid=" << lsid;
   request_body_ = MakeGetUserInfoBody(lsid);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    get_user_info_gurl_,
                                    false,
                                    this));
   fetch_pending_ = true;
   requested_info_key_ = info_key;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartTokenAuth(const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  VLOG(1) << "Starting TokenAuth with auth_token=" << auth_token;
+  DVLOG(1) << "Starting TokenAuth with auth_token=" << auth_token;
 
   // The continue URL is a required parameter of the TokenAuth API, but in this
   // case we don't actually need or want to navigate to it.  Setting it to
   // an arbitrary Google URL.
   std::string continue_url("http://www.google.com");
   request_body_ = MakeTokenAuthBody(auth_token, continue_url, source_);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    token_auth_gurl_,
                                    false,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthFetcher::StartMergeSession(const std::string& auth_token) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  VLOG(1) << "Starting MergeSession with auth_token=" << auth_token;
+  DVLOG(1) << "Starting MergeSession with auth_token=" << auth_token;
 
   // The continue URL is a required parameter of the MergeSession API, but in
   // this case we don't actually need or want to navigate to it.  Setting it to
   // an arbitrary Google URL.
   //
   // In order for the new session to be merged correctly, the server needs to
   // know what sessions already exist in the browser.  The fetcher needs to be
   // created such that it sends the cookies with the request, which is
   // different from all other requests the fetcher can make.
   std::string continue_url("http://www.google.com");
   request_body_ = MakeMergeSessionBody(auth_token, continue_url, source_);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    merge_session_gurl_,
                                    true,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateAuthError(
     const std::string& data,
     const net::URLRequestStatus& status) {
   if (!status.is_success()) {
     if (status.status() == net::URLRequestStatus::CANCELED) {
       return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
     } else {
-      LOG(WARNING) << "Could not reach Google Accounts servers: errno "
+      DLOG(WARNING) << "Could not reach Google Accounts servers: errno "
           << status.error();
       return GoogleServiceAuthError::FromConnectionError(status.error());
     }
   } else {
     if (IsSecondFactorSuccess(data)) {
       return GoogleServiceAuthError(GoogleServiceAuthError::TWO_FACTOR);
     }
 
     std::string error;
     std::string url;
     std::string captcha_url;
     std::string captcha_token;
     ParseClientLoginFailure(data, &error, &url, &captcha_url, &captcha_token);
-    LOG(WARNING) << "ClientLogin failed with " << error;
+    DLOG(WARNING) << "ClientLogin failed with " << error;
 
     if (error == kCaptchaError) {
       GURL image_url(
           GaiaUrls::GetInstance()->captcha_url_prefix() + captcha_url);
       GURL unlock_url(url);
       return GoogleServiceAuthError::FromCaptchaChallenge(
           captcha_token, image_url, unlock_url);
     }
     if (error == kAccountDeletedError)
       return GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DELETED);
     if (error == kAccountDisabledError)
       return GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DISABLED);
     if (error == kBadAuthenticationError) {
       return GoogleServiceAuthError(
           GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
     }
     if (error == kServiceUnavailableError) {
       return GoogleServiceAuthError(
           GoogleServiceAuthError::SERVICE_UNAVAILABLE);
     }
 
-    LOG(WARNING) << "Incomprehensible response from Google Accounts servers.";
+    DLOG(WARNING) << "Incomprehensible response from Google Accounts servers.";
     return GoogleServiceAuthError(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
   }
 
   NOTREACHED();
   return GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
 }
 
 // static
 GoogleServiceAuthError GaiaAuthFetcher::GenerateOAuthLoginError(
     const std::string& data,
     const net::URLRequestStatus& status) {
   if (!status.is_success()) {
     if (status.status() == net::URLRequestStatus::CANCELED) {
       return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
     } else {
-      LOG(WARNING) << "Could not reach Google Accounts servers: errno "
+      DLOG(WARNING) << "Could not reach Google Accounts servers: errno "
           << status.error();
       return GoogleServiceAuthError::FromConnectionError(status.error());
     }
   } else {
     if (IsSecondFactorSuccess(data)) {
       return GoogleServiceAuthError(GoogleServiceAuthError::TWO_FACTOR);
     }
 
     std::string error;
     std::string url;
@@ skipping 15 matching lines @@
       return GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DISABLED);
     if (error == kBadAuthenticationErrorCode) {
       return GoogleServiceAuthError(
           GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
     }
     if (error == kServiceUnavailableErrorCode) {
       return GoogleServiceAuthError(
           GoogleServiceAuthError::SERVICE_UNAVAILABLE);
     }
 
-    LOG(WARNING) << "Incomprehensible response from Google Accounts servers.";
+    DLOG(WARNING) << "Incomprehensible response from Google Accounts servers.";
     return GoogleServiceAuthError(
         GoogleServiceAuthError::SERVICE_UNAVAILABLE);
   }
 
   NOTREACHED();
   return GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
 }
 
 void GaiaAuthFetcher::OnClientLoginFetched(const std::string& data,
                                            const net::URLRequestStatus& status,
                                            int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
-    VLOG(1) << "ClientLogin successful!";
+    DVLOG(1) << "ClientLogin successful!";
     std::string sid;
     std::string lsid;
     std::string token;
     ParseClientLoginResponse(data, &sid, &lsid, &token);
     consumer_->OnClientLoginSuccess(
         GaiaAuthConsumer::ClientLoginResult(sid, lsid, token, data));
   } else {
     consumer_->OnClientLoginFailure(GenerateAuthError(data, status));
   }
 }
@@ skipping 79 matching lines @@
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthFetcher::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }