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

chrome/test/webdriver/session.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/webdriver/session_manager.h"
 
 #ifdef OS_POSIX
 #include <dirent.h>
 #include <unistd.h>
 #include <sys/stat.h>
@@ skipping 51 matching lines @@
 
 Session::Session(const std::string& id)
     : UITestBase(), id_(id), window_num_(0), implicit_wait_(0),
       current_frame_xpath_(L"") {
 }
 
 bool Session::Init() {
   // Create a temp directory for the new profile.
   if (!CreateTemporaryProfileDirectory()) {
     LOG(ERROR) << "Could not make a temp profile directory, "
-               << tmp_profile_dir() << std::endl
-               << "Need to quit, the issue must be fixed";
+               << tmp_profile_dir()
+               << "\nNeed to quit, the issue must be fixed";
     exit(-1);
   }
 
   SetupCommandLine();
   LaunchBrowserAndServer();
   return LoadProxies();
 }
 
 scoped_refptr<TabProxy> Session::ActiveTab() {
   int tab_index;
@@ skipping 72 matching lines @@
     LOG(ERROR) << "Could not generate temp directory name";
     return false;
   }
 
   if (!CreateDirectoryA(tmp_profile_dir_, NULL)) {
     DWORD dw = GetLastError();
     LOG(ERROR) << "Error code: " << dw;
     return false;
   }
 #endif
-  LOG(INFO) << "Using temporary profile directory: " << tmp_profile_dir_;
+  VLOG(1) << "Using temporary profile directory: " << tmp_profile_dir_;
   return true;
 }
 
 void Session::Terminate() {
   QuitBrowser();
 #ifdef OS_POSIX
   FilePath del_dir = FilePath(tmp_profile_dir());
 #elif OS_WIN
   FilePath del_dir = FilePath(ASCIIToWide(tmp_profile_dir()));
 #endif
-  if (file_util::PathExists(del_dir) && !file_util::Delete(del_dir, true)) {
-    LOG(ERROR) << "Could not clean up temp directory: "
-               << tmp_profile_dir() << std::endl;
-  }
+  if (file_util::PathExists(del_dir) && !file_util::Delete(del_dir, true))
+    LOG(ERROR) << "Could not clean up temp directory: " << tmp_profile_dir();
 }
 
 ErrorCode Session::ExecuteScript(const std::wstring& script,
                                  const ListValue* const args,
                                  Value** value) {
   std::string args_as_json;
   base::JSONWriter::Write(static_cast<const Value* const>(args),
                           /*pretty_print=*/false,
                           &args_as_json);
 
-  std::wstring jscript = L"window.domAutomationController.send(";
-  jscript.append(L"(function(){")
-  // Every injected script is fed through the executeScript atom. This atom
-  // will catch any errors that are thrown and convert them to the
-  // appropriate JSON structure.
-  .append(build_atom(EXECUTE_SCRIPT, sizeof EXECUTE_SCRIPT))
-  .append(L"var result = executeScript(function(){")
-  .append(script)
-  .append(L"},")
-  .append(ASCIIToWide(args_as_json))
-  .append(L");return JSON.stringify(result);})());");
+  std::wstring jscript = L"window.domAutomationController.send((function(){" +
+      // Every injected script is fed through the executeScript atom. This atom
+      // will catch any errors that are thrown and convert them to the
+      // appropriate JSON structure.
+      build_atom(EXECUTE_SCRIPT, sizeof EXECUTE_SCRIPT) +
+      L"var result = executeScript(function(){" + script + L"}," +
+      ASCIIToWide(args_as_json) + L");return JSON.stringify(result);})());";
 
   // Should we also log the script that's being executed? It could be several KB
   // in size and will add lots of noise to the logs.
-  LOG(INFO) << "Executing script in frame: " << current_frame_xpath_;
+  VLOG(1) << "Executing script in frame: " << current_frame_xpath_;
 
   std::wstring result;
   scoped_refptr<TabProxy> tab = ActiveTab();
   if (!tab->ExecuteAndExtractString(current_frame_xpath_, jscript, &result)) {
     *value = Value::CreateStringValue(
         "Unknown internal script execution failure");
     return kUnknownError;
   }
 
-  LOG(INFO) << "...script result: " << result;
+  VLOG(1) << "...script result: " << result;
   std::string temp = WideToASCII(result);
   scoped_ptr<Value> r(base::JSONReader::ReadAndReturnError(
       temp, true, NULL, NULL));
   if (!r.get()) {
     *value = Value::CreateStringValue(
         "Internal script execution error: failed to parse script result");
     return kUnknownError;
   }
 
   if (r->GetType() != Value::TYPE_DICTIONARY) {
     std::ostringstream stream;
     stream << "Internal script execution error: script result must be a "
-      << print_valuetype(Value::TYPE_DICTIONARY)
-      << ", but was "
-      << print_valuetype(r->GetType()) << ": " << result;
+           << print_valuetype(Value::TYPE_DICTIONARY) << ", but was "
+           << print_valuetype(r->GetType()) << ": " << result;
     *value = Value::CreateStringValue(stream.str());
     return kUnknownError;
   }
 
   DictionaryValue* result_dict = static_cast<DictionaryValue*>(r.get());
 
   Value* tmp;
   if (result_dict->Get("value", &tmp)) {
     // result_dict owns the returned value, so we need to make a copy.
     *value = tmp->DeepCopy();
   } else {
     // "value" was not defined in the returned dictionary, set to null.
     *value = Value::CreateNullValue();
   }
 
   int status;
   if (!result_dict->GetInteger("status", &status)) {
     NOTREACHED() << "...script did not return a status flag.";
   }
   return static_cast<ErrorCode>(status);
 }
 
 }  // namespace webdriver