Fixing loglevel in chrome driver to accept string rather than an integer.

chrome/test/webdriver/webdriver_capabilities_parser.cc

 // Copyright (c) 2012 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/webdriver_capabilities_parser.h"
 
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/webdriver/webdriver_error.h"
+#include "chrome/test/webdriver/webdriver_logging.h"
 #include "chrome/test/webdriver/webdriver_util.h"
 
 using base::DictionaryValue;
 using base::Value;
 
 namespace webdriver {
 
 namespace {
 
 Error* CreateBadInputError(const std::string& name,
@@ skipping 208 matching lines @@
     return CreateBadInputError("loggingPrefs", Value::TYPE_DICTIONARY, option);
 
   DictionaryValue::key_iterator key_iter = logging_prefs->begin_keys();
   for (; key_iter != logging_prefs->end_keys(); ++key_iter) {
     LogType log_type;
     if (!LogType::FromString(*key_iter, &log_type))
       continue;
 
     Value* level_value;
     logging_prefs->Get(*key_iter, &level_value);
-    int level;
-    if (!level_value->GetAsInteger(&level)) {
+    std::string level_name;
+    if (!level_value->GetAsString(&level_name)) {
       return CreateBadInputError(
           std::string("loggingPrefs.") + *key_iter,
-          Value::TYPE_INTEGER,
+          Value::TYPE_STRING,
           level_value);
     }
-    caps_->log_levels[log_type.type()] = static_cast<LogLevel>(level);
+    caps_->log_levels[log_type.type()] = LogLevelFromString(level_name);
   }
   return NULL;
 }
 
 Error* CapabilitiesParser::ParseNativeEvents(const Value* option) {
   if (!option->GetAsBoolean(&caps_->native_events))
     return CreateBadInputError("nativeEvents", Value::TYPE_BOOLEAN, option);
   return NULL;
 }
 
@@ skipping 71 matching lines @@
     if (error) {
       error->AddDetails("Error occurred while processing 'proxyType': " +
                         proxy_type);
       return error;
     }
   }
   return NULL;
 }
 
 Error* CapabilitiesParser::ParseProxyAutoDetect(
-    const DictionaryValue* options){
+    const DictionaryValue* options) {
   const char kProxyAutoDetectKey[] = "autodetect";
   bool proxy_auto_detect = false;
   if (!options->GetBoolean(kProxyAutoDetectKey, &proxy_auto_detect))
     return CreateBadInputError(kProxyAutoDetectKey,
                                Value::TYPE_BOOLEAN, options);
   if (proxy_auto_detect)
     caps_->command.AppendSwitch(switches::kProxyAutoDetect);
   return NULL;
 }
 
@@ skipping 71 matching lines @@
 }
 
 Error* CapabilitiesParser::ParseNoWebsiteTestingDefaults(const Value* option) {
   if (!option->GetAsBoolean(&caps_->no_website_testing_defaults))
     return CreateBadInputError("noWebsiteTestingDefaults",
                                Value::TYPE_BOOLEAN, option);
   return NULL;
 }
 
 }  // namespace webdriver