Convert LOG(INFO) to VLOG(1) - chrome/browser/chromeos/login/....

chrome/browser/chromeos/login/google_authenticator.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/browser/chromeos/login/google_authenticator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 50 matching lines @@
   CHECK(chromeos::CrosLibrary::Get()->EnsureLoaded());
   // If not already owned, this is a no-op.  If it is, this loads the owner's
   // public key off of disk.
   OwnershipService::GetSharedInstance()->StartLoadOwnerKeyAttempt();
 }
 
 GoogleAuthenticator::~GoogleAuthenticator() {}
 
 void GoogleAuthenticator::CancelClientLogin() {
   if (gaia_authenticator_->HasPendingFetch()) {
-    LOG(INFO) << "Canceling ClientLogin attempt.";
+    VLOG(1) << "Canceling ClientLogin attempt.";
     gaia_authenticator_->CancelRequest();
 
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this,
                           &GoogleAuthenticator::LoadLocalaccount,
                           std::string(kLocalaccountFile)));
 
     CheckOffline(LoginFailure(LoginFailure::LOGIN_TIMED_OUT));
   }
@@ skipping 56 matching lines @@
   return true;
 }
 
 bool GoogleAuthenticator::AuthenticateToUnlock(const std::string& username,
                                                const std::string& password) {
   username_.assign(Canonicalize(username));
   ascii_hash_.assign(HashPassword(password));
   unlock_ = true;
   LoadLocalaccount(kLocalaccountFile);
   if (!localaccount_.empty() && localaccount_ == username) {
-    LOG(INFO) << "unlocking local account";
+    VLOG(1) << "Unlocking localaccount";
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this,
                           &GoogleAuthenticator::OnLoginSuccess,
                           GaiaAuthConsumer::ClientLoginResult(), false));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &GoogleAuthenticator::CheckOffline,
                           LoginFailure(LoginFailure::UNLOCK_FAILED)));
@@ skipping 14 matching lines @@
   } else {
     LOG(ERROR) << "Could not mount tmpfs: " << mount_error;
     consumer_->OnLoginFailure(
         LoginFailure(LoginFailure::COULD_NOT_MOUNT_TMPFS));
   }
 }
 
 void GoogleAuthenticator::OnClientLoginSuccess(
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
 
-  LOG(INFO) << "Online login successful!";
+  VLOG(1) << "Online login successful!";
   ClearClientLoginAttempt();
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(this,
                         &GoogleAuthenticator::OnLoginSuccess,
                         credentials, false));
 }
 
 void GoogleAuthenticator::OnClientLoginFailure(
@@ skipping 60 matching lines @@
     consumer_->OnLoginSuccess(username_, credentials, request_pending);
   } else if (!unlock_ &&
              mount_error == chromeos::kCryptohomeMountErrorKeyFailure) {
     consumer_->OnPasswordChangeDetected(credentials);
   } else {
     OnLoginFailure(LoginFailure(LoginFailure::COULD_NOT_MOUNT_CRYPTOHOME));
   }
 }
 
 void GoogleAuthenticator::CheckOffline(const LoginFailure& error) {
-  LOG(INFO) << "Attempting offline login";
+  VLOG(1) << "Attempting offline login";
   if (CrosLibrary::Get()->GetCryptohomeLibrary()->CheckKey(
           username_.c_str(),
           ascii_hash_.c_str())) {
     // The fetch didn't succeed, but offline login did.
-    LOG(INFO) << "Offline login successful!";
+    VLOG(1) << "Offline login successful!";
     OnLoginSuccess(GaiaAuthConsumer::ClientLoginResult(), false);
   } else {
     // We couldn't hit the network, and offline login failed.
     GoogleAuthenticator::CheckLocalaccount(error);
   }
 }
 
 void GoogleAuthenticator::CheckLocalaccount(const LoginFailure& error) {
   {
     AutoLock for_this_block(localaccount_lock_);
-    LOG(INFO) << "Checking localaccount";
+    VLOG(1) << "Checking localaccount";
     if (!checked_for_localaccount_) {
       BrowserThread::PostDelayedTask(
           BrowserThread::UI,
           FROM_HERE,
           NewRunnableMethod(this,
                             &GoogleAuthenticator::CheckLocalaccount,
                             error),
           kLocalaccountRetryIntervalMs);
       return;
     }
@@ skipping 71 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   {
     AutoLock for_this_block(localaccount_lock_);
     if (checked_for_localaccount_)
       return;
   }
   FilePath localaccount_file;
   std::string localaccount;
   if (PathService::Get(base::DIR_EXE, &localaccount_file)) {
     localaccount_file = localaccount_file.Append(filename);
-    LOG(INFO) << "looking for localaccount in " << localaccount_file.value();
+    VLOG(1) << "Looking for localaccount in " << localaccount_file.value();
 
     ReadFileToString(localaccount_file, &localaccount);
     TrimWhitespaceASCII(localaccount, TRIM_TRAILING, &localaccount);
-    LOG(INFO) << "Loading localaccount: " << localaccount;
+    VLOG(1) << "Loading localaccount: " << localaccount;
   } else {
-    LOG(INFO) << "Assuming no localaccount";
+    VLOG(1) << "Assuming no localaccount";
   }
   SetLocalaccount(localaccount);
 }
 
 void GoogleAuthenticator::SetLocalaccount(const std::string& new_name) {
   localaccount_ = new_name;
   {  // extra braces for clarity about AutoLock scope.
     AutoLock for_this_block(localaccount_lock_);
     checked_for_localaccount_ = true;
   }
@@ skipping 51 matching lines @@
                                       const unsigned int len) {
   if (len < 2*binary_len)
     return false;
   memset(hex_string, 0, len);
   for (uint i = 0, j = 0; i < binary_len; i++, j+=2)
     snprintf(hex_string + j, len - j, "%02x", binary[i]);
   return true;
 }
 
 }  // namespace chromeos