Convert LOG(INFO) to VLOG(1) - chrome/common/.

chrome/common/net/gaia/gaia_authenticator2.cc

 // Copyright (c) 2010 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_authenticator2.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 234 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.
-  LOG(INFO) << "Starting new ClientLogin fetch for:" << username;
+  VLOG(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_,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthenticator2::StartIssueAuthToken(const std::string& sid,
                                              const std::string& lsid,
                                              const char* const service) {
 
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  LOG(INFO) << "Starting IssueAuthToken for: " << service;
+  VLOG(1) << "Starting IssueAuthToken for: " << service;
   requested_service_ = service;
   request_body_ = MakeIssueAuthTokenBody(sid, lsid, service);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    issue_auth_token_gurl_,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
 void GaiaAuthenticator2::StartGetUserInfo(const std::string& lsid,
                                           const std::string& info_key) {
   DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
 
-  LOG(INFO) << "Starting GetUserInfo for lsid=" << lsid;
+  VLOG(1) << "Starting GetUserInfo for lsid=" << lsid;
   request_body_ = MakeGetUserInfoBody(lsid);
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    request_body_,
                                    get_user_info_gurl_,
                                    this));
   fetch_pending_ = true;
   requested_info_key_ = info_key;
   fetcher_->Start();
 }
 
@@ skipping 20 matching lines @@
     std::string captcha_url;
     std::string captcha_token;
     ParseClientLoginFailure(data, &error, &url, &captcha_url, &captcha_token);
     LOG(WARNING) << "ClientLogin failed with " << error;
 
     if (error == kCaptchaError) {
       GURL image_url(kCaptchaUrlPrefix + captcha_url);
       GURL unlock_url(url);
       return GoogleServiceAuthError::FromCaptchaChallenge(
           captcha_token, image_url, unlock_url);
-    } else if (error == kAccountDeletedError) {
+    }
+    if (error == kAccountDeletedError)
       return GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DELETED);
-    } else if (error == kAccountDisabledError) {
+    if (error == kAccountDisabledError)
       return GoogleServiceAuthError(GoogleServiceAuthError::ACCOUNT_DISABLED);
-    } else if (error == kServiceUnavailableError) {
+    if (error == kServiceUnavailableError) {
       return GoogleServiceAuthError(
           GoogleServiceAuthError::SERVICE_UNAVAILABLE);
     }
 
     return GoogleServiceAuthError(
         GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
   }
 
   NOTREACHED();
 }
 
 void GaiaAuthenticator2::OnClientLoginFetched(const std::string& data,
                                               const URLRequestStatus& status,
                                               int response_code) {
 
   if (status.is_success() && response_code == RC_REQUEST_OK) {
-    LOG(INFO) << "ClientLogin successful!";
+    VLOG(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 53 matching lines @@
     NOTREACHED();
   }
 }
 
 // static
 bool GaiaAuthenticator2::IsSecondFactorSuccess(
     const std::string& alleged_error) {
   return alleged_error.find(kSecondFactor) !=
       std::string::npos;
 }