[chromedriver] Remove Logger and just use base LOG.

chrome/test/chromedriver/capabilities.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/capabilities.h"
 
 #include <map>
 
 #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"
 #include "base/strings/string_util.h"
 #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 {
 
 typedef base::Callback<Status(const base::Value&, Capabilities*)> Parser;
 
 Status ParseBoolean(
     bool* to_set,
     const base::Value& option,
     Capabilities* capabilities) {
@@ skipping 30 matching lines @@
                  const base::Value& option,
                  Capabilities* capabilities) {
   const base::DictionaryValue* dict = NULL;
   if (!option.GetAsDictionary(&dict))
     return Status(kUnknownError, "must be a dictionary");
   to_set->reset(dict->DeepCopy());
   return Status(kOk);
 }
 
 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);
 }
 
 Status IgnoreCapability(const base::Value& option, Capabilities* capabilities) {
   return Status(kOk);
 }
 
 Status ParseLogPath(const base::Value& option, Capabilities* capabilities) {
   if (!option.GetAsString(&capabilities->log_path))
     return Status(kUnknownError, "must be a string");
@@ skipping 128 matching lines @@
   base::StringToInt(values[1], &port);
   if (port <= 0)
     return Status(kUnknownError, "port must be > 0");
 
   capabilities->debugger_address = NetAddress(values[0], port);
   return Status(kOk);
 }
 
 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;
   if (!capability.GetAsDictionary(&chrome_options))
     return Status(kUnknownError, "must be a dictionary");
 
   bool is_android = chrome_options->HasKey("androidPackage");
   bool is_existing = chrome_options->HasKey("debuggerAddress");
 
   std::map<std::string, Parser> parser_map;
@@ skipping 15 matching lines @@
   } else if (is_existing) {
     parser_map["debuggerAddress"] = base::Bind(&ParseUseExistingBrowser);
   } else {
     parser_map["args"] = base::Bind(&ParseSwitches);
     parser_map["binary"] = base::Bind(&ParseFilePath, &capabilities->binary);
     parser_map["detach"] = base::Bind(&ParseBoolean, &capabilities->detach);
     parser_map["excludeSwitches"] = base::Bind(&ParseExcludeSwitches);
     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);
     parser_map["prefs"] = base::Bind(&ParseDict, &capabilities->prefs);
   }
 
   for (base::DictionaryValue::Iterator it(*chrome_options); !it.IsAtEnd();
        it.Advance()) {
     if (parser_map.find(it.key()) == parser_map.end()) {
       return Status(kUnknownError,
@@ skipping 122 matching lines @@
 Capabilities::~Capabilities() {}
 
 bool Capabilities::IsAndroid() const {
   return !android_package.empty();
 }
 
 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();
        it != parser_map.end(); ++it) {
     const base::Value* capability = NULL;
     if (desired_caps.Get(it->first, &capability)) {
       Status status = it->second.Run(*capability, this);
       if (status.IsError()) {
         return Status(
             kUnknownError, "cannot parse capability: " + it->first, status);
       }
     }
   }
   return Status(kOk);
 }