Remove TraceController

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 <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
+#include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/tracing_controller.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_data_source.h"
 #include "content/public/common/url_constants.h"
 #include "grit/tracing_resources.h"
 
 namespace content {
 namespace {
 
 void OnGotCategories(const WebUIDataSource::GotDataCallback& callback,
@@ skipping 13 matching lines @@
 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 
 bool OnBeginRecording(const std::string& data64,
                       const WebUIDataSource::GotDataCallback& callback) {
   std::string data;
   if (!base::Base64Decode(data64, &data)) {
     LOG(ERROR) << "Options were not base64 encoded.";
     return false;
   }
 
-  scoped_ptr<base::Value> optionsRaw(base::JSONReader::Read(data));
-  if (!optionsRaw) {
-    LOG(ERROR) << "Options were not valid JSON";
+  scoped_ptr<base::Value> paramsRaw(base::JSONReader::Read(data));
+  if (!paramsRaw) {
+    LOG(ERROR) << "Params were not valid JSON";
     return false;
   }
-  base::DictionaryValue* options;
-  if (!optionsRaw->GetAsDictionary(&options)) {
-    LOG(ERROR) << "Options must be dict";
+  base::DictionaryValue* params;
+  if (!paramsRaw->GetAsDictionary(&params)) {
+    LOG(ERROR) << "Params must be dict";
     return false;
   }
 
-  std::string category_filter_string;
-  bool use_system_tracing;
-  bool use_continuous_tracing;
-  bool use_sampling;
-
-  bool options_ok = true;
-  options_ok &= options->GetString("categoryFilter", &category_filter_string);
-  options_ok &= options->GetBoolean("useSystemTracing", &use_system_tracing);
-  options_ok &= options->GetBoolean("useContinuousTracing",
-                                    &use_continuous_tracing);
-  options_ok &= options->GetBoolean("useSampling", &use_sampling);
-  if (!options_ok) {
-    LOG(ERROR) << "Malformed options";
+  std::string category_filter;
+  TracingController::Options tracing_options;
+  if (!TracingControllerImpl::ParseTracingParams(params, &category_filter,
+                                                 &tracing_options)) {
     return false;
   }
 
-  int tracing_options = 0;
-  if (use_system_tracing)
-    tracing_options |= TracingController::ENABLE_SYSTRACE;
-  if (use_sampling)
-    tracing_options |= TracingController::ENABLE_SAMPLING;
-  if (use_continuous_tracing)
-    tracing_options |= TracingController::RECORD_CONTINUOUSLY;
-
-  base::debug::CategoryFilter category_filter(category_filter_string);
   return TracingController::GetInstance()->EnableRecording(
-      category_filter,
-      static_cast<TracingController::Options>(tracing_options),
+      category_filter, tracing_options,
       base::Bind(OnRecordingEnabledAck, callback));
 }
 
 void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback) {
   base::RefCountedString* res = new base::RefCountedString();
   callback.Run(res);
 }
 
 void OnTraceBufferPercentFullResult(
     const WebUIDataSource::GotDataCallback& callback, float result) {
@@ skipping 59 matching lines @@
 
   WebUIDataSource* source = WebUIDataSource::Create(kChromeUITracingHost);
   source->SetJsonPath("strings.js");
   source->SetDefaultResource(IDR_TRACING_HTML);
   source->AddResourcePath("tracing.js", IDR_TRACING_JS);
   source->SetRequestFilter(base::Bind(OnBeginRequest));
   WebUIDataSource::Add(browser_context, source);
 }
 
 }  // namespace content