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

chrome/test/mini_installer_test/mini_installer_test_util.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/test/mini_installer_test/mini_installer_test_util.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
@@ skipping 63 matching lines @@
   standalone_installer_path.assign(
       mini_installer_constants::kChromeStandAloneInstallerLocation);
   standalone_installer_path.append(file_details.at(0).name_);
   return_command->append(mini_installer_constants::kChromeApplyTagExe);
   return_command->append(L" ");
   return_command->append(standalone_installer_path);
   return_command->append(L" ");
   return_command->append(mini_installer_constants::kStandaloneInstaller);
   return_command->append(L" ");
   return_command->append(mini_installer_constants::kChromeApplyTagParameters);
-  LOG(INFO) << "Command to run Apply tag: " << return_command->c_str();
+  VLOG(1) << "Command to run Apply tag: " << return_command->c_str();
   return true;
 }
 
 std::wstring MiniInstallerTestUtil::GetFilePath(const wchar_t* exe_name) {
   FilePath installer_path;
   PathService::Get(base::DIR_EXE, &installer_path);
   installer_path = installer_path.Append(exe_name);
-  LOG(INFO) << "Chrome exe path: " << installer_path.value().c_str();
+  VLOG(1) << "Chrome exe path: " << installer_path.value().c_str();
   return installer_path.ToWStringHack();
 }
 
 // This method will first call GetLatestFile to get the list of all
 // builds, sorted on creation time. Then goes through each build folder
 // until it finds the installer file that matches the pattern argument.
 bool MiniInstallerTestUtil::GetInstaller(const wchar_t* pattern,
     std::wstring *path, const wchar_t* channel_type, bool chrome_frame) {
   FileInfoList builds_list;
   FileInfoList exe_list;
@@ skipping 26 matching lines @@
   return file_util::PathExists(FilePath::FromWStringHack(*path));
 }
 
 // This method will get the latest installer filename from the directory.
 bool MiniInstallerTestUtil::GetLatestFile(const wchar_t* file_name,
     const wchar_t* pattern, FileInfoList *file_details) {
 
   WIN32_FIND_DATA find_file_data;
   HANDLE file_handle = FindFirstFile(file_name, &find_file_data);
   if (file_handle == INVALID_HANDLE_VALUE) {
-    LOG(INFO) << "Handle is invalid.";
+    VLOG(1) << "Handle is invalid.";
     return false;
   }
   BOOL ret = TRUE;
   bool return_val = false;
   while (ret) {
     std::wstring search_path = find_file_data.cFileName;
     size_t position_found = search_path.find(pattern);
     if (position_found != -1) {
       std::wstring extension = file_util::GetFileExtensionFromPath(file_name);
       if ((base::strcasecmp(WideToUTF8(extension).c_str(), "exe")) == 0) {
@@ skipping 91 matching lines @@
   // Following code will extract build, patch details from the file
   // and concatenate with 1.0 to form the build version.
   // Patteren followed: 1.0.<build>.<patch>htt
   file_name = file_name.substr(22, 25);
   std::wstring::size_type last_dot = file_name.find(L'.');
   file_name = file_name.substr(0, last_dot);
   std::wstring::size_type pos = file_name.find(L'_');
   file_name.replace(pos, 1, L".");
   file_name = L"3.0." + file_name;
   return_file_name->assign(file_name.c_str());
-  LOG(INFO) << "Standalone installer version: " << file_name.c_str();
+  VLOG(1) << "Standalone installer version: " << file_name.c_str();
   return true;
 }
 
 void MiniInstallerTestUtil::SendEnterKeyToWindow() {
   INPUT key;
   key.type = INPUT_KEYBOARD;
   key.ki.wVk = VK_RETURN;
   key.ki.dwFlags = 0;
   key.ki.time = 0;
   key.ki.wScan = 0;
@@ skipping 19 matching lines @@
   if (expected_status)
     ASSERT_NE(0, base::GetProcessCount(process_name, NULL));
   else
     ASSERT_EQ(0, base::GetProcessCount(process_name, NULL));
 }
 
 bool MiniInstallerTestUtil::VerifyProcessClose(
     const wchar_t* process_name) {
   int timer = 0;
   if (base::GetProcessCount(process_name, NULL) > 0) {
-    LOG(INFO) << "Waiting for this process to end: " << process_name;
+    VLOG(1) << "Waiting for this process to end: " << process_name;
     while ((base::GetProcessCount(process_name, NULL) > 0) &&
            (timer < TestTimeouts::large_test_timeout_ms())) {
       PlatformThread::Sleep(200);
       timer = timer + 200;
     }
   } else {
-  if (base::GetProcessCount(process_name, NULL) != 0)
+    if (base::GetProcessCount(process_name, NULL) != 0)
       return false;
   }
   return true;
 }
 
 bool MiniInstallerTestUtil::VerifyProcessHandleClosed(
     base::ProcessHandle handle) {
   DWORD result = WaitForSingleObject(handle,
       TestTimeouts::large_test_timeout_ms());
   return result == WAIT_OBJECT_0;
 }