Refactor trace_event_impl's SetEnabled to use TraceOptions. Propagate this through the whole stack.

content/browser/tracing/tracing_ui.cc

Index: content/browser/tracing/tracing_ui.cc
diff --git a/content/browser/tracing/tracing_ui.cc b/content/browser/tracing/tracing_ui.cc
index 3edcd183d951f2536ec75ce9d96d0cd47ddb8c33..9002a063b3acd560ad52b968f03d91e571d2fa5a 100644
--- a/content/browser/tracing/tracing_ui.cc
+++ b/content/browser/tracing/tracing_ui.cc
@@ -12,6 +12,7 @@
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
+#include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
@@ -55,7 +56,8 @@ void OnGotCategories(const WebUIDataSource::GotDataCallback& callback,
 
 bool GetTracingOptions(const std::string& data64,
                        std::string* category_filter_string,
-                       int* tracing_options) {
+                       base::debug::TraceOptions* tracing_options,
+                       bool* enable_systrace) {
   std::string data;
   if (!base::Base64Decode(data64, &data)) {
     LOG(ERROR) << "Options were not base64 encoded.";
@@ -88,13 +90,19 @@ bool GetTracingOptions(const std::string& data64,
     return false;
   }
 
-  *tracing_options = 0;
+  if (!tracing_options) {
+    LOG(ERROR) << "tracing_options can't be passed as NULL";
+    return false;
+  }
   if (use_system_tracing)
-    *tracing_options |= TracingController::ENABLE_SYSTRACE;
+    *enable_systrace = true;
   if (use_sampling)
-    *tracing_options |= TracingController::ENABLE_SAMPLING;
+    tracing_options->enable_sampling = true;
   if (use_continuous_tracing)
-    *tracing_options |= TracingController::RECORD_CONTINUOUSLY;
+    tracing_options->record_mode =
+        base::debug::TraceOptions::RECORD_CONTINUOUSLY;
+  else
+    tracing_options->record_mode = base::debug::TraceOptions::RECORD_UNTIL_FULL;
   return true;
 }
 
@@ -103,13 +111,16 @@ void OnRecordingEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 bool BeginRecording(const std::string& data64,
                     const WebUIDataSource::GotDataCallback& callback) {
   std::string category_filter_string;
-  int tracing_options = 0;
-  if (!GetTracingOptions(data64, &category_filter_string, &tracing_options))
+  base::debug::TraceOptions tracing_options;
+  bool enable_systrace;
+  if (!GetTracingOptions(
+          data64, &category_filter_string, &tracing_options, &enable_systrace))
     return false;
 
   return TracingController::GetInstance()->EnableRecording(
       category_filter_string,
-      static_cast<TracingController::Options>(tracing_options),
+      tracing_options,
+      enable_systrace,
       base::Bind(&OnRecordingEnabledAck, callback));
 }
 
@@ -146,13 +157,15 @@ void OnMonitoringEnabledAck(const WebUIDataSource::GotDataCallback& callback);
 bool EnableMonitoring(const std::string& data64,
                       const WebUIDataSource::GotDataCallback& callback) {
   std::string category_filter_string;
-  int tracing_options = 0;
-  if (!GetTracingOptions(data64, &category_filter_string, &tracing_options))
+  base::debug::TraceOptions tracing_options;
+  bool enable_systrace;
+  if (!GetTracingOptions(
+          data64, &category_filter_string, &tracing_options, &enable_systrace))
     return false;
 
   return TracingController::GetInstance()->EnableMonitoring(
       category_filter_string,
-      static_cast<TracingController::Options>(tracing_options),
+      static_cast<base::debug::TraceOptions>(tracing_options),

[dsinclair, 2014/07/28 18:52:36]

Why does this need a cast?

[nednguyen, 2014/07/28 20:27:22]

No it doesn't. I did a s/TracingController.../..TraceOptions/g and forgot to fix
this one.

The fact that we don't need to cast this is the signal that this approach is
more sane than using the integer bit, I think.

       base::Bind(OnMonitoringEnabledAck, callback));
 }
 
@@ -169,20 +182,20 @@ void OnMonitoringDisabled(const WebUIDataSource::GotDataCallback& callback) {
 void GetMonitoringStatus(const WebUIDataSource::GotDataCallback& callback) {
   bool is_monitoring;
   std::string category_filter;
-  TracingController::Options options;
+  base::debug::TraceOptions options;
+  bool enable_systrace;
   TracingController::GetInstance()->GetMonitoringStatus(
-      &is_monitoring, &category_filter, &options);
+      &is_monitoring, &category_filter, &options, &enable_systrace);
 
   scoped_ptr<base::DictionaryValue>
     monitoring_options(new base::DictionaryValue());
   monitoring_options->SetBoolean("isMonitoring", is_monitoring);
   monitoring_options->SetString("categoryFilter", category_filter);
-  monitoring_options->SetBoolean("useSystemTracing",
-      (options & TracingController::ENABLE_SYSTRACE) != 0);
-  monitoring_options->SetBoolean("useContinuousTracing",
-      (options & TracingController::RECORD_CONTINUOUSLY) != 0);
-  monitoring_options->SetBoolean("useSampling",
-      (options & TracingController::ENABLE_SAMPLING) != 0);
+  monitoring_options->SetBoolean("useSystemTracing", enable_systrace);
+  monitoring_options->SetBoolean(
+      "useContinuousTracing",
+      options.record_mode == base::debug::TraceOptions::RECORD_CONTINUOUSLY);
+  monitoring_options->SetBoolean("useSampling", options.enable_sampling);
 
   std::string monitoring_options_json;
   base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);