[ChromeDriver] Implementing PerfLoggingPrefs for perf 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"
@@ skipping 284 matching lines @@
     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 ParseInspectorDomainStatus(
+    PerfLoggingPrefs::InspectorDomainStatus* to_set,
+    const base::Value& option,
+    Capabilities* capabilities) {
+  bool desired_value;
+  if (!option.GetAsBoolean(&desired_value))
+    return Status(kUnknownError, "must be a boolean");
+  if (desired_value)
+    *to_set = PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyEnabled;
+  else
+    *to_set = PerfLoggingPrefs::InspectorDomainStatus::kExplicitlyDisabled;
+  return Status(kOk);
+}
+
+Status ParsePerfLoggingPrefs(const base::Value& option,
+                             Capabilities* capabilities) {
+  const base::DictionaryValue* perf_logging_prefs = NULL;
+  if (!option.GetAsDictionary(&perf_logging_prefs))
+    return Status(kUnknownError, "must be a dictionary");
+
+  std::map<std::string, Parser> parser_map;
+  parser_map["enableNetwork"] = base::Bind(
+      &ParseInspectorDomainStatus, &capabilities->perf_logging_prefs.network);
+  parser_map["enablePage"] = base::Bind(
+      &ParseInspectorDomainStatus, &capabilities->perf_logging_prefs.page);
+  parser_map["enableTimeline"] = base::Bind(
+      &ParseInspectorDomainStatus, &capabilities->perf_logging_prefs.timeline);
+  parser_map["traceCategories"] = base::Bind(
+      &ParseString, &capabilities->perf_logging_prefs.trace_categories);
+
+  for (base::DictionaryValue::Iterator it(*perf_logging_prefs); !it.IsAtEnd();
+       it.Advance()) {
+     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 ParseChromeOptions(
     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_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);
+
   if (is_android) {
     parser_map["androidActivity"] =
         base::Bind(&ParseString, &capabilities->android_activity);
     parser_map["androidDeviceSerial"] =
         base::Bind(&ParseString, &capabilities->android_device_serial);
     parser_map["androidPackage"] =
         base::Bind(&ParseString, &capabilities->android_package);
     parser_map["androidProcess"] =
         base::Bind(&ParseString, &capabilities->android_process);
     parser_map["androidUseRunningApp"] =
@@ skipping 135 matching lines @@
       str += "=" + value;
     }
     ++iter;
     if (iter == switch_map_.end())
       break;
     str += " ";
   }
   return str;
 }
 
+PerfLoggingPrefs::PerfLoggingPrefs()
+    : network(InspectorDomainStatus::kDefaultEnabled),
+      page(InspectorDomainStatus::kDefaultEnabled),
+      timeline(InspectorDomainStatus::kDefaultEnabled),
+      trace_categories() {}
+
+PerfLoggingPrefs::~PerfLoggingPrefs() {}
+
 Capabilities::Capabilities()
     : android_use_running_app(false),
       detach(false),
       force_devtools_screenshot(false) {}
 
 Capabilities::~Capabilities() {}
 
 bool Capabilities::IsAndroid() const {
   return !android_package.empty();
 }
@@ skipping 11 matching lines @@
        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);
       }
     }
   }
+  // Perf log must be enabled if perf log prefs are specified; otherwise, error.
+  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");
+    }
+  }
   return Status(kOk);
 }