Add a second format to the tracing json/begin_recording endpoint.

content/browser/tracing/tracing_ui.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 "content/browser/tracing/tracing_ui.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <set>
@@ skipping 37 matching lines @@
   for (std::set<std::string>::const_iterator it = categorySet.begin();
        it != categorySet.end(); it++) {
     category_list.AppendString(*it);
   }
 
   scoped_refptr<base::RefCountedString> res(new base::RefCountedString());
   base::JSONWriter::Write(category_list, &res->data());
   callback.Run(res);
 }
 
-bool GetTracingOptions(const std::string& data64,
-                       base::trace_event::TraceConfig* trace_config) {
-  std::string data;
-  if (!base::Base64Decode(data64, &data)) {
-    LOG(ERROR) << "Options were not base64 encoded.";
-    return false;
-  }
-
-  std::unique_ptr<base::Value> optionsRaw = base::JSONReader::Read(data);
-  if (!optionsRaw) {
-    LOG(ERROR) << "Options were not valid JSON";
-    return false;
-  }
-  base::DictionaryValue* options;
-  if (!optionsRaw->GetAsDictionary(&options)) {
-    LOG(ERROR) << "Options must be dict";
-    return false;
-  }
-
-  if (!trace_config) {
-    LOG(ERROR) << "trace_config can't be passed as NULL";
-    return false;
-  }
-
-  bool options_ok = true;
-  std::string category_filter_string;
-  options_ok &= options->GetString("categoryFilter", &category_filter_string);
-
-  std::string record_mode;
-  options_ok &= options->GetString("tracingRecordMode", &record_mode);
-
-  *trace_config = base::trace_event::TraceConfig(category_filter_string,
-                                                 record_mode);
-
-  bool enable_systrace;
-  options_ok &= options->GetBoolean("useSystemTracing", &enable_systrace);
-  if (enable_systrace)
-    trace_config->EnableSystrace();
-
-  if (!options_ok) {
-    LOG(ERROR) << "Malformed options";
-    return false;
-  }
-  return true;
-}
-
 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
 bool BeginRecording(const std::string& data64,
                     const WebUIDataSource::GotDataCallback& callback) {
   base::trace_event::TraceConfig trace_config("", "");
-  if (!GetTracingOptions(data64, &trace_config))
+  if (!TracingUI::GetTracingOptions(data64, &trace_config))
     return false;
 
   return TracingController::GetInstance()->StartTracing(
       trace_config,
       base::Bind(&OnRecordingEnabledAck, callback));
 }
 
 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback) {
   callback.Run(
       scoped_refptr<base::RefCountedMemory>(new base::RefCountedString()));
@@ skipping 172 matching lines @@
   trace_uploader_ = delegate_->GetTraceUploader(
       BrowserContext::GetDefaultStoragePartition(
           web_ui()->GetWebContents()->GetBrowserContext())->
               GetURLRequestContext());
   DCHECK(trace_uploader_);
   trace_uploader_->DoUpload(file_contents, upload_mode, nullptr,
                             progress_callback, done_callback);
   // TODO(mmandlis): Add support for stopping the upload in progress.
 }
 
+// static
+bool TracingUI::GetTracingOptions(
+    const std::string& data64,
+    base::trace_event::TraceConfig* trace_config) {
+  std::string data;
+  if (!base::Base64Decode(data64, &data)) {
+    LOG(ERROR) << "Options were not base64 encoded.";
+    return false;
+  }
+
+  std::unique_ptr<base::Value> optionsRaw = base::JSONReader::Read(data);
+  if (!optionsRaw) {
+    LOG(ERROR) << "Options were not valid JSON";
+    return false;
+  }
+  base::DictionaryValue* options;
+  if (!optionsRaw->GetAsDictionary(&options)) {
+    LOG(ERROR) << "Options must be dict";
+    return false;
+  }
+
+  if (!trace_config) {
+    LOG(ERROR) << "trace_config can't be passed as NULL";
+    return false;
+  }
+
+  // New style options dictionary.
+  if (options->HasKey("included_categories")) {
+    *trace_config = base::trace_event::TraceConfig(*options);
+    return true;
+  }
+
+  bool options_ok = true;
+  std::string category_filter_string;
+  options_ok &= options->GetString("categoryFilter", &category_filter_string);
+
+  std::string record_mode;
+  options_ok &= options->GetString("tracingRecordMode", &record_mode);
+
+  *trace_config =
+      base::trace_event::TraceConfig(category_filter_string, record_mode);
+
+  bool enable_systrace;
+  options_ok &= options->GetBoolean("useSystemTracing", &enable_systrace);
+  if (enable_systrace)
+    trace_config->EnableSystrace();
+
+  if (!options_ok) {
+    LOG(ERROR) << "Malformed options";
+    return false;
+  }
+  return true;
+}
+
 void TracingUI::OnTraceUploadProgress(int64_t current, int64_t total) {
   DCHECK(current <= total);
   int percent = (current / total) * 100;
   web_ui()->CallJavascriptFunctionUnsafe(
       "onUploadProgress", base::Value(percent),
       base::Value(base::StringPrintf("%" PRId64, current)),
       base::Value(base::StringPrintf("%" PRId64, total)));
 }
 
 void TracingUI::OnTraceUploadComplete(bool success,
                                       const std::string& feedback) {
   if (success) {
     web_ui()->CallJavascriptFunctionUnsafe("onUploadComplete",
                                            base::Value(feedback));
   } else {
     web_ui()->CallJavascriptFunctionUnsafe("onUploadError",
                                            base::Value(feedback));
   }
   trace_uploader_.reset();
 }
 
 }  // namespace content