[Startup Tracing] Hook up TraceConfig and remove CategoryFilter & TraceOptions

content/browser/devtools/protocol/tracing_handler.cc

 // Copyright 2014 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/devtools/protocol/tracing_handler.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/trace_event_impl.h"
 
 namespace content {
 namespace devtools {
 namespace tracing {
 
 typedef DevToolsProtocolClient::Response Response;
 
 namespace {
 
-const char kRecordUntilFull[]   = "record-until-full";
-const char kRecordContinuously[] = "record-continuously";
-const char kRecordAsMuchAsPossible[] = "record-as-much-as-possible";
-const char kEnableSampling[] = "enable-sampling";
 const double kMinimumReportingInterval = 250.0;
 
 class DevToolsTraceSinkProxy : public TracingController::TraceDataSink {
  public:
   explicit DevToolsTraceSinkProxy(base::WeakPtr<TracingHandler> handler)
       : tracing_handler_(handler) {}
 
   void AddTraceChunk(const std::string& chunk) override {
     if (TracingHandler* h = tracing_handler_.get())
       h->OnTraceDataCollected(chunk);
@@ skipping 40 matching lines @@
   message += "] } }";
   client_->SendRawMessage(message);
 }
 
 void TracingHandler::OnTraceComplete() {
   client_->TracingComplete(TracingCompleteParams::Create());
 }
 
 Response TracingHandler::Start(DevToolsCommandId command_id,
                                const std::string* categories,
-                               const std::string* options_str,
+                               const std::string* options,
                                const double* buffer_usage_reporting_interval) {
   if (is_recording_)
     return Response::InternalError("Tracing is already started");
 
   is_recording_ = true;
-  base::trace_event::TraceOptions options = TraceOptionsFromString(options_str);
-  base::trace_event::CategoryFilter filter(categories ? *categories
-                                                      : std::string());
+  base::trace_event::TraceConfig trace_config(
+      categories ? *categories : std::string(),
+      options ? *options : std::string());
   if (buffer_usage_reporting_interval)
     SetupTimer(*buffer_usage_reporting_interval);
 
   // If inspected target is a render process Tracing.start will be handled by
   // tracing agent in the renderer.
   if (target_ == Renderer) {
     TracingController::GetInstance()->EnableRecording(
-        filter,
-        options,
+        trace_config,
         TracingController::EnableRecordingDoneCallback());
     return Response::FallThrough();
   }
 
   TracingController::GetInstance()->EnableRecording(
-      filter,
-      options,
+      trace_config,
       base::Bind(&TracingHandler::OnRecordingEnabled,
                  weak_factory_.GetWeakPtr(),
                  command_id));
   return Response::OK();
 }
 
 Response TracingHandler::End(DevToolsCommandId command_id) {
   if (!is_recording_)
     return Response::InternalError("Tracing is not started");
 
@@ skipping 28 matching lines @@
 void TracingHandler::OnCategoriesReceived(
     DevToolsCommandId command_id,
     const std::set<std::string>& category_set) {
   std::vector<std::string> categories;
   for (const std::string& category : category_set)
     categories.push_back(category);
   client_->SendGetCategoriesResponse(command_id,
       GetCategoriesResponse::Create()->set_categories(categories));
 }
 
-base::trace_event::TraceOptions TracingHandler::TraceOptionsFromString(
-    const std::string* options) {
-  base::trace_event::TraceOptions ret;
-  if (!options)
-    return ret;
-
-  std::vector<std::string> split;
-  std::vector<std::string>::iterator iter;
-
-  base::SplitString(*options, ',', &split);
-  for (iter = split.begin(); iter != split.end(); ++iter) {
-    if (*iter == kRecordUntilFull) {
-      ret.record_mode = base::trace_event::RECORD_UNTIL_FULL;
-    } else if (*iter == kRecordContinuously) {
-      ret.record_mode = base::trace_event::RECORD_CONTINUOUSLY;
-    } else if (*iter == kRecordAsMuchAsPossible) {
-      ret.record_mode = base::trace_event::RECORD_AS_MUCH_AS_POSSIBLE;
-    } else if (*iter == kEnableSampling) {
-      ret.enable_sampling = true;
-    }
-  }
-  return ret;
-}
-
 void TracingHandler::SetupTimer(double usage_reporting_interval) {
   if (usage_reporting_interval == 0) return;
 
   if (usage_reporting_interval < kMinimumReportingInterval)
       usage_reporting_interval = kMinimumReportingInterval;
 
   base::TimeDelta interval = base::TimeDelta::FromMilliseconds(
       std::ceil(usage_reporting_interval));
   buffer_usage_poll_timer_.reset(new base::Timer(
       FROM_HERE, interval,
       base::Bind(base::IgnoreResult(&TracingController::GetTraceBufferUsage),
                  base::Unretained(TracingController::GetInstance()),
                  base::Bind(&TracingHandler::OnBufferUsage,
                             weak_factory_.GetWeakPtr())),
       true));
   buffer_usage_poll_timer_->Reset();
 }
 
 void TracingHandler::DisableRecording(bool abort) {
   is_recording_ = false;
   buffer_usage_poll_timer_.reset();
   TracingController::GetInstance()->DisableRecording(
       abort ? nullptr : new DevToolsTraceSinkProxy(weak_factory_.GetWeakPtr()));
 }
 
 }  // namespace tracing
 }  // namespace devtools
 }  // namespace content