Add webdriver endpoint to send custom debugger commands

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 <utility>
 
 #include "base/bind.h"
@@ skipping 382 matching lines @@
      if (parser_map.find(it.key()) == parser_map.end())
        return Status(kUnknownError, "unrecognized performance logging "
                      "option: " + it.key());
      Status status = parser_map[it.key()].Run(it.value(), capabilities);
      if (status.IsError())
        return Status(kUnknownError, "cannot parse " + it.key(), status);
   }
   return Status(kOk);
 }
 
+Status ParseDevToolsEventsLoggingPrefs(const base::Value& option,
+                                       Capabilities* capabilities) {
+  const base::ListValue* devtools_events_logging_prefs = nullptr;
+  if (!option.GetAsList(&devtools_events_logging_prefs))
+    return Status(kUnknownError, "must be a list");
+  if (devtools_events_logging_prefs->empty())
+    return Status(kUnknownError, "list must contain values");
+  capabilities->devtools_events_logging_prefs.reset(
+      devtools_events_logging_prefs->DeepCopy());
+  return Status(kOk);
+}
+
 Status ParseWindowTypes(const base::Value& option, Capabilities* capabilities) {
   const base::ListValue* window_types = NULL;
   if (!option.GetAsList(&window_types))
     return Status(kUnknownError, "must be a list");
   std::set<WebViewInfo::Type> window_types_tmp;
   for (size_t i = 0; i < window_types->GetSize(); ++i) {
     std::string window_type;
     if (!window_types->GetString(i, &window_type)) {
       return Status(kUnknownError, "each window type must be a string");
     }
@@ skipping 18 matching lines @@
   bool is_remote = chrome_options->HasKey("debuggerAddress");
 
   std::map<std::string, Parser> parser_map;
   // Ignore 'args', 'binary' and 'extensions' capabilities by default, since the
   // Java client always passes them.
   parser_map["args"] = base::Bind(&IgnoreCapability);
   parser_map["binary"] = base::Bind(&IgnoreCapability);
   parser_map["extensions"] = base::Bind(&IgnoreCapability);
 
   parser_map["perfLoggingPrefs"] = base::Bind(&ParsePerfLoggingPrefs);
+  parser_map["devToolsEventsToLog"] = base::Bind(
+          &ParseDevToolsEventsLoggingPrefs);
   parser_map["windowTypes"] = base::Bind(&ParseWindowTypes);
   // Compliance is read when session is initialized and correct response is
   // sent if not parsed correctly.
   parser_map["w3c"] = base::Bind(&IgnoreCapability);
 
   if (is_android) {
     parser_map["androidActivity"] =
         base::Bind(&ParseString, &capabilities->android_activity);
     parser_map["androidDeviceSerial"] =
         base::Bind(&ParseString, &capabilities->android_device_serial);
@@ skipping 208 matching lines @@
   LoggingPrefs::const_iterator iter = logging_prefs.find(
       WebDriverLog::kPerformanceType);
   if (iter == logging_prefs.end() || iter->second == Log::kOff) {
     const base::DictionaryValue* chrome_options = NULL;
     if (desired_caps.GetDictionary("chromeOptions", &chrome_options) &&
         chrome_options->HasKey("perfLoggingPrefs")) {
       return Status(kUnknownError, "perfLoggingPrefs specified, "
                     "but performance logging was not enabled");
     }
   }
+  LoggingPrefs::const_iterator dt_events_logging_iter = logging_prefs.find(
+      WebDriverLog::kDevToolsType);
+  if (dt_events_logging_iter == logging_prefs.end()
+      || dt_events_logging_iter->second == Log::kOff) {
+    const base::DictionaryValue* chrome_options = NULL;
+    if (desired_caps.GetDictionary("chromeOptions", &chrome_options) &&
+        chrome_options->HasKey("devToolsEventsToLog")) {
+      return Status(kUnknownError, "devToolsEventsToLog specified, "
+                    "but devtools events logging was not enabled");
+    }
+  }
   return Status(kOk);
 }