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

content/browser/tracing/background_tracing_manager_impl.cc

 // Copyright 2015 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/background_tracing_manager_impl.h"
 
 #include "base/macros.h"
 #include "content/public/browser/background_tracing_preemptive_config.h"
 #include "content/public/browser/background_tracing_reactive_config.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 101 matching lines @@
   EnableRecordingIfConfigNeedsIt();
 
   return true;
 }
 
 void BackgroundTracingManagerImpl::EnableRecordingIfConfigNeedsIt() {
   if (!config_)
     return;
 
   if (config_->mode == BackgroundTracingConfig::PREEMPTIVE_TRACING_MODE) {
-    EnableRecording(GetCategoryFilterForCategoryPreset(
+    EnableRecording(GetCategoryFilterStringForCategoryPreset(
         static_cast<BackgroundTracingPreemptiveConfig*>(config_.get())
             ->category_preset));
   } else {
     // TODO(simonhatch): Implement reactive tracing path.
     NOTREACHED();
   }
 }
 
 bool BackgroundTracingManagerImpl::IsAbleToTriggerTracing(
     TriggerHandle handle) const {
@@ skipping 88 matching lines @@
            trigger_handles_.begin();
        it != trigger_handles_.end(); ++it)
     trigger_names->push_back(it->second);
 }
 
 void BackgroundTracingManagerImpl::InvalidateTriggerHandlesForTesting() {
   trigger_handles_.clear();
 }
 
 void BackgroundTracingManagerImpl::EnableRecording(
-    base::trace_event::CategoryFilter category_filter) {
+    std::string category_filter_str) {
   is_tracing_ = TracingController::GetInstance()->EnableRecording(
-      category_filter,
-      base::trace_event::TraceOptions(base::trace_event::RECORD_CONTINUOUSLY),
+      base::trace_event::TraceConfig(category_filter_str,
+                                     base::trace_event::RECORD_CONTINUOUSLY),
       TracingController::EnableRecordingDoneCallback());
 }
 
 void BackgroundTracingManagerImpl::OnFinalizeStarted(
     scoped_refptr<base::RefCountedString> file_contents) {
   CHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
 
   if (!receive_callback_.is_null())
     receive_callback_.Run(
         file_contents.get(),
@@ skipping 27 matching lines @@
   is_tracing_ = false;
 
   content::TracingController::GetInstance()->DisableRecording(
       content::TracingController::CreateCompressedStringSink(
           data_endpoint_wrapper_));
 
   if (!callback.is_null())
     callback.Run(true);
 }
 
-base::trace_event::CategoryFilter
-BackgroundTracingManagerImpl::GetCategoryFilterForCategoryPreset(
+std::string
+BackgroundTracingManagerImpl::GetCategoryFilterStringForCategoryPreset(
     BackgroundTracingConfig::CategoryPreset preset) const {
   switch (preset) {
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK:
-      return base::trace_event::CategoryFilter(
-          "benchmark,"
-          "disabled-by-default-toplevel.flow,"
-          "disabled-by-default-ipc.flow");
+      return "benchmark,"
+             "disabled-by-default-toplevel.flow,"
+             "disabled-by-default-ipc.flow";
     case BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP:
-      return base::trace_event::CategoryFilter(
-          "*,disabled-by-default-blink.debug.layout");
+      return "*,disabled-by-default-blink.debug.layout";
   }
   NOTREACHED();
-  return base::trace_event::CategoryFilter();
+  return "";
 }
 
 scoped_ptr<BackgroundTracingConfig> BackgroundTracingConfig::FromDict(
     const base::DictionaryValue* dict) {
   // TODO(simonhatch): Implement this.
   CHECK(false);
   return NULL;
 }
 
 void BackgroundTracingConfig::IntoDict(const BackgroundTracingConfig* config,
                                        base::DictionaryValue* dict) {
   // TODO(simonhatch): Implement this.
   CHECK(false);
 }
 
 }  // namspace content