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

chrome/browser/chromeos/login/parallel_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/parallel_authenticator.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 111 matching lines @@
   guest_mounter_ =
       CryptohomeOp::CreateMountGuestAttempt(current_state_.get(), this);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   guest_mounter_->Initiate();
 }
 
 void ParallelAuthenticator::OnLoginSuccess(
     const GaiaAuthConsumer::ClientLoginResult& credentials,
     bool request_pending) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  LOG(INFO) << "Online login success";
+  VLOG(1) << "Online login success";
   // Send notification of success
   AuthenticationNotificationDetails details(true);
   NotificationService::current()->Notify(
       NotificationType::LOGIN_AUTHENTICATION,
       NotificationService::AllSources(),
       Details<AuthenticationNotificationDetails>(&details));
   {
     AutoLock for_this_block(success_lock_);
     already_reported_success_ = true;
   }
@@ skipping 15 matching lines @@
 
 void ParallelAuthenticator::OnPasswordChangeDetected(
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   consumer_->OnPasswordChangeDetected(credentials);
 }
 
 void ParallelAuthenticator::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::FILE, FROM_HERE,
           NewRunnableMethod(this,
                             &ParallelAuthenticator::CheckLocalaccount,
                             error),
           kLocalaccountRetryIntervalMs);
       return;
     }
   }
@@ skipping 235 matching lines @@
 
   if (state != POSSIBLE_PW_CHANGE &&
       state != NO_MOUNT &&
       state != OFFLINE_LOGIN)
     return state;
 
   if (current_state_->online_complete()) {
     if (current_state_->online_outcome().reason() == LoginFailure::NONE) {
       // Online attempt succeeded as well, so combine the results.
       return ResolveOnlineSuccessState(state);
-    } else {
-      // Online login attempt was rejected or failed to occur.
-      return ResolveOnlineFailureState(state);
     }
+    // Online login attempt was rejected or failed to occur.
+    return ResolveOnlineFailureState(state);
   }
   // if online isn't complete yet, just return the offline result.
   return state;
 }
 
 ParallelAuthenticator::AuthState
 ParallelAuthenticator::ResolveReauthState() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (reauth_state_->cryptohome_complete()) {
     if (!reauth_state_->cryptohome_outcome()) {
       // If we've tried to migrate and failed, log the error and just wait
       // til next time the user logs in to migrate their cryptohome key.
       LOG(ERROR) << "Failed to migrate cryptohome key: "
                  << reauth_state_->cryptohome_code();
     }
     reauth_state_.reset(NULL);
     return ONLINE_LOGIN;
   }
   // Haven't tried the migrate yet, must be processing the online auth attempt.
   if (!reauth_state_->online_complete()) {
     NOTREACHED();  // Shouldn't be here at all, if online reauth isn't done!
     return CONTINUE;
   }
-  if (reauth_state_->online_outcome().reason() == LoginFailure::NONE)
-    return HAVE_NEW_PW;
-  else
-    return NEED_NEW_PW;
+  return (reauth_state_->online_outcome().reason() == LoginFailure::NONE) ?
+      HAVE_NEW_PW : NEED_NEW_PW;
 }
 
 ParallelAuthenticator::AuthState
 ParallelAuthenticator::ResolveCryptohomeFailureState() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (data_remover_.get()) {
+  if (data_remover_.get())
     return FAILED_REMOVE;
-  } else if (guest_mounter_.get()) {
+  if (guest_mounter_.get())
     return FAILED_TMPFS;
-  } else if (key_migrator_.get()) {
+  if (key_migrator_.get())
     return NEED_OLD_PW;
-  } else if (key_checker_.get()) {
+  if (key_checker_.get())
     return LOGIN_FAILED;
-  } else if (current_state_->cryptohome_code() ==
-             chromeos::kCryptohomeMountErrorKeyFailure) {
+  if (current_state_->cryptohome_code() ==
+      chromeos::kCryptohomeMountErrorKeyFailure) {
     // If we tried a mount but they used the wrong key, we may need to
     // ask the user for her old password.  We'll only know once we've
     // done the online check.
     return POSSIBLE_PW_CHANGE;
-  } else if (current_state_->cryptohome_code() ==
-             chromeos::kCryptohomeMountErrorUserDoesNotExist) {
+  }
+  if (current_state_->cryptohome_code() ==
+      chromeos::kCryptohomeMountErrorUserDoesNotExist) {
     // If we tried a mount but the user did not exist, then we should wait
     // for online login to succeed and try again with the "create" flag set.
     return NO_MOUNT;
-  } else {
-    return FAILED_MOUNT;
   }
+  return FAILED_MOUNT;
 }
 
 ParallelAuthenticator::AuthState
 ParallelAuthenticator::ResolveCryptohomeSuccessState() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (data_remover_.get()) {
+  if (data_remover_.get())
     return CREATE_NEW;
-  } else if (guest_mounter_.get()) {
+  if (guest_mounter_.get())
     return LOCAL_LOGIN;
-  } else if (key_migrator_.get()) {
+  if (key_migrator_.get())
     return RECOVER_MOUNT;
-  } else if (key_checker_.get()) {
+  if (key_checker_.get())
     return UNLOCK;
-  } else {
-    return OFFLINE_LOGIN;
-  }
+  return OFFLINE_LOGIN;
 }
 
 ParallelAuthenticator::AuthState
 ParallelAuthenticator::ResolveOnlineFailureState(
     ParallelAuthenticator::AuthState offline_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (offline_state == OFFLINE_LOGIN) {
     if (current_state_->online_outcome().error().state() ==
         GoogleServiceAuthError::CONNECTION_FAILED) {
       // Couldn't do an online check, so just go with the offline result.
       return OFFLINE_LOGIN;
     }
     // Otherwise, online login was rejected!
     if (current_state_->online_outcome().error().state() ==
         GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS) {
       return NEED_NEW_PW;
-    } else {
-      return ONLINE_FAILED;
     }
+    return ONLINE_FAILED;
   }
   return LOGIN_FAILED;
 }
 
 ParallelAuthenticator::AuthState
 ParallelAuthenticator::ResolveOnlineSuccessState(
     ParallelAuthenticator::AuthState offline_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   switch (offline_state) {
     case POSSIBLE_PW_CHANGE:
@@ skipping 20 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 ParallelAuthenticator::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 32 matching lines @@
 
 std::string ParallelAuthenticator::SaltAsAscii() {
   LoadSystemSalt();  // no-op if it's already loaded.
   unsigned int salt_len = system_salt_.size();
   char ascii_salt[2 * salt_len + 1];
   if (ParallelAuthenticator::BinaryToHex(system_salt_,
                                        salt_len,
                                        ascii_salt,
                                        sizeof(ascii_salt))) {
     return std::string(ascii_salt, sizeof(ascii_salt) - 1);
-  } else {
-    return std::string();
   }
+  return std::string();
 }
 
 // static
 bool ParallelAuthenticator::BinaryToHex(
     const std::vector<unsigned char>& binary,
     const unsigned int binary_len,
     char* hex_string,
     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