[ChromeDriver] Implementing tracing support

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 29 matching lines @@
                    Capabilities* capabilities) {
   std::string str;
   if (!option.GetAsString(&str))
     return Status(kUnknownError, "must be a string");
   if (str.empty())
     return Status(kUnknownError, "cannot be empty");
   *to_set = str;
   return Status(kOk);
 }
 
+Status ParseInterval(int* to_set,
+                     const base::Value& option,
+                     Capabilities* capabilities) {
+  int parsed_int = 0;
+  if (!option.GetAsInteger(&parsed_int))
+    return Status(kUnknownError, "must be an integer");
+  if (parsed_int <= 0)
+    return Status(kUnknownError, "must be positive");
+  *to_set = parsed_int;
+  return Status(kOk);
+}
+
 Status ParseFilePath(base::FilePath* to_set,
                      const base::Value& option,
                      Capabilities* capabilities) {
   base::FilePath::StringType str;
   if (!option.GetAsString(&str))
     return Status(kUnknownError, "must be a string");
   *to_set = base::FilePath(str);
   return Status(kOk);
 }
 
@@ skipping 256 matching lines @@
   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["bufferUsageReportingInterval"] = base::Bind(&ParseInterval,
+      &capabilities->perf_logging_prefs.buffer_usage_reporting_interval);
   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();
@@ skipping 179 matching lines @@
       break;
     str += " ";
   }
   return str;
 }
 
 PerfLoggingPrefs::PerfLoggingPrefs()
     : network(InspectorDomainStatus::kDefaultEnabled),
       page(InspectorDomainStatus::kDefaultEnabled),
       timeline(InspectorDomainStatus::kDefaultEnabled),
-      trace_categories() {}
+      trace_categories(),
+      buffer_usage_reporting_interval(1000) {}
 
 PerfLoggingPrefs::~PerfLoggingPrefs() {}
 
 Capabilities::Capabilities()
     : android_use_running_app(false),
       detach(false),
       force_devtools_screenshot(false) {}
 
 Capabilities::~Capabilities() {}
 
@@ skipping 27 matching lines @@
   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);
 }