[chromedriver] Remove Logger and just use base LOG.

BUG=none
R=chrisgao@chromium.org

Review URL: https://codereview.chromium.org/23566018

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@221521 0039d316-1c4b-4281-b951-d872f2087c98

chrome/chrome_tests.gypi

@@ -846,6 +846,8 @@
         'test/chromedriver/chrome/status.h',
         'test/chromedriver/chrome/ui_events.cc',
         'test/chromedriver/chrome/ui_events.h',
+        'test/chromedriver/chrome/util.cc',
+        'test/chromedriver/chrome/util.h',
         'test/chromedriver/chrome/version.cc',
         'test/chromedriver/chrome/version.h',
         'test/chromedriver/chrome/web_view.h',

chrome/test/chromedriver/capabilities.cc

@@ -9,6 +9,7 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/string_escape.h"
+#include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_tokenizer.h"
@@ -16,8 +17,8 @@
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
+#include "chrome/test/chromedriver/logging.h"
 #include "net/base/net_util.h"
 
 namespace {
@@ -68,13 +69,10 @@ Status ParseDict(scoped_ptr<base::DictionaryValue>* to_set,
 }
 
 Status IgnoreDeprecatedOption(
-    Log* log,
     const char* option_name,
     const base::Value& option,
     Capabilities* capabilities) {
-  log->AddEntry(Log::kWarning,
-                base::StringPrintf("deprecated chrome option is ignored: '%s'",
-                                   option_name));
+  LOG(WARNING) << "Deprecated chrome option is ignored: " << option_name;
   return Status(kOk);
 }
 
@@ -223,18 +221,25 @@ Status ParseUseExistingBrowser(const base::Value& option,
 
 Status ParseLoggingPrefs(const base::Value& option,
                          Capabilities* capabilities) {
-  const base::DictionaryValue* logging_prefs_dict = NULL;
-  if (!option.GetAsDictionary(&logging_prefs_dict))
+  const base::DictionaryValue* logging_prefs = NULL;
+  if (!option.GetAsDictionary(&logging_prefs))
     return Status(kUnknownError, "must be a dictionary");
 
-  // TODO(klm): verify log types.
-  // TODO(klm): verify log levels.
-  capabilities->logging_prefs.reset(logging_prefs_dict->DeepCopy());
+  for (base::DictionaryValue::Iterator pref(*logging_prefs);
+       !pref.IsAtEnd(); pref.Advance()) {
+    std::string type = pref.key();
+    Log::Level level;
+    std::string level_name;
+    if (!pref.value().GetAsString(&level_name) ||
+        !WebDriverLog::NameToLevel(level_name, &level)) {
+      return Status(kUnknownError, "invalid log level for '" + type + "' log");
+    }
+    capabilities->logging_prefs.insert(std::make_pair(type, level));
+  }
   return Status(kOk);
 }
 
 Status ParseChromeOptions(
-    Log* log,
     const base::Value& capability,
     Capabilities* capabilities) {
   const base::DictionaryValue* chrome_options = NULL;
@@ -270,8 +275,7 @@ Status ParseChromeOptions(
     parser_map["extensions"] = base::Bind(&ParseExtensions);
     parser_map["forceDevToolsScreenshot"] = base::Bind(
         &ParseBoolean, &capabilities->force_devtools_screenshot);
-    parser_map["loadAsync"] =
-        base::Bind(&IgnoreDeprecatedOption, log, "loadAsync");
+    parser_map["loadAsync"] = base::Bind(&IgnoreDeprecatedOption, "loadAsync");
     parser_map["localState"] =
         base::Bind(&ParseDict, &capabilities->local_state);
     parser_map["logPath"] = base::Bind(&ParseLogPath);
@@ -414,11 +418,9 @@ bool Capabilities::IsExistingBrowser() const {
   return debugger_address.IsValid();
 }
 
-Status Capabilities::Parse(
-    const base::DictionaryValue& desired_caps,
-    Log* log) {
+Status Capabilities::Parse(const base::DictionaryValue& desired_caps) {
   std::map<std::string, Parser> parser_map;
-  parser_map["chromeOptions"] = base::Bind(&ParseChromeOptions, log);
+  parser_map["chromeOptions"] = base::Bind(&ParseChromeOptions);
   parser_map["loggingPrefs"] = base::Bind(&ParseLoggingPrefs);
   parser_map["proxy"] = base::Bind(&ParseProxy);
   for (std::map<std::string, Parser>::iterator it = parser_map.begin();

chrome/test/chromedriver/capabilities.h

@@ -14,6 +14,7 @@
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string16.h"
+#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/net/net_util.h"
 
 namespace base {
@@ -21,7 +22,6 @@ class DictionaryValue;
 }
 
 class CommandLine;
-class Log;
 class Status;
 
 class Switches {
@@ -57,6 +57,8 @@ class Switches {
   SwitchMap switch_map_;
 };
 
+typedef std::map<std::string, Log::Level> LoggingPrefs;
+
 struct Capabilities {
   Capabilities();
   ~Capabilities();
@@ -67,7 +69,7 @@ struct Capabilities {
   // Return true if android package is specified.
   bool IsAndroid() const;
 
-  Status Parse(const base::DictionaryValue& desired_caps, Log* log);
+  Status Parse(const base::DictionaryValue& desired_caps);
 
   std::string android_activity;
 
@@ -101,7 +103,7 @@ struct Capabilities {
 
   std::string log_path;
 
-  scoped_ptr<base::DictionaryValue> logging_prefs;
+  LoggingPrefs logging_prefs;
 
   scoped_ptr<base::DictionaryValue> prefs;
 

chrome/test/chromedriver/capabilities_unittest.cc

@@ -101,8 +101,7 @@ TEST(ParseCapabilities, WithAndroidPackage) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("chromeOptions.androidPackage", "abc");
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.IsAndroid());
   ASSERT_EQ("abc", capabilities.android_package);
@@ -112,8 +111,7 @@ TEST(ParseCapabilities, EmptyAndroidPackage) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("chromeOptions.androidPackage", std::string());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -121,8 +119,7 @@ TEST(ParseCapabilities, IllegalAndroidPackage) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetInteger("chromeOptions.androidPackage", 123);
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -130,8 +127,7 @@ TEST(ParseCapabilities, LogPath) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("chromeOptions.logPath", "path/to/logfile");
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_STREQ("path/to/logfile", capabilities.log_path.c_str());
 }
@@ -144,8 +140,7 @@ TEST(ParseCapabilities, Args) {
   base::DictionaryValue caps;
   caps.Set("chromeOptions.args", args.DeepCopy());
 
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
 
   ASSERT_EQ(2u, capabilities.switches.GetSize());
@@ -162,8 +157,7 @@ TEST(ParseCapabilities, Prefs) {
   prefs.SetString("key2.k", "value2");
   base::DictionaryValue caps;
   caps.Set("chromeOptions.prefs", prefs.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.prefs->Equals(&prefs));
 }
@@ -175,8 +169,7 @@ TEST(ParseCapabilities, LocalState) {
   local_state.SetString("s2.s", "v2");
   base::DictionaryValue caps;
   caps.Set("chromeOptions.localState", local_state.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.local_state->Equals(&local_state));
 }
@@ -188,8 +181,7 @@ TEST(ParseCapabilities, Extensions) {
   extensions.AppendString("ext2");
   base::DictionaryValue caps;
   caps.Set("chromeOptions.extensions", extensions.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.extensions.size());
   ASSERT_EQ("ext1", capabilities.extensions[0]);
@@ -202,8 +194,7 @@ TEST(ParseCapabilities, UnrecognizedProxyType) {
   proxy.SetString("proxyType", "unknown proxy type");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -213,8 +204,7 @@ TEST(ParseCapabilities, IllegalProxyType) {
   proxy.SetInteger("proxyType", 123);
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -224,8 +214,7 @@ TEST(ParseCapabilities, DirectProxy) {
   proxy.SetString("proxyType", "DIRECT");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("no-proxy-server"));
@@ -237,8 +226,7 @@ TEST(ParseCapabilities, SystemProxy) {
   proxy.SetString("proxyType", "system");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(0u, capabilities.switches.GetSize());
 }
@@ -250,8 +238,7 @@ TEST(ParseCapabilities, PacProxy) {
   proxy.SetString("proxyAutoconfigUrl", "test.wpad");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_EQ("test.wpad", capabilities.switches.GetSwitchValue("proxy-pac-url"));
@@ -264,8 +251,7 @@ TEST(ParseCapabilities, MissingProxyAutoconfigUrl) {
   proxy.SetString("httpProxy", "http://localhost:8001");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -275,8 +261,7 @@ TEST(ParseCapabilities, AutodetectProxy) {
   proxy.SetString("proxyType", "autodetect");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-auto-detect"));
@@ -292,8 +277,7 @@ TEST(ParseCapabilities, ManualProxy) {
   proxy.SetString("noProxy", "google.com, youtube.com");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.switches.GetSize());
   ASSERT_EQ(
@@ -310,8 +294,7 @@ TEST(ParseCapabilities, MissingSettingForManualProxy) {
   proxy.SetString("proxyType", "manual");
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -324,8 +307,7 @@ TEST(ParseCapabilities, IgnoreNullValueForManualProxy) {
   proxy.Set("noProxy", base::Value::CreateNullValue());
   base::DictionaryValue caps;
   caps.Set("proxy", proxy.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(1u, capabilities.switches.GetSize());
   ASSERT_TRUE(capabilities.switches.HasSwitch("proxy-server"));
@@ -340,22 +322,17 @@ TEST(ParseCapabilities, LoggingPrefsOk) {
   logging_prefs.SetString("Network", "INFO");
   base::DictionaryValue caps;
   caps.Set("loggingPrefs", logging_prefs.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
-  ASSERT_TRUE(capabilities.logging_prefs.get());
-  ASSERT_EQ(1u, capabilities.logging_prefs->size());
-  std::string log_level;
-  ASSERT_TRUE(capabilities.logging_prefs->GetString("Network", &log_level));
-  ASSERT_STREQ("INFO", log_level.c_str());
+  ASSERT_EQ(1u, capabilities.logging_prefs.size());
+  ASSERT_EQ(Log::kInfo, capabilities.logging_prefs["Network"]);
 }
 
 TEST(ParseCapabilities, LoggingPrefsNotDict) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("loggingPrefs", "INFO");
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_FALSE(status.IsOk());
 }
 
@@ -366,8 +343,7 @@ TEST(ParseCapabilities, ExcludeSwitches) {
   exclude_switches.AppendString("switch2");
   base::DictionaryValue caps;
   caps.Set("chromeOptions.excludeSwitches", exclude_switches.DeepCopy());
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, capabilities.exclude_switches.size());
   const std::set<std::string>& switches = capabilities.exclude_switches;
@@ -379,8 +355,7 @@ TEST(ParseCapabilities, UseExistingBrowser) {
   Capabilities capabilities;
   base::DictionaryValue caps;
   caps.SetString("chromeOptions.debuggerAddress", "abc:123");
-  Logger log(Log::kError);
-  Status status = capabilities.Parse(caps, &log);
+  Status status = capabilities.Parse(caps);
   ASSERT_TRUE(status.IsOk());
   ASSERT_TRUE(capabilities.IsExistingBrowser());
   ASSERT_EQ("abc", capabilities.debugger_address.host());

chrome/test/chromedriver/chrome/adb_impl.cc

@@ -17,7 +17,6 @@
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/net/adb_client_socket.h"
 
@@ -74,8 +73,8 @@ void ExecuteCommandOnIOThread(
 
 AdbImpl::AdbImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    Log* log, int port)
-    : io_task_runner_(io_task_runner), log_(log), port_(port) {
+    int port)
+    : io_task_runner_(io_task_runner), port_(port) {
   CHECK(io_task_runner_.get());
 }
 
@@ -219,14 +218,15 @@ Status AdbImpl::GetPidByName(const std::string& device_serial,
 Status AdbImpl::ExecuteCommand(
     const std::string& command, std::string* response) {
   scoped_refptr<ResponseBuffer> response_buffer = new ResponseBuffer;
-  log_->AddEntry(Log::kDebug, "Sending adb command: " + command);
+  VLOG(1) << "Sending adb command: " << command;
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&ExecuteCommandOnIOThread, command, response_buffer, port_));
   Status status = response_buffer->GetResponse(
       response, base::TimeDelta::FromSeconds(30));
-  if (status.IsOk())
-    log_->AddEntry(Log::kDebug, "Received adb response: " + *response);
+  if (status.IsOk()) {
+    VLOG(1) << "Received adb response: " << *response;
+  }
   return status;
 }
 

chrome/test/chromedriver/chrome/adb_impl.h

@@ -16,14 +16,13 @@ namespace base {
 class SingleThreadTaskRunner;
 }
 
-class Log;
 class Status;
 
 class AdbImpl : public Adb {
  public:
   explicit AdbImpl(
       const scoped_refptr<base::SingleThreadTaskRunner>& io_message_loop_proxy,
-      Log* log, int port);
+      int port);
   virtual ~AdbImpl();
 
   // Overridden from Adb:
@@ -60,7 +59,6 @@ class AdbImpl : public Adb {
 
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
-  Log* log_;
   int port_;
 };
 

chrome/test/chromedriver/chrome/chrome_android_impl.cc

@@ -11,9 +11,8 @@
 ChromeAndroidImpl::ChromeAndroidImpl(
     scoped_ptr<DevToolsHttpClient> client,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-    scoped_ptr<Device> device,
-    Log* log)
-    : ChromeImpl(client.Pass(), devtools_event_listeners, log),
+    scoped_ptr<Device> device)
+    : ChromeImpl(client.Pass(), devtools_event_listeners),
       device_(device.Pass()) {}
 
 ChromeAndroidImpl::~ChromeAndroidImpl() {}

chrome/test/chromedriver/chrome/chrome_android_impl.h

@@ -19,8 +19,7 @@ class ChromeAndroidImpl : public ChromeImpl {
   ChromeAndroidImpl(
       scoped_ptr<DevToolsHttpClient> client,
       ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-      scoped_ptr<Device> device,
-      Log* log);
+      scoped_ptr<Device> device);
   virtual ~ChromeAndroidImpl();
 
   // Overridden from Chrome:

chrome/test/chromedriver/chrome/chrome_desktop_impl.cc

@@ -63,13 +63,11 @@ bool KillProcess(base::ProcessHandle process_id) {
 ChromeDesktopImpl::ChromeDesktopImpl(
     scoped_ptr<DevToolsHttpClient> client,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-    Log* log,
     base::ProcessHandle process,
     base::ScopedTempDir* user_data_dir,
     base::ScopedTempDir* extension_dir)
     : ChromeImpl(client.Pass(),
-                 devtools_event_listeners,
-                 log),
+                 devtools_event_listeners),
       process_(process),
       quit_(false) {
   if (user_data_dir->IsValid())
@@ -113,7 +111,7 @@ Status ChromeDesktopImpl::WaitForPageToLoad(const std::string& url,
     return Status(kUnknownError, "page could not be found: " + url);
 
   scoped_ptr<WebView> web_view_tmp(new WebViewImpl(
-      id, GetBuildNo(), devtools_http_client_->CreateClient(id), log_));
+      id, GetBuildNo(), devtools_http_client_->CreateClient(id)));
   Status status = web_view_tmp->ConnectIfNecessary();
   if (status.IsError())
     return status;

chrome/test/chromedriver/chrome/chrome_desktop_impl.h

@@ -27,7 +27,6 @@ class ChromeDesktopImpl : public ChromeImpl {
   ChromeDesktopImpl(
       scoped_ptr<DevToolsHttpClient> client,
       ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-      Log* log,
       base::ProcessHandle process,
       base::ScopedTempDir* user_data_dir,
       base::ScopedTempDir* extension_dir);

chrome/test/chromedriver/chrome/chrome_existing_impl.cc

@@ -8,9 +8,8 @@
 
 ChromeExistingImpl::ChromeExistingImpl(
     scoped_ptr<DevToolsHttpClient> client,
-    ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-    Log* log)
-    : ChromeImpl(client.Pass(), devtools_event_listeners, log) {}
+    ScopedVector<DevToolsEventListener>& devtools_event_listeners)
+    : ChromeImpl(client.Pass(), devtools_event_listeners) {}
 
 ChromeExistingImpl::~ChromeExistingImpl() {}
 

chrome/test/chromedriver/chrome/chrome_existing_impl.h

@@ -17,8 +17,7 @@ class ChromeExistingImpl : public ChromeImpl {
  public:
   ChromeExistingImpl(
       scoped_ptr<DevToolsHttpClient> client,
-      ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-      Log* log);
+      ScopedVector<DevToolsEventListener>& devtools_event_listeners);
   virtual ~ChromeExistingImpl();
 
   // Overridden from Chrome.

chrome/test/chromedriver/chrome/chrome_impl.cc

@@ -7,7 +7,6 @@
 #include "chrome/test/chromedriver/chrome/devtools_client.h"
 #include "chrome/test/chromedriver/chrome/devtools_event_listener.h"
 #include "chrome/test/chromedriver/chrome/devtools_http_client.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/web_view_impl.h"
 
@@ -61,7 +60,7 @@ Status ChromeImpl::GetWebViewIds(std::list<std::string>* web_view_ids) {
         // OnConnected will fire when DevToolsClient connects later.
       }
       web_views_.push_back(make_linked_ptr(new WebViewImpl(
-          view.id, GetBuildNo(), client.Pass(), log_)));
+          view.id, GetBuildNo(), client.Pass())));
     }
   }
 
@@ -109,9 +108,7 @@ Status ChromeImpl::GetAutomationExtension(AutomationExtension** extension) {
 
 ChromeImpl::ChromeImpl(
     scoped_ptr<DevToolsHttpClient> client,
-    ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-    Log* log)
-    : devtools_http_client_(client.Pass()),
-      log_(log) {
+    ScopedVector<DevToolsEventListener>& devtools_event_listeners)
+    : devtools_http_client_(client.Pass()) {
   devtools_event_listeners_.swap(devtools_event_listeners);
 }

chrome/test/chromedriver/chrome/chrome_impl.h

@@ -18,7 +18,6 @@ class AutomationExtension;
 class DevToolsEventListener;
 class DevToolsHttpClient;
 class JavaScriptDialogManager;
-class Log;
 class Status;
 class WebView;
 class WebViewImpl;
@@ -41,11 +40,9 @@ class ChromeImpl : public Chrome {
  protected:
   ChromeImpl(
       scoped_ptr<DevToolsHttpClient> client,
-      ScopedVector<DevToolsEventListener>& devtools_event_listeners,
-      Log* log);
+      ScopedVector<DevToolsEventListener>& devtools_event_listeners);
 
   scoped_ptr<DevToolsHttpClient> devtools_http_client_;
-  Log* log_;
 
  private:
   typedef std::list<linked_ptr<WebViewImpl> > WebViewList;

chrome/test/chromedriver/chrome/console_logger.cc

@@ -53,7 +53,7 @@ Status ConsoleLogger::OnEvent(
   if (params.GetDictionary("message", &message_dict)) {
     std::string text;
     std::string level_name;
-    Log::Level level = Log::kLog;
+    Log::Level level = Log::kInfo;
     if (message_dict->GetString("text", &text) && !text.empty() &&
         message_dict->GetString("level", &level_name) &&
         ConsoleLevelToLogLevel(level_name, &level)) {

chrome/test/chromedriver/chrome/console_logger_unittest.cc

@@ -173,7 +173,7 @@ TEST(ConsoleLogger, ConsoleMessages) {
 
   ASSERT_EQ(8u, log.GetEntries().size());
   ValidateLogEntry(log.GetEntries()[0], Log::kDebug, "url1 10:1 text1");
-  ValidateLogEntry(log.GetEntries()[1], Log::kLog, "source2 - text2");
+  ValidateLogEntry(log.GetEntries()[1], Log::kInfo, "source2 - text2");
   ValidateLogEntry(log.GetEntries()[2], Log::kWarning, "url3 30 text3");
   ValidateLogEntry(log.GetEntries()[3], Log::kError, "url4 - text4");
   ValidateLogEntry(

chrome/test/chromedriver/chrome/devtools_client_impl.cc

@@ -13,6 +13,7 @@
 #include "chrome/test/chromedriver/chrome/devtools_event_listener.h"
 #include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
+#include "chrome/test/chromedriver/chrome/util.h"
 #include "chrome/test/chromedriver/net/sync_websocket.h"
 #include "chrome/test/chromedriver/net/url_request_context_getter.h"
 
@@ -70,13 +71,11 @@ DevToolsClientImpl::DevToolsClientImpl(
     const SyncWebSocketFactory& factory,
     const std::string& url,
     const std::string& id,
-    const FrontendCloserFunc& frontend_closer_func,
-    Log* log)
+    const FrontendCloserFunc& frontend_closer_func)
     : socket_(factory.Run().Pass()),
       url_(url),
       id_(id),
       frontend_closer_func_(frontend_closer_func),
-      log_(log),
       parser_func_(base::Bind(&internal::ParseInspectorMessage)),
       unnotified_event_(NULL),
       next_id_(1),
@@ -87,13 +86,11 @@ DevToolsClientImpl::DevToolsClientImpl(
     const std::string& url,
     const std::string& id,
     const FrontendCloserFunc& frontend_closer_func,
-    Log* log,
     const ParserFunc& parser_func)
     : socket_(factory.Run().Pass()),
       url_(url),
       id_(id),
       frontend_closer_func_(frontend_closer_func),
-      log_(log),
       parser_func_(parser_func),
       unnotified_event_(NULL),
       next_id_(1),
@@ -207,9 +204,11 @@ Status DevToolsClientImpl::SendCommandInternal(
   command.SetInteger("id", command_id);
   command.SetString("method", method);
   command.Set("params", params.DeepCopy());
-  std::string message;
-  base::JSONWriter::Write(&command, &message);
-  log_->AddEntry(Log::kDebug, "sending Inspector command " + message);
+  std::string message = SerializeValue(&command);
+  if (IsVLogOn(1)) {
+    VLOG(1) << "COMMAND " << method << " (id=" << command_id << ") "
+            << FormatValueForDisplay(params);
+  }
   if (!socket_->Send(message))
     return Status(kDisconnected, "unable to send message to renderer");
 
@@ -260,16 +259,19 @@ Status DevToolsClientImpl::ProcessNextMessage(
   std::string message;
   switch (socket_->ReceiveNextMessage(&message, timeout)) {
     case SyncWebSocket::kOk:
-      log_->AddEntry(Log::kDebug, "received Inspector response " + message);
       break;
-    case SyncWebSocket::kDisconnected:
-      message = "unable to receive message from renderer";
-      log_->AddEntry(Log::kDebug, message);
-      return Status(kDisconnected, message);
-    case SyncWebSocket::kTimeout:
-      message = "timed out receiving message from renderer";
-      log_->AddEntry(Log::kDebug, message);
-      return Status(kTimeout, message);
+    case SyncWebSocket::kDisconnected: {
+      std::string err = "Unable to receive message from renderer";
+      LOG(ERROR) << err;
+      return Status(kDisconnected, err);
+    }
+    case SyncWebSocket::kTimeout: {
+      std::string err =
+          "Timed out receiving message from renderer: " +
+          base::StringPrintf("%.3lf", timeout.InSecondsF());
+      LOG(ERROR) << err;
+      return Status(kTimeout, err);
+    }
     default:
       NOTREACHED();
       break;
@@ -278,8 +280,10 @@ Status DevToolsClientImpl::ProcessNextMessage(
   internal::InspectorMessageType type;
   internal::InspectorEvent event;
   internal::InspectorCommandResponse response;
-  if (!parser_func_.Run(message, expected_id, &type, &event, &response))
+  if (!parser_func_.Run(message, expected_id, &type, &event, &response)) {
+    LOG(ERROR) << "Bad inspector message: " << message;
     return Status(kUnknownError, "bad inspector message: " + message);
+  }
 
   if (type == internal::kEventMessageType)
     return ProcessEvent(event);
@@ -288,6 +292,10 @@ Status DevToolsClientImpl::ProcessNextMessage(
 }
 
 Status DevToolsClientImpl::ProcessEvent(const internal::InspectorEvent& event) {
+  if (IsVLogOn(1)) {
+    VLOG(1) << "EVENT " << event.method << " "
+            << FormatValueForDisplay(*event.params);
+  }
   unnotified_event_listeners_ = listeners_;
   unnotified_event_ = &event;
   Status status = EnsureListenersNotifiedOfEvent();
@@ -327,7 +335,20 @@ Status DevToolsClientImpl::ProcessEvent(const internal::InspectorEvent& event) {
 
 Status DevToolsClientImpl::ProcessCommandResponse(
     const internal::InspectorCommandResponse& response) {
-  if (response_info_map_.count(response.id) == 0)
+  ResponseInfoMap::iterator iter = response_info_map_.find(response.id);
+  if (IsVLogOn(1)) {
+    std::string method, result;
+    if (iter != response_info_map_.end())
+      method = iter->second->method;
+    if (response.result)
+      result = FormatValueForDisplay(*response.result);
+    else
+      result = response.error;
+    VLOG(1) << "RESPONSE " << method << " (id=" << response.id
+            << ") " << result;
+  }
+
+  if (iter == response_info_map_.end())
     return Status(kUnknownError, "unexpected command response");
 
   linked_ptr<ResponseInfo> response_info = response_info_map_[response.id];

chrome/test/chromedriver/chrome/devtools_client_impl.h

@@ -47,7 +47,6 @@ struct InspectorCommandResponse {
 }  // namespace internal
 
 class DevToolsEventListener;
-class Log;
 class Status;
 class SyncWebSocket;
 
@@ -57,8 +56,7 @@ class DevToolsClientImpl : public DevToolsClient {
   DevToolsClientImpl(const SyncWebSocketFactory& factory,
                      const std::string& url,
                      const std::string& id,
-                     const FrontendCloserFunc& frontend_closer_func,
-                     Log* log);
+                     const FrontendCloserFunc& frontend_closer_func);
 
   typedef base::Callback<bool(
       const std::string&,
@@ -70,7 +68,6 @@ class DevToolsClientImpl : public DevToolsClient {
                      const std::string& url,
                      const std::string& id,
                      const FrontendCloserFunc& frontend_closer_func,
-                     Log* log,
                      const ParserFunc& parser_func);
 
   virtual ~DevToolsClientImpl();
@@ -130,7 +127,6 @@ class DevToolsClientImpl : public DevToolsClient {
   GURL url_;
   const std::string id_;
   FrontendCloserFunc frontend_closer_func_;
-  Log* log_;
   ParserFunc parser_func_;
   std::list<DevToolsEventListener*> listeners_;
   std::list<DevToolsEventListener*> unnotified_connect_listeners_;

chrome/test/chromedriver/chrome/devtools_http_client.cc

@@ -67,11 +67,9 @@ const WebViewInfo* WebViewsInfo::GetForId(const std::string& id) const {
 DevToolsHttpClient::DevToolsHttpClient(
     const NetAddress& address,
     scoped_refptr<URLRequestContextGetter> context_getter,
-    const SyncWebSocketFactory& socket_factory,
-    Log* log)
+    const SyncWebSocketFactory& socket_factory)
     : context_getter_(context_getter),
       socket_factory_(socket_factory),
-      log_(log),
       server_url_("http://" + address.ToString()),
       web_socket_url_prefix_(base::StringPrintf(
           "ws://%s/devtools/page/", address.ToString().c_str())) {}
@@ -141,8 +139,7 @@ scoped_ptr<DevToolsClient> DevToolsHttpClient::CreateClient(
       web_socket_url_prefix_ + id,
       id,
       base::Bind(
-          &DevToolsHttpClient::CloseFrontends, base::Unretained(this), id),
-      log_));
+          &DevToolsHttpClient::CloseFrontends, base::Unretained(this), id)));
 }
 
 Status DevToolsHttpClient::CloseWebView(const std::string& id) {
@@ -234,10 +231,9 @@ Status DevToolsHttpClient::CloseFrontends(const std::string& for_client_id) {
         socket_factory_,
         web_socket_url_prefix_ + *it,
         *it,
-        base::Bind(&FakeCloseFrontends),
-        log_));
+        base::Bind(&FakeCloseFrontends)));
     scoped_ptr<WebViewImpl> web_view(
-        new WebViewImpl(*it, build_no_, client.Pass(), log_));
+        new WebViewImpl(*it, build_no_, client.Pass()));
 
     status = web_view->ConnectIfNecessary();
     // Ignore disconnected error, because the debugger might have closed when
@@ -279,12 +275,13 @@ Status DevToolsHttpClient::CloseFrontends(const std::string& for_client_id) {
 bool DevToolsHttpClient::FetchUrlAndLog(const std::string& url,
                                         URLRequestContextGetter* getter,
                                         std::string* response) {
-  log_->AddEntry(Log::kDebug, "devtools request: " + url);
+  VLOG(1) << "DevTools request: " << url;
   bool ok = FetchUrl(url, getter, response);
-  if (ok)
-    log_->AddEntry(Log::kDebug, "devtools response: " + *response);
-  else
-    log_->AddEntry(Log::kDebug, "devtools request failed");
+  if (ok) {
+    VLOG(1) << "DevTools response: " << *response;
+  } else {
+    VLOG(1) << "DevTools request failed";
+  }
   return ok;
 }
 

chrome/test/chromedriver/chrome/devtools_http_client.h

@@ -17,7 +17,6 @@ class TimeDelta;
 }
 
 class DevToolsClient;
-class Log;
 class NetAddress;
 class Status;
 class URLRequestContextGetter;
@@ -61,8 +60,7 @@ class DevToolsHttpClient {
   DevToolsHttpClient(
       const NetAddress& address,
       scoped_refptr<URLRequestContextGetter> context_getter,
-      const SyncWebSocketFactory& socket_factory,
-      Log* log);
+      const SyncWebSocketFactory& socket_factory);
   ~DevToolsHttpClient();
 
   Status Init(const base::TimeDelta& timeout);
@@ -87,7 +85,6 @@ class DevToolsHttpClient {
 
   scoped_refptr<URLRequestContextGetter> context_getter_;
   SyncWebSocketFactory socket_factory_;
-  Log* log_;
   std::string server_url_;
   std::string web_socket_url_prefix_;
   std::string version_;

chrome/test/chromedriver/chrome/log.cc

@@ -4,18 +4,19 @@
 
 #include "chrome/test/chromedriver/chrome/log.h"
 
-#include <stdio.h>
-
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_util.h"
-#include "base/strings/stringprintf.h"
 #include "base/values.h"
 
+void Log::AddEntry(Level level, const std::string& message) {
+  AddEntryTimestamped(base::Time::Now(), level, message);
+}
+
 namespace {
 
-// Truncates the given string to 200 characters, adding an ellipsis if
-// truncation was necessary.
+IsVLogOnFunc g_is_vlog_on_func = NULL;
+
 void TruncateString(std::string* data) {
   const size_t kMaxLength = 200;
   if (data->length() > kMaxLength) {
@@ -24,8 +25,7 @@ void TruncateString(std::string* data) {
   }
 }
 
-// Truncates all strings contained in the given value.
-void TruncateContainedStrings(base::Value* value) {
+base::Value* TruncateContainedStrings(base::Value* value) {
   base::ListValue* list = NULL;
   base::DictionaryValue* dict = NULL;
   if (value->GetAsDictionary(&dict)) {
@@ -55,80 +55,45 @@ void TruncateContainedStrings(base::Value* value) {
       }
     }
   }
+  return value;
 }
 
-std::string ConvertForDisplayInternal(const std::string& input) {
-  size_t left = input.find("{");
-  size_t right = input.rfind("}");
-  if (left == std::string::npos || right == std::string::npos)
-    return input.substr(0, 10 << 10);
+}  // namespace
 
-  scoped_ptr<base::Value> value(
-      base::JSONReader::Read(input.substr(left, right - left + 1)));
-  if (!value)
-    return input.substr(0, 10 << 10);
-  TruncateContainedStrings(value.get());
-  std::string json;
-  base::JSONWriter::WriteWithOptions(
-      value.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
-  std::string display = input.substr(0, left) + json;
-  if (input.length() > right)
-    display += input.substr(right + 1);
-  return display;
+void InitLogging(IsVLogOnFunc is_vlog_on_func) {
+  g_is_vlog_on_func = is_vlog_on_func;
 }
 
-// Pretty prints encapsulated JSON and truncates long strings for display.
-std::string ConvertForDisplay(const std::string& input) {
-  std::string display = ConvertForDisplayInternal(input);
-  char remove_chars[] = {'\r', '\0'};
-  RemoveChars(display, remove_chars, &display);
-  return display;
+bool IsVLogOn(int vlog_level) {
+  if (!g_is_vlog_on_func)
+    return false;
+  return g_is_vlog_on_func(vlog_level);
 }
 
-}  // namespace
-
-void Log::AddEntry(Level level, const std::string& message) {
- AddEntryTimestamped(base::Time::Now(), level, message);
+std::string PrettyPrintValue(const base::Value& value) {
+  std::string json;
+  base::JSONWriter::WriteWithOptions(
+      &value, base::JSONWriter::OPTIONS_PRETTY_PRINT, &json);
+#if defined(OS_WIN)
+  RemoveChars(json, "\r", &json);
+#endif
+  // Remove the trailing newline.
+  if (json.length())
+    json.resize(json.length() - 1);
+  return json;
 }
 
-Logger::Logger() : min_log_level_(kLog), start_(base::Time::Now()) {}
-
-Logger::Logger(Level min_log_level)
-    : min_log_level_(min_log_level), start_(base::Time::Now()) {}
-
-Logger::~Logger() {}
-
-void Logger::AddEntryTimestamped(const base::Time& timestamp,
-                                 Level level,
-                                 const std::string& message) {
-  if (level < min_log_level_)
-    return;
+std::string FormatValueForDisplay(const base::Value& value) {
+  scoped_ptr<base::Value> truncated(TruncateContainedStrings(value.DeepCopy()));
+  return PrettyPrintValue(*truncated);
+}
 
-  const char* level_name = "UNKNOWN";
-  switch (level) {
-    case kDebug:
-      level_name = "DEBUG";
-      break;
-    case kLog:
-      level_name = "INFO";
-      break;
-    case kWarning:
-      level_name = "WARNING";
-      break;
-    case kError:
-      level_name = "ERROR";
-      break;
-    default:
-      break;
+std::string FormatJsonForDisplay(const std::string& json) {
+  scoped_ptr<base::Value> value(base::JSONReader::Read(json));
+  if (!value) {
+    std::string truncated = json;
+    TruncateString(&truncated);
+    return truncated;
   }
-  std::string entry =
-      base::StringPrintf("[%.3lf][%s]: %s",
-                         base::TimeDelta(timestamp - start_).InSecondsF(),
-                         level_name,
-                         ConvertForDisplay(message).c_str());
-  const char* format = "%s\n";
-  if (entry[entry.length() - 1] == '\n')
-    format = "%s";
-  fprintf(stderr, format, entry.c_str());
-  fflush(stderr);
+  return PrettyPrintValue(*TruncateContainedStrings(value.get()));
 }

chrome/test/chromedriver/chrome/log.h

@@ -10,15 +10,21 @@
 #include "base/compiler_specific.h"
 #include "base/time/time.h"
 
+namespace base {
+class Value;
+}
+
 // Abstract class for logging entries with a level, timestamp, string message.
 class Log {
  public:
   // Log entry severity level.
   enum Level {
+    kAll,
     kDebug,
-    kLog,
+    kInfo,
     kWarning,
-    kError
+    kError,
+    kOff
   };
 
   virtual ~Log() {}
@@ -32,21 +38,18 @@ class Log {
   void AddEntry(Level level, const std::string& message);
 };
 
-// Writes log entries using printf.
-class Logger : public Log {
- public:
-  // Creates a logger with a minimum level of |kDebug|.
-  Logger();
-  explicit Logger(Level min_log_level);
-  virtual ~Logger();
+typedef bool (*IsVLogOnFunc)(int vlog_level);
+void InitLogging(IsVLogOnFunc is_vlog_on_func);
 
-  virtual void AddEntryTimestamped(const base::Time& timestamp,
-                                   Level level,
-                                   const std::string& message) OVERRIDE;
+// Returns whether the given VLOG level is on.
+bool IsVLogOn(int vlog_level);
 
- private:
-  Level min_log_level_;
-  base::Time start_;
-};
+std::string PrettyPrintValue(const base::Value& value);
+
+// Returns a pretty printed value, after truncating long strings.
+std::string FormatValueForDisplay(const base::Value& value);
+
+// Returns a pretty printed json string, after truncating long strings.
+std::string FormatJsonForDisplay(const std::string& json);
 
 #endif  // CHROME_TEST_CHROMEDRIVER_CHROME_LOG_H_

chrome/test/chromedriver/chrome/performance_logger.cc

@@ -60,6 +60,6 @@ Status PerformanceLogger::OnEvent(
   // Look at where it is for Page, Network, Timeline events.
   base::JSONWriter::Write(&log_message_dict, &log_message_json);
 
-  log_->AddEntry(Log::kLog, log_message_json);
+  log_->AddEntry(Log::kInfo, log_message_json);
   return Status(kOk);
 }

chrome/test/chromedriver/chrome/performance_logger_unittest.cc

@@ -117,7 +117,7 @@ scoped_ptr<DictionaryValue> ParseDictionary(const std::string& json) {
 void ValidateLogEntry(const LogEntry *entry,
                       const std::string& expected_webview,
                       const std::string& expected_method) {
-  EXPECT_EQ(Log::kLog, entry->level);
+  EXPECT_EQ(Log::kInfo, entry->level);
   EXPECT_LT(0, entry->timestamp.ToTimeT());
 
   scoped_ptr<base::DictionaryValue> message(ParseDictionary(entry->message));

chrome/test/chromedriver/chrome/util.cc

+// Copyright (c) 2013 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/chromedriver/chrome/util.h"
+
+#include "base/json/json_writer.h"
+#include "base/values.h"
+
+std::string SerializeValue(const base::Value* value) {
+  std::string json;
+  base::JSONWriter::Write(value, &json);
+  return json;
+}

chrome/test/chromedriver/chrome/util.h

+// Copyright (c) 2013 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.
+
+#ifndef CHROME_TEST_CHROMEDRIVER_CHROME_UTIL_H_
+#define CHROME_TEST_CHROMEDRIVER_CHROME_UTIL_H_
+
+#include <string>
+
+namespace base {
+class Value;
+}
+
+std::string SerializeValue(const base::Value* value);
+
+#endif  // CHROME_TEST_CHROMEDRIVER_CHROME_UTIL_H_

chrome/test/chromedriver/chrome/web_view_impl.cc

@@ -19,7 +19,6 @@
 #include "chrome/test/chromedriver/chrome/geolocation_override_manager.h"
 #include "chrome/test/chromedriver/chrome/javascript_dialog_manager.h"
 #include "chrome/test/chromedriver/chrome/js.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/navigation_tracker.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/ui_events.h"
@@ -112,8 +111,7 @@ const char* GetAsString(KeyEventType type) {
 
 WebViewImpl::WebViewImpl(const std::string& id,
                          int build_no,
-                         scoped_ptr<DevToolsClient> client,
-                         Log* log)
+                         scoped_ptr<DevToolsClient> client)
     : id_(id),
       build_no_(build_no),
       dom_tracker_(new DomTracker(client.get())),
@@ -122,8 +120,7 @@ WebViewImpl::WebViewImpl(const std::string& id,
       dialog_manager_(new JavaScriptDialogManager(client.get())),
       geolocation_override_manager_(
           new GeolocationOverrideManager(client.get())),
-      client_(client.release()),
-      log_(log) {}
+      client_(client.release()) {}
 
 WebViewImpl::~WebViewImpl() {}
 
@@ -322,14 +319,14 @@ Status WebViewImpl::DeleteCookie(const std::string& name,
 Status WebViewImpl::WaitForPendingNavigations(const std::string& frame_id,
                                               const base::TimeDelta& timeout,
                                               bool stop_load_on_timeout) {
-  log_->AddEntry(Log::kLog, "waiting for pending navigations...");
+  VLOG(0) << "Waiting for pending navigations...";
   Status status = client_->HandleEventsUntil(
       base::Bind(&WebViewImpl::IsNotPendingNavigation,
                  base::Unretained(this),
                  frame_id),
       timeout);
   if (status.code() == kTimeout && stop_load_on_timeout) {
-    log_->AddEntry(Log::kLog, "timed out. stopping navigations...");
+    VLOG(0) << "Timed out. Stopping navigation...";
     scoped_ptr<base::Value> unused_value;
     EvaluateScript(std::string(), "window.stop();", &unused_value);
     Status new_status = client_->HandleEventsUntil(
@@ -339,7 +336,7 @@ Status WebViewImpl::WaitForPendingNavigations(const std::string& frame_id,
     if (new_status.IsError())
       status = new_status;
   }
-  log_->AddEntry(Log::kLog, "done waiting for pending navigations");
+  VLOG(0) << "Done waiting for pending navigations";
   return status;
 }
 

chrome/test/chromedriver/chrome/web_view_impl.h

@@ -24,7 +24,6 @@ class DomTracker;
 class FrameTracker;
 class GeolocationOverrideManager;
 struct KeyEvent;
-class Log;
 struct MouseEvent;
 class NavigationTracker;
 class Status;
@@ -33,8 +32,7 @@ class WebViewImpl : public WebView {
  public:
   WebViewImpl(const std::string& id,
               int build_no,
-              scoped_ptr<DevToolsClient> client,
-              Log* log);
+              scoped_ptr<DevToolsClient> client);
   virtual ~WebViewImpl();
 
   // Overridden from WebView:
@@ -103,7 +101,6 @@ class WebViewImpl : public WebView {
   scoped_ptr<JavaScriptDialogManager> dialog_manager_;
   scoped_ptr<GeolocationOverrideManager> geolocation_override_manager_;
   scoped_ptr<DevToolsClient> client_;
-  Log* log_;
 };
 
 namespace internal {

chrome/test/chromedriver/chrome_launcher.cc

@@ -32,7 +32,6 @@
 #include "chrome/test/chromedriver/chrome/device_manager.h"
 #include "chrome/test/chromedriver/chrome/devtools_http_client.h"
 #include "chrome/test/chromedriver/chrome/embedded_automation_extension.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/user_data_dir.h"
 #include "chrome/test/chromedriver/chrome/version.h"
@@ -147,10 +146,9 @@ Status WaitForDevToolsAndCheckVersion(
     const NetAddress& address,
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     scoped_ptr<DevToolsHttpClient>* user_client) {
   scoped_ptr<DevToolsHttpClient> client(new DevToolsHttpClient(
-      address, context_getter, socket_factory, log));
+      address, context_getter, socket_factory));
   base::TimeTicks deadline =
       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(20);
   Status status = client->Init(deadline - base::TimeTicks::Now());
@@ -178,14 +176,13 @@ Status WaitForDevToolsAndCheckVersion(
 Status LaunchExistingChromeSession(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   Status status(kOk);
   scoped_ptr<DevToolsHttpClient> devtools_client;
   status = WaitForDevToolsAndCheckVersion(
-      capabilities.debugger_address, context_getter, socket_factory, log,
+      capabilities.debugger_address, context_getter, socket_factory,
       &devtools_client);
   if (status.IsError()) {
     return Status(kUnknownError, "cannot connect to chrome at " +
@@ -193,8 +190,7 @@ Status LaunchExistingChromeSession(
                   status);
   }
   chrome->reset(new ChromeExistingImpl(devtools_client.Pass(),
-      devtools_event_listeners,
-      log));
+                                       devtools_event_listeners));
   return Status(kOk);
 }
 
@@ -202,7 +198,6 @@ Status LaunchDesktopChrome(
     URLRequestContextGetter* context_getter,
     int port,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
@@ -233,14 +228,14 @@ Status LaunchDesktopChrome(
 #else
   std::string command_string = command.GetCommandLineString();
 #endif
-  log->AddEntry(Log::kLog, "Launching chrome: " + command_string);
+  VLOG(0) << "Launching chrome: " << command_string;
   base::ProcessHandle process;
   if (!base::LaunchProcess(command, options, &process))
     return Status(kUnknownError, "chrome failed to start");
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   status = WaitForDevToolsAndCheckVersion(
-      NetAddress(port), context_getter, socket_factory, log, &devtools_client);
+      NetAddress(port), context_getter, socket_factory, &devtools_client);
 
   if (status.IsError()) {
     int exit_code;
@@ -279,7 +274,6 @@ Status LaunchDesktopChrome(
   scoped_ptr<ChromeDesktopImpl> chrome_desktop(
       new ChromeDesktopImpl(devtools_client.Pass(),
                             devtools_event_listeners,
-                            log,
                             process,
                             &user_data_dir,
                             &extension_dir));
@@ -302,7 +296,6 @@ Status LaunchAndroidChrome(
     URLRequestContextGetter* context_getter,
     int port,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     DeviceManager* device_manager,
@@ -336,13 +329,12 @@ Status LaunchAndroidChrome(
   status = WaitForDevToolsAndCheckVersion(NetAddress(port),
                                           context_getter,
                                           socket_factory,
-                                          log,
                                           &devtools_client);
   if (status.IsError())
     return status;
 
   chrome->reset(new ChromeAndroidImpl(
-      devtools_client.Pass(), devtools_event_listeners, device.Pass(), log));
+      devtools_client.Pass(), devtools_event_listeners, device.Pass()));
   return Status(kOk);
 }
 
@@ -351,7 +343,6 @@ Status LaunchAndroidChrome(
 Status LaunchChrome(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     DeviceManager* device_manager,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
@@ -359,7 +350,7 @@ Status LaunchChrome(
   if (capabilities.IsExistingBrowser()) {
     return LaunchExistingChromeSession(
         context_getter, socket_factory,
-        log, capabilities, devtools_event_listeners, chrome);
+        capabilities, devtools_event_listeners, chrome);
   }
 
   int port;
@@ -368,11 +359,11 @@ Status LaunchChrome(
 
   if (capabilities.IsAndroid()) {
     return LaunchAndroidChrome(
-        context_getter, port, socket_factory, log, capabilities,
+        context_getter, port, socket_factory, capabilities,
         devtools_event_listeners, device_manager, chrome);
   } else {
     return LaunchDesktopChrome(
-        context_getter, port, socket_factory, log, capabilities,
+        context_getter, port, socket_factory, capabilities,
         devtools_event_listeners, chrome);
   }
 }

chrome/test/chromedriver/chrome_launcher.h

@@ -24,14 +24,12 @@ class FilePath;
 
 class Chrome;
 class DeviceManager;
-class Log;
 class Status;
 class URLRequestContextGetter;
 
 Status LaunchChrome(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     DeviceManager* device_manager,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,

chrome/test/chromedriver/commands.cc

@@ -56,13 +56,11 @@ void ExecuteGetStatus(
 }
 
 NewSessionParams::NewSessionParams(
-    Log* log,
     SessionThreadMap* session_thread_map,
     scoped_refptr<URLRequestContextGetter> context_getter,
     const SyncWebSocketFactory& socket_factory,
     DeviceManager* device_manager)
-    : log(log),
-      session_thread_map(session_thread_map),
+    : session_thread_map(session_thread_map),
       context_getter(context_getter),
       socket_factory(socket_factory),
       device_manager(device_manager) {}
@@ -84,22 +82,24 @@ Status CreateSessionOnSessionThreadHelper(
     return Status(kUnknownError, "cannot find dict 'desiredCapabilities'");
 
   Capabilities capabilities;
-  Status status = capabilities.Parse(*desired_caps, bound_params.log);
+  Status status = capabilities.Parse(*desired_caps);
   if (status.IsError())
     return status;
 
   // Create Log's and DevToolsEventListener's for ones that are DevTools-based.
   // Session will own the Log's, Chrome will own the listeners.
   ScopedVector<WebDriverLog> devtools_logs;
+  // TODO(kkania): Save this log in the session.
+  scoped_ptr<WebDriverLog> driver_log;
   ScopedVector<DevToolsEventListener> devtools_event_listeners;
-  status = CreateLogs(capabilities, &devtools_logs, &devtools_event_listeners);
+  status = CreateLogs(
+      capabilities, &devtools_logs, &driver_log, &devtools_event_listeners);
   if (status.IsError())
     return status;
 
   scoped_ptr<Chrome> chrome;
   status = LaunchChrome(bound_params.context_getter.get(),
                         bound_params.socket_factory,
-                        bound_params.log,
                         bound_params.device_manager,
                         capabilities,
                         devtools_event_listeners,

chrome/test/chromedriver/commands.h

@@ -20,7 +20,6 @@ class Value;
 }
 
 class DeviceManager;
-class Log;
 struct Session;
 class Status;
 class URLRequestContextGetter;
@@ -32,14 +31,12 @@ void ExecuteGetStatus(
     const CommandCallback& callback);
 
 struct NewSessionParams {
-  NewSessionParams(Log* log,
-                   SessionThreadMap* session_thread_map,
+  NewSessionParams(SessionThreadMap* session_thread_map,
                    scoped_refptr<URLRequestContextGetter> context_getter,
                    const SyncWebSocketFactory& socket_factory,
                    DeviceManager* device_manager);
   ~NewSessionParams();
 
-  Log* log;
   SessionThreadMap* session_thread_map;
   scoped_refptr<URLRequestContextGetter> context_getter;
   SyncWebSocketFactory socket_factory;

chrome/test/chromedriver/logging.h

@@ -22,26 +22,13 @@ class Status;
 // See https://code.google.com/p/selenium/wiki/Logging.
 class WebDriverLog : public Log {
  public:
-  // Constants corresponding to log entry severity levels in the wire protocol.
-  enum WebDriverLevel {
-    kWdAll,
-    kWdDebug,
-    kWdInfo,
-    kWdWarning,
-    kWdSevere,
-    kWdOff
-  };
-
-  // Converts WD wire protocol level name -> WebDriverLevel, false on bad name.
-  static bool NameToLevel(const std::string& name, WebDriverLevel* out_level);
+  // Converts WD wire protocol level name -> Level, false on bad name.
+  static bool NameToLevel(const std::string& name, Level* out_level);
 
   // Creates a WebDriverLog with the given type and minimum level.
-  WebDriverLog(const std::string& type, WebDriverLevel min_wd_level);
+  WebDriverLog(const std::string& type, Level min_level);
   virtual ~WebDriverLog();
 
-  // Returns this log's type, for the WD wire protocol "/log" and "/log/types".
-  const std::string& GetType();
-
   // Returns entries accumulated so far, as a ListValue ready for serialization
   // into the wire protocol response to the "/log" command.
   // The caller assumes ownership of the ListValue, and the WebDriverLog
@@ -53,17 +40,24 @@ class WebDriverLog : public Log {
                                    Level level,
                                    const std::string& message) OVERRIDE;
 
+  const std::string& type() const;
+  Level min_level() const;
+
  private:
   const std::string type_;  // WebDriver log type.
-  const WebDriverLevel min_wd_level_;  // Minimum level of entries to store.
+  const Level min_level_;  // Minimum level of entries to store.
   scoped_ptr<base::ListValue> entries_;  // Accumulated entries.
 
   DISALLOW_COPY_AND_ASSIGN(WebDriverLog);
 };
 
-// Creates Log's and DevToolsEventListener's for ones that are DevTools-based.
+// Initializes logging system for ChromeDriver. Returns true on success.
+bool InitLogging();
+
+// Creates Log's and DevToolsEventListener's based on logging preferences.
 Status CreateLogs(const Capabilities& capabilities,
-                  ScopedVector<WebDriverLog>* out_devtools_logs,
+                  ScopedVector<WebDriverLog>* out_logs,
+                  scoped_ptr<WebDriverLog>* out_driver_log,
                   ScopedVector<DevToolsEventListener>* out_listeners);
 
 #endif  // CHROME_TEST_CHROMEDRIVER_LOGGING_H_

chrome/test/chromedriver/logging_unittest.cc

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/test/chromedriver/logging.h"
-
 #include "base/values.h"
 #include "chrome/test/chromedriver/capabilities.h"
 #include "chrome/test/chromedriver/chrome/devtools_event_listener.h"
+#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
+#include "chrome/test/chromedriver/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ -21,17 +21,15 @@ const char* const kAllWdLevels[] = {
 TEST(Logging, NameLevelConversionHappy) {
   // All names map to a valid enum value.
   for (int i = 0; static_cast<size_t>(i) < arraysize(kAllWdLevels); ++i) {
-    WebDriverLog::WebDriverLevel level =
-        static_cast<WebDriverLog::WebDriverLevel>(-1);
+    Log::Level level = static_cast<Log::Level>(-1);
     EXPECT_TRUE(WebDriverLog::NameToLevel(kAllWdLevels[i], &level));
-    EXPECT_LE(WebDriverLog::kWdAll, level);
-    EXPECT_GE(WebDriverLog::kWdOff, level);
+    EXPECT_LE(Log::kAll, level);
+    EXPECT_GE(Log::kOff, level);
   }
 }
 
 TEST(Logging, NameToLevelErrors) {
-  WebDriverLog::WebDriverLevel level =
-      static_cast<WebDriverLog::WebDriverLevel>(-1);
+  Log::Level level = static_cast<Log::Level>(-1);
   EXPECT_FALSE(WebDriverLog::NameToLevel("A", &level));
   EXPECT_FALSE(WebDriverLog::NameToLevel("B", &level));
   EXPECT_FALSE(WebDriverLog::NameToLevel("H", &level));
@@ -39,7 +37,7 @@ TEST(Logging, NameToLevelErrors) {
   EXPECT_FALSE(WebDriverLog::NameToLevel("T", &level));
   EXPECT_FALSE(WebDriverLog::NameToLevel("Z", &level));
   // The level variable was never modified.
-  EXPECT_EQ(static_cast<WebDriverLog::WebDriverLevel>(-1), level);
+  EXPECT_EQ(static_cast<Log::Level>(-1), level);
 }
 
 namespace {
@@ -61,11 +59,11 @@ void ValidateLogEntry(base::ListValue *entries,
   EXPECT_LT(0, timestamp);
 }
 
-}
+}  // namespace
 
 TEST(WebDriverLog, Levels) {
-  WebDriverLog log("type", WebDriverLog::kWdInfo);
-  log.AddEntry(Log::kLog, std::string("info message"));
+  WebDriverLog log("type", Log::kInfo);
+  log.AddEntry(Log::kInfo, std::string("info message"));
   log.AddEntry(Log::kError, "severe message");
   log.AddEntry(Log::kDebug, "debug message");  // Must not log
 
@@ -77,7 +75,7 @@ TEST(WebDriverLog, Levels) {
 }
 
 TEST(WebDriverLog, Off) {
-  WebDriverLog log("type", WebDriverLog::kWdOff);
+  WebDriverLog log("type", Log::kOff);
   log.AddEntry(Log::kError, "severe message");  // Must not log
   log.AddEntry(Log::kDebug, "debug message");  // Must not log
 
@@ -87,7 +85,7 @@ TEST(WebDriverLog, Off) {
 }
 
 TEST(WebDriverLog, All) {
-  WebDriverLog log("type", WebDriverLog::kWdAll);
+  WebDriverLog log("type", Log::kAll);
   log.AddEntry(Log::kError, "severe message");
   log.AddEntry(Log::kDebug, "debug message");
 
@@ -100,67 +98,45 @@ TEST(WebDriverLog, All) {
 
 TEST(Logging, CreatePerformanceLog) {
   Capabilities capabilities;
-  capabilities.logging_prefs.reset(new base::DictionaryValue());
-  capabilities.logging_prefs->SetString("performance", "INFO");
+  capabilities.logging_prefs["performance"] = Log::kInfo;
+  capabilities.logging_prefs["browser"] = Log::kInfo;
 
   ScopedVector<DevToolsEventListener> listeners;
   ScopedVector<WebDriverLog> logs;
-  Status status = CreateLogs(capabilities, &logs, &listeners);
+  scoped_ptr<WebDriverLog> driver_log;
+  Status status = CreateLogs(capabilities, &logs, &driver_log, &listeners);
   ASSERT_TRUE(status.IsOk());
   ASSERT_EQ(2u, logs.size());
   ASSERT_EQ(2u, listeners.size());
-  ASSERT_EQ("performance", logs[0]->GetType());
-  ASSERT_EQ("browser", logs[1]->GetType());  // Always created.
-}
-
-TEST(Logging, CreateBrowserLogOff) {
-  Capabilities capabilities;
-  capabilities.logging_prefs.reset(new base::DictionaryValue());
-  capabilities.logging_prefs->SetString("browser", "OFF");
-
-  ScopedVector<DevToolsEventListener> listeners;
-  ScopedVector<WebDriverLog> logs;
-  Status status = CreateLogs(capabilities, &logs, &listeners);
-  ASSERT_TRUE(status.IsOk());
-  ASSERT_EQ(1u, logs.size());
-  ASSERT_EQ(0u, listeners.size());
-  ASSERT_EQ("browser", logs[0]->GetType());
-
-  // Verify the created log is "OFF" -- drops all messages.
-  logs[0]->AddEntry(Log::kError, "drop even errors");
-  scoped_ptr<base::ListValue> entries(logs[0]->GetAndClearEntries());
-  ASSERT_EQ(0u, entries->GetSize());
+  ASSERT_EQ("performance", logs[0]->type());
+  ASSERT_EQ("browser", logs[1]->type());
+  ASSERT_EQ("driver", driver_log->type());
 }
 
 TEST(Logging, IgnoreUnknownLogType) {
   Capabilities capabilities;
-  capabilities.logging_prefs.reset(new base::DictionaryValue());
-  capabilities.logging_prefs->SetString("gaga", "INFO");
+  capabilities.logging_prefs["gaga"] = Log::kInfo;
 
   ScopedVector<DevToolsEventListener> listeners;
   ScopedVector<WebDriverLog> logs;
-  Status status = CreateLogs(capabilities, &logs, &listeners);
+  scoped_ptr<WebDriverLog> driver_log;
+  Status status = CreateLogs(capabilities, &logs, &driver_log, &listeners);
   EXPECT_TRUE(status.IsOk());
   ASSERT_EQ(1u, logs.size());
-  ASSERT_EQ(1u, listeners.size());
-  ASSERT_EQ("browser", logs[0]->GetType());
+  ASSERT_EQ(0u, listeners.size());
+  ASSERT_EQ("browser", logs[0]->type());
 }
 
-TEST(Logging, BrowserLogCreatedWithoutLoggingPrefs) {
+TEST(Logging, DefaultLogs) {
   Capabilities capabilities;
 
   ScopedVector<DevToolsEventListener> listeners;
   ScopedVector<WebDriverLog> logs;
-  Status status = CreateLogs(capabilities, &logs, &listeners);
+  scoped_ptr<WebDriverLog> driver_log;
+  Status status = CreateLogs(capabilities, &logs, &driver_log, &listeners);
   EXPECT_TRUE(status.IsOk());
   ASSERT_EQ(1u, logs.size());
-  ASSERT_EQ(1u, listeners.size());
-  ASSERT_EQ("browser", logs[0]->GetType());
-
-  // Verify the created "browser" log is "INFO" level.
-  logs[0]->AddEntry(Log::kLog, "info message");
-  logs[0]->AddEntry(Log::kDebug, "drop debug message");
-  scoped_ptr<base::ListValue> entries(logs[0]->GetAndClearEntries());
-  ASSERT_EQ(1u, entries->GetSize());
-  ValidateLogEntry(entries.get(), 0, "INFO", "info message");
+  ASSERT_EQ(0u, listeners.size());
+  ASSERT_EQ("driver", driver_log->type());
+  ASSERT_EQ(Log::kWarning, driver_log->min_level());
 }

chrome/test/chromedriver/server/chromedriver_server.cc

@@ -22,8 +22,8 @@
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/version.h"
+#include "chrome/test/chromedriver/logging.h"
 #include "chrome/test/chromedriver/server/http_handler.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
@@ -32,11 +32,6 @@
 #include "net/server/http_server_response_info.h"
 #include "net/socket/tcp_listen_socket.h"
 
-#if defined(OS_POSIX)
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-
 namespace {
 
 typedef base::Callback<
@@ -139,18 +134,15 @@ void StartServerOnIOThread(int port,
   lazy_tls_server.Pointer()->Set(temp_server.release());
 }
 
-void RunServer(Log::Level log_level, int port, const std::string& url_base,
-               int adb_port) {
+void RunServer(int port, const std::string& url_base, int adb_port) {
   base::Thread io_thread("ChromeDriver IO");
   CHECK(io_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   base::MessageLoop cmd_loop;
   base::RunLoop cmd_run_loop;
-  Logger log(log_level);
   HttpHandler handler(cmd_run_loop.QuitClosure(),
                       io_thread.message_loop_proxy(),
-                      &log,
                       url_base,
                       adb_port);
   HttpRequestHandlerFunc handle_request_func =
@@ -185,8 +177,6 @@ int main(int argc, char *argv[]) {
   int port = 9515;
   int adb_port = 5037;
   std::string url_base;
-  base::FilePath log_path;
-  Log::Level log_level = Log::kError;
   if (cmd_line->HasSwitch("h") || cmd_line->HasSwitch("help")) {
     std::string options;
     const char* kOptionAndDescriptions[] = {
@@ -225,47 +215,17 @@ int main(int argc, char *argv[]) {
     url_base = "/" + url_base;
   if (url_base[url_base.length() - 1] != '/')
     url_base = url_base + "/";
-  if (cmd_line->HasSwitch("log-path")) {
-    log_level = Log::kLog;
-    log_path = cmd_line->GetSwitchValuePath("log-path");
-#if defined(OS_WIN)
-    FILE* redir_stderr = _wfreopen(log_path.value().c_str(), L"w", stderr);
-#else
-    FILE* redir_stderr = freopen(log_path.value().c_str(), "w", stderr);
-#endif
-    if (!redir_stderr) {
-      printf("Failed to redirect stderr to log file. Exiting...\n");
-      return 1;
-    }
-  }
-  if (cmd_line->HasSwitch("verbose")) {
-    log_level = Log::kDebug;
-  } else {
-#if defined(OS_POSIX)
-    // Close stderr on exec, so that Chrome log spew doesn't confuse users.
-    fcntl(STDERR_FILENO, F_SETFD, FD_CLOEXEC);
-#endif
-  }
   if (!cmd_line->HasSwitch("silent")) {
     printf(
         "Starting ChromeDriver (v%s) on port %d\n", kChromeDriverVersion, port);
     fflush(stdout);
   }
 
-
-  logging::LoggingSettings settings;
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-  bool success = logging::InitLogging(settings);
-  if (!success) {
-    PLOG(ERROR) << "Unable to initialize logging";
+  if (!InitLogging()) {
+    printf("Unable to initialize logging. Exiting...\n");
+    return 1;
   }
-  logging::SetLogItems(false,  // enable_process_id
-                       false,  // enable_thread_id
-                       false,  // enable_timestamp
-                       false); // enable_tickcount
-  if (!cmd_line->HasSwitch("verbose"))
-    logging::SetMinLogLevel(logging::LOG_FATAL);
 
-  RunServer(log_level, port, url_base, adb_port);
+  RunServer(port, url_base, adb_port);
   return 0;
 }

chrome/test/chromedriver/server/http_handler.cc

@@ -56,9 +56,8 @@ CommandMapping::CommandMapping(HttpMethod method,
 
 CommandMapping::~CommandMapping() {}
 
-HttpHandler::HttpHandler(Log* log, const std::string& url_base)
-    : log_(log),
-      url_base_(url_base),
+HttpHandler::HttpHandler(const std::string& url_base)
+    : url_base_(url_base),
       received_shutdown_(false),
       command_map_(new CommandMap()),
       weak_ptr_factory_(this) {}
@@ -66,11 +65,9 @@ HttpHandler::HttpHandler(Log* log, const std::string& url_base)
 HttpHandler::HttpHandler(
     const base::Closure& quit_func,
     const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    Log* log,
     const std::string& url_base,
     int adb_port)
     : quit_func_(quit_func),
-      log_(log),
       url_base_(url_base),
       received_shutdown_(false),
       weak_ptr_factory_(this) {
@@ -79,15 +76,14 @@ HttpHandler::HttpHandler(
 #endif
   context_getter_ = new URLRequestContextGetter(io_task_runner);
   socket_factory_ = CreateSyncWebSocketFactory(context_getter_.get());
-  adb_.reset(new AdbImpl(io_task_runner, log_, adb_port));
+  adb_.reset(new AdbImpl(io_task_runner, adb_port));
   device_manager_.reset(new DeviceManager(adb_.get()));
 
   CommandMapping commands[] = {
       CommandMapping(kPost,
                      internal::kNewSessionPathPattern,
                      base::Bind(&ExecuteNewSession,
-                                NewSessionParams(log_,
-                                                 &session_thread_map_,
+                                NewSessionParams(&session_thread_map_,
                                                  context_getter_,
                                                  socket_factory_,
                                                  device_manager_.get()))),
@@ -491,11 +487,10 @@ void HttpHandler::HandleCommand(
     const net::HttpServerRequestInfo& request,
     const std::string& trimmed_path,
     const HttpResponseSenderFunc& send_response_func) {
-  log_->AddEntry(Log::kLog,
-                 base::StringPrintf("handling command: %s %s %s",
-                                    request.method.c_str(),
-                                    trimmed_path.c_str(),
-                                    request.data.c_str()));
+  if (IsVLogOn(0)) {
+    VLOG(0) << "Handling command: " << request.method << " " << trimmed_path
+            << " " << FormatJsonForDisplay(request.data);
+  }
 
   base::DictionaryValue params;
   std::string session_id;
@@ -545,10 +540,10 @@ void HttpHandler::PrepareResponse(
   CHECK(thread_checker_.CalledOnValidThread());
   scoped_ptr<net::HttpServerResponseInfo> response =
       PrepareResponseHelper(trimmed_path, status, value.Pass(), session_id);
-  log_->AddEntry(Log::kLog,
-                 base::StringPrintf("sending response: %d %s",
-                                    response->status_code(),
-                                    response->body().c_str()));
+  if (IsVLogOn(0)) {
+    VLOG(0) << "Sending response: " << response->status_code() << " "
+            << FormatJsonForDisplay(response->body());
+  }
   send_response_func.Run(response.Pass());
   if (trimmed_path == kShutdownPath)
     quit_func_.Run();

chrome/test/chromedriver/server/http_handler.h

@@ -35,7 +35,6 @@ class HttpServerResponseInfo;
 
 class Adb;
 class DeviceManager;
-class Log;
 class URLRequestContextGetter;
 
 enum HttpMethod {
@@ -60,10 +59,9 @@ typedef base::Callback<void(scoped_ptr<net::HttpServerResponseInfo>)>
 
 class HttpHandler {
  public:
-  HttpHandler(Log* log, const std::string& url_base);
+  explicit HttpHandler(const std::string& url_base);
   HttpHandler(const base::Closure& quit_func,
               const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-              Log* log,
               const std::string& url_base,
               int adb_port);
   ~HttpHandler();
@@ -98,7 +96,6 @@ class HttpHandler {
 
   base::ThreadChecker thread_checker_;
   base::Closure quit_func_;
-  Log* log_;
   std::string url_base_;
   bool received_shutdown_;
   scoped_refptr<URLRequestContextGetter> context_getter_;

chrome/test/chromedriver/server/http_handler_unittest.cc

@@ -37,8 +37,7 @@ void OnResponse(net::HttpServerResponseInfo* response_to_set,
 }  // namespace
 
 TEST(HttpHandlerTest, HandleOutsideOfBaseUrl) {
-  Logger log;
-  HttpHandler handler(&log, "base/url/");
+  HttpHandler handler("base/url/");
   net::HttpServerRequestInfo request;
   request.method = "get";
   request.path = "base/path";
@@ -49,8 +48,7 @@ TEST(HttpHandlerTest, HandleOutsideOfBaseUrl) {
 }
 
 TEST(HttpHandlerTest, HandleUnknownCommand) {
-  Logger log;
-  HttpHandler handler(&log, "/");
+  HttpHandler handler("/");
   net::HttpServerRequestInfo request;
   request.method = "get";
   request.path = "/path";
@@ -60,8 +58,7 @@ TEST(HttpHandlerTest, HandleUnknownCommand) {
 }
 
 TEST(HttpHandlerTest, HandleNewSession) {
-  Logger log;
-  HttpHandler handler(&log, "/base/");
+  HttpHandler handler("/base/");
   handler.command_map_.reset(new HttpHandler::CommandMap());
   handler.command_map_->push_back(
       CommandMapping(kPost, internal::kNewSessionPathPattern,
@@ -78,8 +75,7 @@ TEST(HttpHandlerTest, HandleNewSession) {
 }
 
 TEST(HttpHandlerTest, HandleInvalidPost) {
-  Logger log;
-  HttpHandler handler(&log, "/");
+  HttpHandler handler("/");
   handler.command_map_->push_back(
       CommandMapping(kPost, "path", base::Bind(&DummyCommand, Status(kOk))));
   net::HttpServerRequestInfo request;
@@ -92,8 +88,7 @@ TEST(HttpHandlerTest, HandleInvalidPost) {
 }
 
 TEST(HttpHandlerTest, HandleUnimplementedCommand) {
-  Logger log;
-  HttpHandler handler(&log, "/");
+  HttpHandler handler("/");
   handler.command_map_->push_back(
       CommandMapping(kPost, "path",
                      base::Bind(&DummyCommand, Status(kUnknownCommand))));
@@ -106,8 +101,7 @@ TEST(HttpHandlerTest, HandleUnimplementedCommand) {
 }
 
 TEST(HttpHandlerTest, HandleCommand) {
-  Logger log;
-  HttpHandler handler(&log, "/");
+  HttpHandler handler("/");
   handler.command_map_->push_back(
       CommandMapping(kPost, "path", base::Bind(&DummyCommand, Status(kOk))));
   net::HttpServerRequestInfo request;

chrome/test/chromedriver/session_commands.cc

@@ -389,7 +389,7 @@ Status ExecuteGetAvailableLogTypes(
   for (ScopedVector<WebDriverLog>::const_iterator log
        = session->devtools_logs.begin();
        log != session->devtools_logs.end(); ++log) {
-    types->AppendString((*log)->GetType());
+    types->AppendString((*log)->type());
   }
   value->reset(types.release());
   return Status(kOk);
@@ -406,7 +406,7 @@ Status ExecuteGetLog(
   for (ScopedVector<WebDriverLog>::const_iterator log
        = session->devtools_logs.begin();
        log != session->devtools_logs.end(); ++log) {
-    if (log_type == (*log)->GetType()) {
+    if (log_type == (*log)->type()) {
       scoped_ptr<base::ListValue> log_entries = (*log)->GetAndClearEntries();
       value->reset(log_entries.release());
       return Status(kOk);