Refactor tracing to pass around base::debug::TraceOptions to reduce spaghetti

Previously, the options for tracing were passed around with different ad hoc
systems. Strings in some places, base::debug::TraceOptions enum in others,
and a content::TraceOptions in yet another. There were two separate ad-hoc
string formats. Similar messes were present with category filters: sometimes
we passed strings, sometimes the CategoryFilter.

This patch though enormous looking simply consolidates all this ad-hockery
into base::debug::TraceOptions. It may look like the call sites have gotten
more verbose,
but the end result of this is a consistent understanding of TraceOptions.

There is one exception to this consolidation: devtools has to maintain its own
mapping of string->TraceOptions encoding. This is because DevTools makes
guarantees about backward compatibility: if base changes its mind about the
string form of a TraceOption, devtools needs to keep supporting the old form.

BUG=396081
TBR=cevans@chromium.org

Review URL: https://codereview.chromium.org/425593002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@287348 0039d316-1c4b-4281-b951-d872f2087c98

30 files changed, 703 insertions, 376 deletions

diff --git a/base/debug/trace_event_android.cc b/base/debug/trace_event_android.cc
index ed6b20d..1e78b45 100644
--- a/base/debug/trace_event_android.cc
+++ b/base/debug/trace_event_android.cc
@@ -97,8 +97,8 @@ void TraceLog::StartATrace() {
     return;
   }
   SetEnabled(CategoryFilter(CategoryFilter::kDefaultCategoryFilterString),
-             base::debug::TraceLog::RECORDING_MODE,
-             RECORD_CONTINUOUSLY);
+             TraceLog::RECORDING_MODE,
+             TraceOptions(RECORD_CONTINUOUSLY));
 }
 
 void TraceLog::StopATrace() {
diff --git a/base/debug/trace_event_impl.cc b/base/debug/trace_event_impl.cc
index 93ec6fe..85fa692 100644
--- a/base/debug/trace_event_impl.cc
+++ b/base/debug/trace_event_impl.cc
@@ -58,6 +58,13 @@ namespace {
 // trace.
 const int kOverheadReportThresholdInMicroseconds = 50;
 
+// String options that can be used to initialize TraceOptions.
+const char kRecordUntilFull[] = "record-until-full";
+const char kRecordContinuously[] = "record-continuously";
+const char kTraceToConsole[] = "trace-to-console";
+const char kEnableSampling[] = "enable-sampling";
+const char kEnableSystrace[] = "enable-systrace";
+
 // Controls the number of trace events we will buffer in-memory
 // before throwing them away.
 const size_t kTraceBufferChunkSize = TraceBufferChunk::kTraceBufferChunkSize;
@@ -970,6 +977,59 @@ TraceBucketData::~TraceBucketData() {
 
 ////////////////////////////////////////////////////////////////////////////////
 //
+// TraceOptions
+//
+////////////////////////////////////////////////////////////////////////////////
+
+TraceOptions::TraceOptions(const std::string& options_string)
+    : record_mode(RECORD_UNTIL_FULL),
+      enable_sampling(false),
+      enable_systrace(false) {
+  std::vector<std::string> split;
+  std::vector<std::string>::iterator iter;
+
+  base::SplitString(options_string, ',', &split);
+  for (iter = split.begin(); iter != split.end(); ++iter) {
+    if (*iter == kRecordUntilFull) {
+      record_mode = RECORD_UNTIL_FULL;
+    } else if (*iter == kRecordContinuously) {
+      record_mode = RECORD_CONTINUOUSLY;
+    } else if (*iter == kTraceToConsole) {
+      record_mode = ECHO_TO_CONSOLE;
+    } else if (*iter == kEnableSampling) {
+      enable_sampling = true;
+    } else if (*iter == kEnableSystrace) {
+      enable_systrace = true;
+    } else {
+      NOTREACHED();
+    }
+  }
+}
+
+std::string TraceOptions::ToString() const {
+  std::string ret;
+  switch (record_mode) {
+    case RECORD_UNTIL_FULL:
+      ret = kRecordUntilFull;
+      break;
+    case RECORD_CONTINUOUSLY:
+      ret = kRecordContinuously;
+      break;
+    case ECHO_TO_CONSOLE:
+      ret = kTraceToConsole;
+      break;
+    default:
+      NOTREACHED();
+  }
+  if (enable_sampling)
+    ret = ret + "," + kEnableSampling;
+  if (enable_systrace)
+    ret = ret + "," + kEnableSystrace;
+  return ret;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+//
 // TraceLog
 //
 ////////////////////////////////////////////////////////////////////////////////
@@ -1137,7 +1197,7 @@ TraceLog::TraceLog()
       process_id_hash_(0),
       process_id_(0),
       watch_category_(0),
-      trace_options_(RECORD_UNTIL_FULL),
+      trace_options_(kInternalRecordUntilFull),
       sampling_thread_handle_(0),
       category_filter_(CategoryFilter::kDefaultCategoryFilterString),
       event_callback_category_filter_(
@@ -1175,7 +1235,9 @@ TraceLog::TraceLog()
 
     LOG(ERROR) << "Start " << switches::kTraceToConsole
                << " with CategoryFilter '" << filter << "'.";
-    SetEnabled(CategoryFilter(filter), RECORDING_MODE, ECHO_TO_CONSOLE);
+    SetEnabled(CategoryFilter(filter),
+               RECORDING_MODE,
+               TraceOptions(ECHO_TO_CONSOLE));
   }
 #endif
 
@@ -1325,7 +1387,7 @@ void TraceLog::GetKnownCategoryGroups(
 
 void TraceLog::SetEnabled(const CategoryFilter& category_filter,
                           Mode mode,
-                          Options options) {
+                          const TraceOptions& options) {
   std::vector<EnabledStateObserver*> observer_list;
   {
     AutoLock lock(lock_);
@@ -1333,10 +1395,13 @@ void TraceLog::SetEnabled(const CategoryFilter& category_filter,
     // Can't enable tracing when Flush() is in progress.
     DCHECK(!flush_message_loop_proxy_.get());
 
-    Options old_options = trace_options();
+    InternalTraceOptions new_options =
+        GetInternalOptionsFromTraceOptions(options);
+
+   InternalTraceOptions old_options = trace_options();
 
     if (IsEnabled()) {
-      if (options != old_options) {
+      if (new_options != old_options) {
         DLOG(ERROR) << "Attempting to re-enable tracing with a different "
                     << "set of options.";
       }
@@ -1358,8 +1423,8 @@ void TraceLog::SetEnabled(const CategoryFilter& category_filter,
 
     mode_ = mode;
 
-    if (options != old_options) {
-      subtle::NoBarrier_Store(&trace_options_, options);
+    if (new_options != old_options) {
+      subtle::NoBarrier_Store(&trace_options_, new_options);
       UseNextTraceBuffer();
     }
 
@@ -1369,7 +1434,7 @@ void TraceLog::SetEnabled(const CategoryFilter& category_filter,
     UpdateCategoryGroupEnabledFlags();
     UpdateSyntheticDelaysFromCategoryFilter();
 
-    if (options & ENABLE_SAMPLING) {
+    if (new_options & kInternalEnableSampling) {
       sampling_thread_.reset(new TraceSamplingThread);
       sampling_thread_->RegisterSampleBucket(
           &g_trace_state[0],
@@ -1402,11 +1467,42 @@ void TraceLog::SetEnabled(const CategoryFilter& category_filter,
   }
 }
 
+TraceLog::InternalTraceOptions TraceLog::GetInternalOptionsFromTraceOptions(
+    const TraceOptions& options) {
+  InternalTraceOptions ret =
+      options.enable_sampling ? kInternalEnableSampling : kInternalNone;
+  switch (options.record_mode) {
+    case RECORD_UNTIL_FULL:
+      return ret | kInternalRecordUntilFull;
+    case RECORD_CONTINUOUSLY:
+      return ret | kInternalRecordContinuously;
+    case ECHO_TO_CONSOLE:
+      return ret | kInternalEchoToConsole;
+  }
+  NOTREACHED();
+  return kInternalNone;
+}
+
 CategoryFilter TraceLog::GetCurrentCategoryFilter() {
   AutoLock lock(lock_);
   return category_filter_;
 }
 
+TraceOptions TraceLog::GetCurrentTraceOptions() const {
+  TraceOptions ret;
+  InternalTraceOptions option = trace_options();
+  ret.enable_sampling = (option & kInternalEnableSampling) != 0;
+  if (option & kInternalRecordUntilFull)
+    ret.record_mode = RECORD_UNTIL_FULL;
+  else if (option & kInternalRecordContinuously)
+    ret.record_mode = RECORD_CONTINUOUSLY;
+  else if (option & kInternalEchoToConsole)
+    ret.record_mode = ECHO_TO_CONSOLE;
+  else
+    NOTREACHED();
+  return ret;
+}
+
 void TraceLog::SetDisabled() {
   AutoLock lock(lock_);
   SetDisabledWhileLocked();
@@ -1496,12 +1592,12 @@ bool TraceLog::BufferIsFull() const {
 }
 
 TraceBuffer* TraceLog::CreateTraceBuffer() {
-  Options options = trace_options();
-  if (options & RECORD_CONTINUOUSLY)
+  InternalTraceOptions options = trace_options();
+  if (options & kInternalRecordContinuously)
     return new TraceBufferRingBuffer(kTraceEventRingBufferChunks);
-  else if ((options & ENABLE_SAMPLING) && mode_ == MONITORING_MODE)
+  else if ((options & kInternalEnableSampling) && mode_ == MONITORING_MODE)
     return new TraceBufferRingBuffer(kMonitorTraceEventBufferChunks);
-  else if (options & ECHO_TO_CONSOLE)
+  else if (options & kInternalEchoToConsole)
     return new TraceBufferRingBuffer(kEchoToConsoleTraceEventBufferChunks);
   return CreateTraceBufferVectorOfSize(kTraceEventVectorBufferChunks);
 }
@@ -1874,7 +1970,7 @@ TraceEventHandle TraceLog::AddTraceEventWithThreadIdAndTimestamp(
 #endif
     }
 
-    if (trace_options() & ECHO_TO_CONSOLE) {
+    if (trace_options() & kInternalEchoToConsole) {
       console_message = EventToConsoleMessage(
           phase == TRACE_EVENT_PHASE_COMPLETE ? TRACE_EVENT_PHASE_BEGIN : phase,
           timestamp, trace_event);
@@ -2017,7 +2113,7 @@ void TraceLog::UpdateTraceEventDuration(
 #endif
     }
 
-    if (trace_options() & ECHO_TO_CONSOLE) {
+    if (trace_options() & kInternalEchoToConsole) {
       console_message = EventToConsoleMessage(TRACE_EVENT_PHASE_END,
                                               now, trace_event);
     }
@@ -2262,6 +2358,10 @@ CategoryFilter::CategoryFilter(const std::string& filter_string) {
     Initialize(CategoryFilter::kDefaultCategoryFilterString);
 }
 
+CategoryFilter::CategoryFilter() {
+    Initialize(CategoryFilter::kDefaultCategoryFilterString);
+}
+
 CategoryFilter::CategoryFilter(const CategoryFilter& cf)
     : included_(cf.included_),
       disabled_(cf.disabled_),
diff --git a/base/debug/trace_event_impl.h b/base/debug/trace_event_impl.h
index 146ca8f..32cd648 100644
--- a/base/debug/trace_event_impl.h
+++ b/base/debug/trace_event_impl.h
@@ -316,6 +316,8 @@ class BASE_EXPORT CategoryFilter {
   //          is called.
   explicit CategoryFilter(const std::string& filter_string);
 
+  CategoryFilter();
+
   CategoryFilter(const CategoryFilter& cf);
 
   ~CategoryFilter();
@@ -341,7 +343,7 @@ class BASE_EXPORT CategoryFilter {
 
   // Clears both included/excluded pattern lists. This would be equivalent to
   // creating a CategoryFilter with an empty string, through the constructor.
-  // i.e: CategoryFilter("").
+  // i.e: CategoryFilter().
   //
   // When using an empty filter, all categories are considered included as we
   // are not excluding anything.
@@ -371,6 +373,52 @@ class BASE_EXPORT CategoryFilter {
 
 class TraceSamplingThread;
 
+// Options determines how the trace buffer stores data.
+enum TraceRecordMode {
+  // Record until the trace buffer is full.
+  RECORD_UNTIL_FULL,
+
+  // Record until the user ends the trace. The trace buffer is a fixed size
+  // and we use it as a ring buffer during recording.
+  RECORD_CONTINUOUSLY,
+
+  // Echo to console. Events are discarded.
+  ECHO_TO_CONSOLE,
+};
+
+struct BASE_EXPORT TraceOptions {
+
+  TraceOptions()
+      : record_mode(RECORD_UNTIL_FULL),
+        enable_sampling(false),
+        enable_systrace(false) {}
+
+  TraceOptions(TraceRecordMode record_mode)
+      : record_mode(record_mode),
+        enable_sampling(false),
+        enable_systrace(false) {}
+
+  // |options_string| is a comma-delimited list of trace options.
+  // Possible options are: "record-until-full", "record-continuously",
+  // "trace-to-console", "enable-sampling" and "enable-systrace".
+  // The first 3 options are trace recoding modes and hence
+  // mutually exclusive. If more than one trace recording modes appear in the
+  // options_string, the last one takes precedence. If none of the trace
+  // recording mode is specified, recording mode is RECORD_UNTIL_FULL.
+  //
+  // Example: TraceOptions("record-until-full")
+  // Example: TraceOptions("record-continuously, enable-sampling")
+  // Example: TraceOptions("record-until-full, trace-to-console") would have
+  //          ECHO_TO_CONSOLE as the recording mode.
+  explicit TraceOptions(const std::string& options_string);
+
+  std::string ToString() const;
+
+  TraceRecordMode record_mode;
+  bool enable_sampling;
+  bool enable_systrace;
+};
+
 class BASE_EXPORT TraceLog {
  public:
   enum Mode {
@@ -379,22 +427,6 @@ class BASE_EXPORT TraceLog {
     MONITORING_MODE,
   };
 
-  // Options determines how the trace buffer stores data.
-  enum Options {
-    // Record until the trace buffer is full.
-    RECORD_UNTIL_FULL = 1 << 0,
-
-    // Record until the user ends the trace. The trace buffer is a fixed size
-    // and we use it as a ring buffer during recording.
-    RECORD_CONTINUOUSLY = 1 << 1,
-
-    // Enable the sampling profiler in the recording mode.
-    ENABLE_SAMPLING = 1 << 2,
-
-    // Echo to console. Events are discarded.
-    ECHO_TO_CONSOLE = 1 << 3,
-  };
-
   // The pointer returned from GetCategoryGroupEnabledInternal() points to a
   // value with zero or more of the following bits. Used in this class only.
   // The TRACE_EVENT macros should only use the value as a bool.
@@ -417,16 +449,15 @@ class BASE_EXPORT TraceLog {
   // Retrieves a copy (for thread-safety) of the current CategoryFilter.
   CategoryFilter GetCurrentCategoryFilter();
 
-  Options trace_options() const {
-    return static_cast<Options>(subtle::NoBarrier_Load(&trace_options_));
-  }
+  // Retrieves a copy (for thread-safety) of the current TraceOptions.
+  TraceOptions GetCurrentTraceOptions() const;
 
   // Enables normal tracing (recording trace events in the trace buffer).
   // See CategoryFilter comments for details on how to control what categories
   // will be traced. If tracing has already been enabled, |category_filter| will
   // be merged into the current category filter.
   void SetEnabled(const CategoryFilter& category_filter,
-                  Mode mode, Options options);
+                  Mode mode, const TraceOptions& options);
 
   // Disables normal tracing for all categories.
   void SetDisabled();
@@ -606,6 +637,8 @@ class BASE_EXPORT TraceLog {
   void SetCurrentThreadBlocksMessageLoop();
 
  private:
+  typedef unsigned int InternalTraceOptions;
+
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferRingBufferGetReturnChunk);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
@@ -614,6 +647,9 @@ class BASE_EXPORT TraceLog {
                            TraceBufferRingBufferFullIteration);
   FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
                            TraceBufferVectorReportFull);
+  FRIEND_TEST_ALL_PREFIXES(TraceEventTestFixture,
+                           ConvertTraceOptionsToInternalOptions);
+
 
   // This allows constructor and destructor to be private and usable only
   // by the Singleton class.
@@ -631,6 +667,9 @@ class BASE_EXPORT TraceLog {
   // category filter.
   void UpdateSyntheticDelaysFromCategoryFilter();
 
+  InternalTraceOptions GetInternalOptionsFromTraceOptions(
+      const TraceOptions& options);
+
   class ThreadLocalEventBuffer;
   class OptionalAutoLock;
 
@@ -639,6 +678,11 @@ class BASE_EXPORT TraceLog {
   const unsigned char* GetCategoryGroupEnabledInternal(const char* name);
   void AddMetadataEventsWhileLocked();
 
+  InternalTraceOptions trace_options() const {
+    return static_cast<InternalTraceOptions>(
+        subtle::NoBarrier_Load(&trace_options_));
+  }
+
   TraceBuffer* trace_buffer() const { return logged_events_.get(); }
   TraceBuffer* CreateTraceBuffer();
   TraceBuffer* CreateTraceBufferVectorOfSize(size_t max_chunks);
@@ -678,6 +722,14 @@ class BASE_EXPORT TraceLog {
     return timestamp - time_offset_;
   }
 
+  // Internal representation of trace options since we store the currently used
+  // trace option as an AtomicWord.
+  static const InternalTraceOptions kInternalNone;
+  static const InternalTraceOptions kInternalRecordUntilFull;
+  static const InternalTraceOptions kInternalRecordContinuously;
+  static const InternalTraceOptions kInternalEchoToConsole;
+  static const InternalTraceOptions kInternalEnableSampling;
+
   // This lock protects TraceLog member accesses (except for members protected
   // by thread_info_lock_) from arbitrary threads.
   mutable Lock lock_;
diff --git a/base/debug/trace_event_impl_constants.cc b/base/debug/trace_event_impl_constants.cc
index 71e9e08..17a270a 100644
--- a/base/debug/trace_event_impl_constants.cc
+++ b/base/debug/trace_event_impl_constants.cc
@@ -10,5 +10,16 @@ namespace debug {
 // Enable everything but debug and test categories by default.
 const char* CategoryFilter::kDefaultCategoryFilterString = "-*Debug,-*Test";
 
+// Constant used by TraceLog's internal implementation of trace_option.
+const TraceLog::InternalTraceOptions TraceLog::kInternalNone = 0;
+const TraceLog::InternalTraceOptions TraceLog::kInternalRecordUntilFull =
+    1 << 0;
+const TraceLog::InternalTraceOptions TraceLog::kInternalRecordContinuously =
+    1 << 1;
+const TraceLog::InternalTraceOptions TraceLog::kInternalEnableSampling = 1
+                                                                          << 2;
+const TraceLog::InternalTraceOptions TraceLog::kInternalEchoToConsole = 1
+                                                                          << 3;
+
 }  // namespace debug
 }  // namespace base
diff --git a/base/debug/trace_event_unittest.cc b/base/debug/trace_event_unittest.cc
index ce07604..d5e8742 100644
--- a/base/debug/trace_event_unittest.cc
+++ b/base/debug/trace_event_unittest.cc
@@ -26,8 +26,6 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::debug::HighResSleepForTraceTest;
-
 namespace base {
 namespace debug {
 
@@ -81,9 +79,10 @@ class TraceEventTestFixture : public testing::Test {
 
   void BeginSpecificTrace(const std::string& filter) {
     event_watch_notification_ = 0;
-    TraceLog::GetInstance()->SetEnabled(CategoryFilter(filter),
-                                        base::debug::TraceLog::RECORDING_MODE,
-                                        TraceLog::RECORD_UNTIL_FULL);
+    TraceLog::GetInstance()->SetEnabled(
+        CategoryFilter(filter),
+        TraceLog::RECORDING_MODE,
+        TraceOptions());
   }
 
   void EndTraceAndFlush() {
@@ -149,8 +148,8 @@ class TraceEventTestFixture : public testing::Test {
 
   char* old_thread_name_;
   ListValue trace_parsed_;
-  base::debug::TraceResultBuffer trace_buffer_;
-  base::debug::TraceResultBuffer::SimpleOutput json_output_;
+  TraceResultBuffer trace_buffer_;
+  TraceResultBuffer::SimpleOutput json_output_;
   int event_watch_notification_;
 
  private:
@@ -882,9 +881,10 @@ void HighResSleepForTraceTest(base::TimeDelta elapsed) {
 
 // Simple Test for emitting data and validating it was received.
 TEST_F(TraceEventTestFixture, DataCaptured) {
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
 
   TraceWithAllMacroVariants(NULL);
 
@@ -894,7 +894,7 @@ TEST_F(TraceEventTestFixture, DataCaptured) {
 }
 
 class MockEnabledStateChangedObserver :
-      public base::debug::TraceLog::EnabledStateObserver {
+      public TraceLog::EnabledStateObserver {
  public:
   MOCK_METHOD0(OnTraceLogEnabled, void());
   MOCK_METHOD0(OnTraceLogDisabled, void());
@@ -906,9 +906,10 @@ TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) {
 
   EXPECT_CALL(observer, OnTraceLogEnabled())
       .Times(1);
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   testing::Mock::VerifyAndClear(&observer);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
@@ -918,9 +919,10 @@ TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) {
 }
 
 TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) {
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
 
   testing::StrictMock<MockEnabledStateChangedObserver> observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
@@ -929,9 +931,10 @@ TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) {
       .Times(0);
   EXPECT_CALL(observer, OnTraceLogDisabled())
       .Times(0);
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   testing::Mock::VerifyAndClear(&observer);
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
@@ -943,12 +946,14 @@ TEST_F(TraceEventTestFixture, EnabledObserverDoesntFireOnSecondEnable) {
 
 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnFirstDisable) {
   CategoryFilter cf_inc_all("*");
-  TraceLog::GetInstance()->SetEnabled(cf_inc_all,
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
-  TraceLog::GetInstance()->SetEnabled(cf_inc_all,
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      cf_inc_all,
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
+  TraceLog::GetInstance()->SetEnabled(
+      cf_inc_all,
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
 
   testing::StrictMock<MockEnabledStateChangedObserver> observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
@@ -966,9 +971,10 @@ TEST_F(TraceEventTestFixture, EnabledObserverFiresOnFirstDisable) {
 }
 
 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnDisable) {
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
 
   MockEnabledStateChangedObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
@@ -984,12 +990,12 @@ TEST_F(TraceEventTestFixture, EnabledObserverFiresOnDisable) {
 
 // Tests the IsEnabled() state of TraceLog changes before callbacks.
 class AfterStateChangeEnabledStateObserver
-    : public base::debug::TraceLog::EnabledStateObserver {
+    : public TraceLog::EnabledStateObserver {
  public:
   AfterStateChangeEnabledStateObserver() {}
   virtual ~AfterStateChangeEnabledStateObserver() {}
 
-  // base::debug::TraceLog::EnabledStateObserver overrides:
+  // TraceLog::EnabledStateObserver overrides:
   virtual void OnTraceLogEnabled() OVERRIDE {
     EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
   }
@@ -1003,9 +1009,10 @@ TEST_F(TraceEventTestFixture, ObserversFireAfterStateChange) {
   AfterStateChangeEnabledStateObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   EXPECT_TRUE(TraceLog::GetInstance()->IsEnabled());
 
   TraceLog::GetInstance()->SetDisabled();
@@ -1016,12 +1023,12 @@ TEST_F(TraceEventTestFixture, ObserversFireAfterStateChange) {
 
 // Tests that a state observer can remove itself during a callback.
 class SelfRemovingEnabledStateObserver
-    : public base::debug::TraceLog::EnabledStateObserver {
+    : public TraceLog::EnabledStateObserver {
  public:
   SelfRemovingEnabledStateObserver() {}
   virtual ~SelfRemovingEnabledStateObserver() {}
 
-  // base::debug::TraceLog::EnabledStateObserver overrides:
+  // TraceLog::EnabledStateObserver overrides:
   virtual void OnTraceLogEnabled() OVERRIDE {}
 
   virtual void OnTraceLogDisabled() OVERRIDE {
@@ -1036,9 +1043,10 @@ TEST_F(TraceEventTestFixture, SelfRemovingObserver) {
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
   EXPECT_EQ(1u, TraceLog::GetInstance()->GetObserverCountForTest());
 
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TraceLog::GetInstance()->SetDisabled();
   // The observer removed itself on disable.
   EXPECT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
@@ -1052,9 +1060,10 @@ bool IsNewTrace() {
 
 TEST_F(TraceEventTestFixture, NewTraceRecording) {
   ASSERT_FALSE(IsNewTrace());
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   // First call to IsNewTrace() should succeed. But, the second shouldn't.
   ASSERT_TRUE(IsNewTrace());
   ASSERT_FALSE(IsNewTrace());
@@ -1065,9 +1074,10 @@ TEST_F(TraceEventTestFixture, NewTraceRecording) {
 
   // Start another trace. IsNewTrace() should become true again, briefly, as
   // before.
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   ASSERT_TRUE(IsNewTrace());
   ASSERT_FALSE(IsNewTrace());
 
@@ -1122,9 +1132,10 @@ TEST_F(TraceEventTestFixture, Categories) {
   // Include nonexistent category -> no events
   Clear();
   included_categories.clear();
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("not_found823564786"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("not_found823564786"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
@@ -1134,9 +1145,10 @@ TEST_F(TraceEventTestFixture, Categories) {
   // Include existent category -> only events of that category
   Clear();
   included_categories.clear();
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("inc"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("inc"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
@@ -1149,8 +1161,8 @@ TEST_F(TraceEventTestFixture, Categories) {
   included_categories.clear();
   TraceLog::GetInstance()->SetEnabled(
       CategoryFilter("inc_wildcard_*,inc_wildchar_?_end"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::RECORD_UNTIL_FULL);
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("inc_wildcard_abc", "included",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc_wildcard_", "included", TRACE_EVENT_SCOPE_THREAD);
@@ -1178,9 +1190,10 @@ TEST_F(TraceEventTestFixture, Categories) {
 
   // Exclude nonexistent category -> all events
   Clear();
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("-not_found823564786"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("-not_found823564786"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("cat1", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("cat2", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("category1,category2", "name", TRACE_EVENT_SCOPE_THREAD);
@@ -1191,9 +1204,10 @@ TEST_F(TraceEventTestFixture, Categories) {
 
   // Exclude existent category -> only events of other categories
   Clear();
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("-inc"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("-inc"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("inc", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc2", "name", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc2,inc", "name", TRACE_EVENT_SCOPE_THREAD);
@@ -1208,8 +1222,8 @@ TEST_F(TraceEventTestFixture, Categories) {
   Clear();
   TraceLog::GetInstance()->SetEnabled(
       CategoryFilter("-inc_wildcard_*,-inc_wildchar_?_end"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::RECORD_UNTIL_FULL);
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("inc_wildcard_abc", "not_inc",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc_wildcard_", "not_inc",
@@ -1361,12 +1375,12 @@ TEST_F(TraceEventTestFixture, StaticStringVsString) {
   {
     BeginTrace();
     // Test that string arguments are copied.
-    base::debug::TraceEventHandle handle1 =
+    TraceEventHandle handle1 =
         trace_event_internal::AddTraceEvent(
             TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name1", 0, 0,
             "arg1", std::string("argval"), "arg2", std::string("argval"));
     // Test that static TRACE_STR_COPY string arguments are copied.
-    base::debug::TraceEventHandle handle2 =
+    TraceEventHandle handle2 =
         trace_event_internal::AddTraceEvent(
             TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name2", 0, 0,
             "arg1", TRACE_STR_COPY("argval"),
@@ -1389,14 +1403,14 @@ TEST_F(TraceEventTestFixture, StaticStringVsString) {
   {
     BeginTrace();
     // Test that static literal string arguments are not copied.
-    base::debug::TraceEventHandle handle1 =
+    TraceEventHandle handle1 =
         trace_event_internal::AddTraceEvent(
             TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name1", 0, 0,
             "arg1", "argval", "arg2", "argval");
     // Test that static TRACE_STR_COPY NULL string arguments are not copied.
     const char* str1 = NULL;
     const char* str2 = NULL;
-    base::debug::TraceEventHandle handle2 =
+    TraceEventHandle handle2 =
         trace_event_internal::AddTraceEvent(
             TRACE_EVENT_PHASE_INSTANT, category_group_enabled, "name2", 0, 0,
             "arg1", TRACE_STR_COPY(str1),
@@ -1717,20 +1731,20 @@ TEST_F(TraceEventTestFixture, TraceEnableDisable) {
   TraceLog* trace_log = TraceLog::GetInstance();
   CategoryFilter cf_inc_all("*");
   trace_log->SetEnabled(cf_inc_all,
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(trace_log->IsEnabled());
   trace_log->SetDisabled();
   EXPECT_FALSE(trace_log->IsEnabled());
 
   trace_log->SetEnabled(cf_inc_all,
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(trace_log->IsEnabled());
   const std::vector<std::string> empty;
-  trace_log->SetEnabled(CategoryFilter(""),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+  trace_log->SetEnabled(CategoryFilter(),
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(trace_log->IsEnabled());
   trace_log->SetDisabled();
   EXPECT_FALSE(trace_log->IsEnabled());
@@ -1741,20 +1755,20 @@ TEST_F(TraceEventTestFixture, TraceEnableDisable) {
 TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(CategoryFilter("foo,bar"),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
   trace_log->SetEnabled(CategoryFilter("foo2"),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo2"));
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
   // The "" becomes the default catergory set when applied.
-  trace_log->SetEnabled(CategoryFilter(""),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+  trace_log->SetEnabled(CategoryFilter(),
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("foo"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
   EXPECT_STREQ("-*Debug,-*Test",
@@ -1766,13 +1780,13 @@ TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("baz"));
 
   trace_log->SetEnabled(CategoryFilter("-foo,-bar"),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
   trace_log->SetEnabled(CategoryFilter("moo"),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("baz"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("moo"));
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
@@ -1783,12 +1797,12 @@ TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
 
   // Make sure disabled categories aren't cleared if we set in the second.
   trace_log->SetEnabled(CategoryFilter("disabled-by-default-cc,foo"),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("bar"));
   trace_log->SetEnabled(CategoryFilter("disabled-by-default-gpu"),
-                        base::debug::TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-cc"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("disabled-by-default-gpu"));
   EXPECT_TRUE(*trace_log->GetCategoryGroupEnabled("bar"));
@@ -1799,11 +1813,11 @@ TEST_F(TraceEventTestFixture, TraceCategoriesAfterNestedEnable) {
 }
 
 TEST_F(TraceEventTestFixture, TraceSampling) {
-  TraceLog::GetInstance()->SetEnabled(
-      CategoryFilter("*"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::Options(TraceLog::RECORD_UNTIL_FULL |
-                        TraceLog::ENABLE_SAMPLING));
+  TraceOptions trace_options(RECORD_UNTIL_FULL);
+  trace_options.enable_sampling = true;
+  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
+                                      TraceLog::RECORDING_MODE,
+                                      trace_options);
 
   TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Stuff");
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
@@ -1818,11 +1832,11 @@ TEST_F(TraceEventTestFixture, TraceSampling) {
 }
 
 TEST_F(TraceEventTestFixture, TraceSamplingScope) {
-  TraceLog::GetInstance()->SetEnabled(
-    CategoryFilter("*"),
-    base::debug::TraceLog::RECORDING_MODE,
-    TraceLog::Options(TraceLog::RECORD_UNTIL_FULL |
-                      TraceLog::ENABLE_SAMPLING));
+  TraceOptions trace_options(RECORD_UNTIL_FULL);
+  trace_options.enable_sampling = true;
+  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
+                                      TraceLog::RECORDING_MODE,
+                                      trace_options);
 
   TRACE_EVENT_SCOPED_SAMPLING_STATE("AAA", "name");
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
@@ -1853,10 +1867,12 @@ TEST_F(TraceEventTestFixture, TraceSamplingScope) {
 }
 
 TEST_F(TraceEventTestFixture, TraceContinuousSampling) {
-  TraceLog::GetInstance()->SetEnabled(
-      CategoryFilter("*"),
-      base::debug::TraceLog::MONITORING_MODE,
-      TraceLog::Options(TraceLog::ENABLE_SAMPLING));
+  TraceOptions trace_options(RECORD_UNTIL_FULL);
+  trace_options.enable_sampling = true;
+
+  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
+                                      TraceLog::MONITORING_MODE,
+                                      trace_options);
 
   TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "category", "AAA");
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
@@ -1899,7 +1915,7 @@ TEST_F(TraceEventTestFixture, TraceContinuousSampling) {
   Clear();
 }
 
-class MyData : public base::debug::ConvertableToTraceFormat {
+class MyData : public ConvertableToTraceFormat {
  public:
   MyData() {}
 
@@ -1913,9 +1929,10 @@ class MyData : public base::debug::ConvertableToTraceFormat {
 };
 
 TEST_F(TraceEventTestFixture, ConvertableTypes) {
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
 
   scoped_refptr<ConvertableToTraceFormat> data(new MyData());
   scoped_refptr<ConvertableToTraceFormat> data1(new MyData());
@@ -2019,9 +2036,10 @@ TEST_F(TraceEventTestFixture, ConvertableTypes) {
 }
 
 TEST_F(TraceEventTestFixture, PrimitiveArgs) {
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
 
   TRACE_EVENT1("foo", "event1", "int_one", 1);
   TRACE_EVENT1("foo", "event2", "int_neg_ten", -10);
@@ -2282,9 +2300,10 @@ TEST_F(TraceEventCallbackTest, TraceEventCallback) {
 }
 
 TEST_F(TraceEventCallbackTest, TraceEventCallbackWhileFull) {
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   do {
     TRACE_EVENT_INSTANT0("all", "badger badger", TRACE_EVENT_SCOPE_GLOBAL);
   } while (!TraceLog::GetInstance()->BufferIsFull());
@@ -2304,9 +2323,10 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording1) {
                                                    Callback);
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("recording"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("recording"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackDisabled();
@@ -2328,9 +2348,10 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording2) {
                                                    Callback);
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("recording"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("recording"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   EndTraceAndFlush();
@@ -2348,9 +2369,10 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording2) {
 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording3) {
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("recording"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("recording"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"),
@@ -2372,9 +2394,10 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording3) {
 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording4) {
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("recording"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_UNTIL_FULL);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("recording"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions());
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"),
@@ -2397,9 +2420,10 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecordingDuration) {
                                                    Callback);
   {
     TRACE_EVENT0("callback", "duration1");
-    TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                        base::debug::TraceLog::RECORDING_MODE,
-                                        TraceLog::RECORD_UNTIL_FULL);
+    TraceLog::GetInstance()->SetEnabled(
+        CategoryFilter("*"),
+        TraceLog::RECORDING_MODE,
+        TraceOptions());
     TRACE_EVENT0("callback", "duration2");
     EndTraceAndFlush();
     TRACE_EVENT0("callback", "duration3");
@@ -2424,8 +2448,8 @@ TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecordingDuration) {
 TEST_F(TraceEventTestFixture, MAYBE_TraceBufferVectorReportFull) {
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(CategoryFilter("*"),
-      base::debug::TraceLog::RECORDING_MODE,
-      TraceLog::RECORD_UNTIL_FULL);
+                        TraceLog::RECORDING_MODE,
+                        TraceOptions());
   trace_log->logged_events_.reset(
       trace_log->CreateTraceBufferVectorOfSize(100));
   do {
@@ -2471,8 +2495,8 @@ TEST_F(TraceEventTestFixture, MAYBE_TraceBufferVectorReportFull) {
 
 TEST_F(TraceEventTestFixture, TraceBufferRingBufferGetReturnChunk) {
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_CONTINUOUSLY);
+                                      TraceLog::RECORDING_MODE,
+                                      TraceOptions(RECORD_CONTINUOUSLY));
   TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
   size_t capacity = buffer->Capacity();
   size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
@@ -2531,8 +2555,8 @@ TEST_F(TraceEventTestFixture, TraceBufferRingBufferGetReturnChunk) {
 
 TEST_F(TraceEventTestFixture, TraceBufferRingBufferHalfIteration) {
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_CONTINUOUSLY);
+                                      TraceLog::RECORDING_MODE,
+                                      TraceOptions(RECORD_CONTINUOUSLY));
   TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
   size_t capacity = buffer->Capacity();
   size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
@@ -2559,8 +2583,8 @@ TEST_F(TraceEventTestFixture, TraceBufferRingBufferHalfIteration) {
 
 TEST_F(TraceEventTestFixture, TraceBufferRingBufferFullIteration) {
   TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::RECORD_CONTINUOUSLY);
+                                      TraceLog::RECORDING_MODE,
+                                      TraceOptions(RECORD_CONTINUOUSLY));
   TraceBuffer* buffer = TraceLog::GetInstance()->trace_buffer();
   size_t capacity = buffer->Capacity();
   size_t num_chunks = capacity / TraceBufferChunk::kTraceBufferChunkSize;
@@ -2599,7 +2623,7 @@ TEST_F(TraceEventTestFixture, CategoryFilter) {
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("CategoryTest,Category2"));
 
   // Make sure that upon an empty string, we fall back to the default filter.
-  default_cf = CategoryFilter("");
+  default_cf = CategoryFilter();
   category_filter_str = default_cf.ToString();
   EXPECT_STREQ("-*Debug,-*Test", category_filter_str.c_str());
   EXPECT_TRUE(default_cf.IsCategoryGroupEnabled("not-excluded-category"));
@@ -2716,6 +2740,43 @@ TEST_F(TraceEventTestFixture, SetCurrentThreadBlocksMessageLoopBeforeTracing) {
   thread.Stop();
 }
 
+TEST_F(TraceEventTestFixture, ConvertTraceOptionsToInternalOptions) {
+  TraceLog* trace_log = TraceLog::GetInstance();
+  TraceOptions options(RECORD_UNTIL_FULL);
+  EXPECT_EQ(TraceLog::kInternalRecordUntilFull,
+            trace_log->GetInternalOptionsFromTraceOptions(options));
+
+  options.record_mode = RECORD_CONTINUOUSLY;
+  EXPECT_EQ(TraceLog::kInternalRecordContinuously,
+            trace_log->GetInternalOptionsFromTraceOptions(options));
+
+  options.record_mode = ECHO_TO_CONSOLE;
+  EXPECT_EQ(TraceLog::kInternalEchoToConsole,
+            trace_log->GetInternalOptionsFromTraceOptions(options));
+
+  options.enable_sampling = true;
+
+  options.record_mode = RECORD_UNTIL_FULL;
+  EXPECT_EQ(
+      TraceLog::kInternalRecordUntilFull | TraceLog::kInternalEnableSampling,
+      trace_log->GetInternalOptionsFromTraceOptions(options));
+
+  options.record_mode = RECORD_CONTINUOUSLY;
+  EXPECT_EQ(
+      TraceLog::kInternalRecordContinuously | TraceLog::kInternalEnableSampling,
+      trace_log->GetInternalOptionsFromTraceOptions(options));
+
+  options.record_mode = ECHO_TO_CONSOLE;
+  EXPECT_EQ(
+      TraceLog::kInternalEchoToConsole | TraceLog::kInternalEnableSampling,
+      trace_log->GetInternalOptionsFromTraceOptions(options));
+
+  options.enable_systrace = true;
+  EXPECT_EQ(
+      TraceLog::kInternalEchoToConsole | TraceLog::kInternalEnableSampling,
+      trace_log->GetInternalOptionsFromTraceOptions(options));
+}
+
 void SetBlockingFlagAndBlockUntilStopped(WaitableEvent* task_start_event,
                                          WaitableEvent* task_stop_event) {
   TraceLog::GetInstance()->SetCurrentThreadBlocksMessageLoop();
@@ -2807,9 +2868,10 @@ TEST_F(TraceEventTestFixture, EchoToConsole) {
       logging::GetLogMessageHandler();
   logging::SetLogMessageHandler(MockLogMessageHandler);
 
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::ECHO_TO_CONSOLE);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions(ECHO_TO_CONSOLE));
   TRACE_EVENT_BEGIN0("a", "begin_end");
   {
     TRACE_EVENT0("b", "duration");
@@ -2843,9 +2905,10 @@ TEST_F(TraceEventTestFixture, EchoToConsoleTraceEventRecursion) {
       logging::GetLogMessageHandler();
   logging::SetLogMessageHandler(LogMessageHandlerWithTraceEvent);
 
-  TraceLog::GetInstance()->SetEnabled(CategoryFilter("*"),
-                                      base::debug::TraceLog::RECORDING_MODE,
-                                      TraceLog::ECHO_TO_CONSOLE);
+  TraceLog::GetInstance()->SetEnabled(
+      CategoryFilter("*"),
+      TraceLog::RECORDING_MODE,
+      TraceOptions(ECHO_TO_CONSOLE));
   {
     // This should not cause deadlock or infinite recursion.
     TRACE_EVENT0("b", "duration");
@@ -2932,5 +2995,76 @@ TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) {
   EXPECT_EQ(config, filter.ToString());
 }
 
+TEST(TraceOptionsTest, TraceOptionsFromString) {
+  TraceOptions options = TraceOptions("record-until-full");
+  EXPECT_EQ(RECORD_UNTIL_FULL, options.record_mode);
+  EXPECT_FALSE(options.enable_sampling);
+  EXPECT_FALSE(options.enable_systrace);
+
+  options = TraceOptions(RECORD_CONTINUOUSLY);
+  EXPECT_EQ(RECORD_CONTINUOUSLY, options.record_mode);
+  EXPECT_FALSE(options.enable_sampling);
+  EXPECT_FALSE(options.enable_systrace);
+
+  options = TraceOptions("trace-to-console");
+  EXPECT_EQ(ECHO_TO_CONSOLE, options.record_mode);
+  EXPECT_FALSE(options.enable_sampling);
+  EXPECT_FALSE(options.enable_systrace);
+
+  options = TraceOptions("record-until-full, enable-sampling");
+  EXPECT_EQ(RECORD_UNTIL_FULL, options.record_mode);
+  EXPECT_TRUE(options.enable_sampling);
+  EXPECT_FALSE(options.enable_systrace);
+
+  options = TraceOptions("enable-systrace,record-continuously");
+  EXPECT_EQ(RECORD_CONTINUOUSLY, options.record_mode);
+  EXPECT_FALSE(options.enable_sampling);
+  EXPECT_TRUE(options.enable_systrace);
+
+  options = TraceOptions("enable-systrace, trace-to-console,enable-sampling");
+  EXPECT_EQ(ECHO_TO_CONSOLE, options.record_mode);
+  EXPECT_TRUE(options.enable_sampling);
+  EXPECT_TRUE(options.enable_systrace);
+
+  options =
+      TraceOptions("record-continuously,record-until-full,trace-to-console");
+  EXPECT_EQ(ECHO_TO_CONSOLE, options.record_mode);
+  EXPECT_FALSE(options.enable_systrace);
+  EXPECT_FALSE(options.enable_sampling);
+
+  options = TraceOptions("");
+  EXPECT_EQ(RECORD_UNTIL_FULL, options.record_mode);
+  EXPECT_FALSE(options.enable_systrace);
+  EXPECT_FALSE(options.enable_sampling);
+
+#if GTEST_HAS_EXCEPTIONS
+  EXPECT_THROW(TraceOptions("foo-bar-baz"), int);
+#endif
+}
+
+TEST(TraceOptionsTest, TraceOptionsToString) {
+  // Test that we can intialize TraceOptions from a string got from
+  // TraceOptions.ToString() method to get a same TraceOptions.
+  TraceRecordMode modes[] = {
+      RECORD_UNTIL_FULL, RECORD_CONTINUOUSLY, ECHO_TO_CONSOLE};
+  bool enable_sampling_options[] = {true, false};
+  bool enable_systrace_options[] = {true, false};
+
+  for (int i = 0; i < 3; ++i) {
+    for (int j = 0; j < 2; ++j) {
+      for (int k = 0; k < 2; ++k) {
+        TraceOptions original_option = TraceOptions(modes[i]);
+        original_option.enable_sampling = enable_sampling_options[j];
+        original_option.enable_systrace = enable_systrace_options[k];
+        TraceOptions new_options = TraceOptions(original_option.ToString());
+        EXPECT_EQ(original_option.record_mode, new_options.record_mode);
+        EXPECT_EQ(original_option.enable_sampling, new_options.enable_sampling);
+        EXPECT_EQ(original_option.enable_systrace, new_options.enable_systrace);
+      }
+    }
+  }
+}
+
+
 }  // namespace debug
 }  // namespace base
diff --git a/base/test/trace_event_analyzer_unittest.cc b/base/test/trace_event_analyzer_unittest.cc
index 48a803b..a17c7e5 100644
--- a/base/test/trace_event_analyzer_unittest.cc
+++ b/base/test/trace_event_analyzer_unittest.cc
@@ -48,7 +48,7 @@ void TraceEventAnalyzerTest::BeginTracing() {
   base::debug::TraceLog::GetInstance()->SetEnabled(
       base::debug::CategoryFilter("*"),
       base::debug::TraceLog::RECORDING_MODE,
-      base::debug::TraceLog::RECORD_UNTIL_FULL);
+      base::debug::TraceOptions());
 }
 
 void TraceEventAnalyzerTest::EndTracing() {
diff --git a/chrome/browser/lifetime/application_lifetime.cc b/chrome/browser/lifetime/application_lifetime.cc
index ae04ae3..4c10890 100644
--- a/chrome/browser/lifetime/application_lifetime.cc
+++ b/chrome/browser/lifetime/application_lifetime.cc
@@ -182,7 +182,7 @@ void StartShutdownTracing() {
     base::debug::TraceLog::GetInstance()->SetEnabled(
         category_filter,
         base::debug::TraceLog::RECORDING_MODE,
-        base::debug::TraceLog::RECORD_UNTIL_FULL);
+        base::debug::TraceOptions());
   }
   TRACE_EVENT0("shutdown", "StartShutdownTracing");
 }
diff --git a/chrome/test/base/tracing.cc b/chrome/test/base/tracing.cc
index 87e6aaa..03a53f1 100644
--- a/chrome/test/base/tracing.cc
+++ b/chrome/test/base/tracing.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/test/base/tracing.h"
 
+#include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/memory/singleton.h"
@@ -32,7 +33,8 @@ class InProcessTraceController {
   bool BeginTracing(const std::string& category_patterns) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     return content::TracingController::GetInstance()->EnableRecording(
-        category_patterns, content::TracingController::DEFAULT_OPTIONS,
+        base::debug::CategoryFilter(category_patterns),
+        base::debug::TraceOptions(),
         content::TracingController::EnableRecordingDoneCallback());
   }
 
@@ -50,7 +52,8 @@ class InProcessTraceController {
       return false;
     }
     if (!content::TracingController::GetInstance()->EnableRecording(
-            category_patterns, content::TracingController::DEFAULT_OPTIONS,
+            base::debug::CategoryFilter(category_patterns),
+            base::debug::TraceOptions(),
             base::Bind(&InProcessTraceController::OnEnableTracingComplete,
                        base::Unretained(this)))) {
       return false;
diff --git a/components/feedback/tracing_manager.cc b/components/feedback/tracing_manager.cc
index 5298c2f..f35fe80 100644
--- a/components/feedback/tracing_manager.cc
+++ b/components/feedback/tracing_manager.cc
@@ -91,7 +91,8 @@ void TracingManager::DiscardTraceData(int id) {
 
 void TracingManager::StartTracing() {
   content::TracingController::GetInstance()->EnableRecording(
-      "", content::TracingController::DEFAULT_OPTIONS,
+      base::debug::CategoryFilter(),
+      base::debug::TraceOptions(),
       content::TracingController::EnableRecordingDoneCallback());
 }
 
diff --git a/components/tracing/child_trace_message_filter.cc b/components/tracing/child_trace_message_filter.cc
index 3df0f70..e3daa1a 100644
--- a/components/tracing/child_trace_message_filter.cc
+++ b/components/tracing/child_trace_message_filter.cc
@@ -50,7 +50,7 @@ ChildTraceMessageFilter::~ChildTraceMessageFilter() {}
 void ChildTraceMessageFilter::OnBeginTracing(
     const std::string& category_filter_str,
     base::TimeTicks browser_time,
-    int options) {
+    const std::string& options) {
 #if defined(__native_client__)
   // NaCl and system times are offset by a bit, so subtract some time from
   // the captured timestamps. The value might be off by a bit due to messaging
@@ -63,7 +63,7 @@ void ChildTraceMessageFilter::OnBeginTracing(
   TraceLog::GetInstance()->SetEnabled(
       base::debug::CategoryFilter(category_filter_str),
       base::debug::TraceLog::RECORDING_MODE,
-      static_cast<base::debug::TraceLog::Options>(options));
+      base::debug::TraceOptions(options));
 }
 
 void ChildTraceMessageFilter::OnEndTracing() {
@@ -80,11 +80,11 @@ void ChildTraceMessageFilter::OnEndTracing() {
 void ChildTraceMessageFilter::OnEnableMonitoring(
     const std::string& category_filter_str,
     base::TimeTicks browser_time,
-    int options) {
+    const std::string& options) {
   TraceLog::GetInstance()->SetEnabled(
       base::debug::CategoryFilter(category_filter_str),
       base::debug::TraceLog::MONITORING_MODE,
-      static_cast<base::debug::TraceLog::Options>(options));
+      base::debug::TraceOptions(options));
 }
 
 void ChildTraceMessageFilter::OnDisableMonitoring() {
diff --git a/components/tracing/child_trace_message_filter.h b/components/tracing/child_trace_message_filter.h
index 5bd993e..596e738 100644
--- a/components/tracing/child_trace_message_filter.h
+++ b/components/tracing/child_trace_message_filter.h
@@ -32,11 +32,11 @@ class ChildTraceMessageFilter : public IPC::MessageFilter {
   // Message handlers.
   void OnBeginTracing(const std::string& category_filter_str,
                       base::TimeTicks browser_time,
-                      int options);
+                      const std::string& options);
   void OnEndTracing();
   void OnEnableMonitoring(const std::string& category_filter_str,
                           base::TimeTicks browser_time,
-                          int options);
+                          const std::string& options);
   void OnDisableMonitoring();
   void OnCaptureMonitoringSnapshot();
   void OnGetTraceBufferPercentFull();
diff --git a/components/tracing/tracing_messages.h b/components/tracing/tracing_messages.h
index 0a1fdc9..ff891a0 100644
--- a/components/tracing/tracing_messages.h
+++ b/components/tracing/tracing_messages.h
@@ -19,7 +19,7 @@
 IPC_MESSAGE_CONTROL3(TracingMsg_BeginTracing,
                      std::string /*  category_filter_str */,
                      base::TimeTicks /* browser_time */,
-                     int /* base::debug::TraceLog::Options */)
+                     std::string /* base::debug::TraceOptions */)
 
 // Sent to all child processes to disable trace event recording.
 IPC_MESSAGE_CONTROL0(TracingMsg_EndTracing)
@@ -28,7 +28,7 @@ IPC_MESSAGE_CONTROL0(TracingMsg_EndTracing)
 IPC_MESSAGE_CONTROL3(TracingMsg_EnableMonitoring,
                      std::string /*  category_filter_str */,
                      base::TimeTicks /* browser_time */,
-                     int /* base::debug::TraceLog::Options */)
+                     std::string /* base::debug::TraceOptions */)
 
 // Sent to all child processes to stop monitoring.
 IPC_MESSAGE_CONTROL0(TracingMsg_DisableMonitoring)
diff --git a/content/app/android/library_loader_hooks.cc b/content/app/android/library_loader_hooks.cc
index f69933f..4778bfb 100644
--- a/content/app/android/library_loader_hooks.cc
+++ b/content/app/android/library_loader_hooks.cc
@@ -80,9 +80,10 @@ bool LibraryLoaded(JNIEnv* env, jclass clazz,
   if (command_line->HasSwitch(switches::kTraceStartup)) {
     base::debug::CategoryFilter category_filter(
         command_line->GetSwitchValueASCII(switches::kTraceStartup));
-    base::debug::TraceLog::GetInstance()->SetEnabled(category_filter,
+    base::debug::TraceLog::GetInstance()->SetEnabled(
+        category_filter,
         base::debug::TraceLog::RECORDING_MODE,
-        base::debug::TraceLog::RECORD_UNTIL_FULL);
+        base::debug::TraceOptions());
   }
 
   // Android's main browser loop is custom so we set the browser
diff --git a/content/app/content_main_runner.cc b/content/app/content_main_runner.cc
index a002013..ba132cb 100644
--- a/content/app/content_main_runner.cc
+++ b/content/app/content_main_runner.cc
@@ -633,7 +633,8 @@ class ContentMainRunnerImpl : public ContentMainRunner {
       base::debug::TraceLog::GetInstance()->SetEnabled(
           category_filter,
           base::debug::TraceLog::RECORDING_MODE,
-          base::debug::TraceLog::RECORD_UNTIL_FULL);
+          base::debug::TraceOptions(
+              base::debug::RECORD_UNTIL_FULL));
     }
 #if !defined(OS_ANDROID)
     // Android tracing started at the beginning of the method.
diff --git a/content/browser/android/tracing_controller_android.cc b/content/browser/android/tracing_controller_android.cc
index a9c5b40..f89d472d 100644
--- a/content/browser/android/tracing_controller_android.cc
+++ b/content/browser/android/tracing_controller_android.cc
@@ -32,17 +32,18 @@ void TracingControllerAndroid::Destroy(JNIEnv* env, jobject obj) {
 bool TracingControllerAndroid::StartTracing(JNIEnv* env,
                                             jobject obj,
                                             jstring jcategories,
-                                            jboolean record_continuously) {
+                                            jstring jtraceoptions) {
   std::string categories =
       base::android::ConvertJavaStringToUTF8(env, jcategories);
+  std::string trace_options =
+      base::android::ConvertJavaStringToUTF8(env, jtraceoptions);
 
   // This log is required by adb_profile_chrome.py.
   LOG(WARNING) << "Logging performance trace to file";
 
   return TracingController::GetInstance()->EnableRecording(
-      categories,
-      record_continuously ? TracingController::RECORD_CONTINUOUSLY
-                          : TracingController::DEFAULT_OPTIONS,
+      base::debug::CategoryFilter(categories),
+      base::debug::TraceOptions(trace_options),
       TracingController::EnableRecordingDoneCallback());
 }
 
diff --git a/content/browser/android/tracing_controller_android.h b/content/browser/android/tracing_controller_android.h
index ab426d7..60421b9 100644
--- a/content/browser/android/tracing_controller_android.h
+++ b/content/browser/android/tracing_controller_android.h
@@ -22,7 +22,7 @@ class TracingControllerAndroid {
   bool StartTracing(JNIEnv* env,
                     jobject obj,
                     jstring categories,
-                    jboolean record_continuously);
+                    jstring trace_options);
   void StopTracing(JNIEnv* env, jobject obj, jstring jfilepath);
   bool GetKnownCategoryGroupsAsync(JNIEnv* env, jobject obj);
   static void GenerateTracingFilePath(base::FilePath* file_path);
diff --git a/content/browser/devtools/devtools_tracing_handler.cc b/content/browser/devtools/devtools_tracing_handler.cc
index 9b1f8e7..19abb63 100644
--- a/content/browser/devtools/devtools_tracing_handler.cc
+++ b/content/browser/devtools/devtools_tracing_handler.cc
@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/debug/trace_event_impl.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ -128,23 +129,23 @@ void DevToolsTracingHandler::OnTraceDataCollected(
   SendRawMessage(message);
 }
 
-TracingController::Options DevToolsTracingHandler::TraceOptionsFromString(
+base::debug::TraceOptions DevToolsTracingHandler::TraceOptionsFromString(
     const std::string& options) {
   std::vector<std::string> split;
   std::vector<std::string>::iterator iter;
-  int ret = 0;
+  base::debug::TraceOptions ret;
 
   base::SplitString(options, ',', &split);
   for (iter = split.begin(); iter != split.end(); ++iter) {
     if (*iter == kRecordUntilFull) {
-      ret &= ~TracingController::RECORD_CONTINUOUSLY;
+      ret.record_mode = base::debug::RECORD_UNTIL_FULL;
     } else if (*iter == kRecordContinuously) {
-      ret |= TracingController::RECORD_CONTINUOUSLY;
+      ret.record_mode = base::debug::RECORD_CONTINUOUSLY;
     } else if (*iter == kEnableSampling) {
-      ret |= TracingController::ENABLE_SAMPLING;
+      ret.enable_sampling = true;
     }
   }
-  return static_cast<TracingController::Options>(ret);
+  return ret;
 }
 
 scoped_refptr<DevToolsProtocol::Response>
@@ -153,7 +154,7 @@ DevToolsTracingHandler::OnStart(
   is_recording_ = true;
 
   std::string categories;
-  TracingController::Options options = TracingController::DEFAULT_OPTIONS;
+  base::debug::TraceOptions options;
   double usage_reporting_interval = 0.0;
 
   base::DictionaryValue* params = command->params();
@@ -175,12 +176,15 @@ DevToolsTracingHandler::OnStart(
   // tracing agent in the renderer.
   if (target_ == Renderer) {
     TracingController::GetInstance()->EnableRecording(
-        categories, options, TracingController::EnableRecordingDoneCallback());
+        base::debug::CategoryFilter(categories),
+        options,
+        TracingController::EnableRecordingDoneCallback());
     return NULL;
   }
 
   TracingController::GetInstance()->EnableRecording(
-      categories, options,
+      base::debug::CategoryFilter(categories),
+      options,
       base::Bind(&DevToolsTracingHandler::OnRecordingEnabled,
                  weak_factory_.GetWeakPtr(),
                  command));
@@ -274,8 +278,8 @@ void DevToolsTracingHandler::OnTracingStarted(
   SetupTimer(kDefaultReportingInterval);
 
   TracingController::GetInstance()->EnableRecording(
-      kDefaultCategories,
-      TracingController::DEFAULT_OPTIONS,
+      base::debug::CategoryFilter(kDefaultCategories),
+      base::debug::TraceOptions(),
       TracingController::EnableRecordingDoneCallback());
 }
 
diff --git a/content/browser/devtools/devtools_tracing_handler.h b/content/browser/devtools/devtools_tracing_handler.h
index ec48d05..20ebca8 100644
--- a/content/browser/devtools/devtools_tracing_handler.h
+++ b/content/browser/devtools/devtools_tracing_handler.h
@@ -8,6 +8,7 @@
 #include <set>
 #include <string>
 
+#include "base/debug/trace_event.h"
 #include "base/memory/weak_ptr.h"
 #include "content/browser/devtools/devtools_protocol.h"
 #include "content/public/browser/tracing_controller.h"
@@ -53,7 +54,7 @@ class DevToolsTracingHandler : public DevToolsProtocol::Handler {
   void OnCategoriesReceived(scoped_refptr<DevToolsProtocol::Command> command,
                             const std::set<std::string>& category_set);
 
-  TracingController::Options TraceOptionsFromString(const std::string& options);
+  base::debug::TraceOptions TraceOptionsFromString(const std::string& options);
 
   void SetupTimer(double usage_reporting_interval);
 
diff --git a/content/browser/media/webrtc_getusermedia_browsertest.cc b/content/browser/media/webrtc_getusermedia_browsertest.cc
index 8af8f45..9efa23e 100644
--- a/content/browser/media/webrtc_getusermedia_browsertest.cc
+++ b/content/browser/media/webrtc_getusermedia_browsertest.cc
@@ -83,9 +83,11 @@ class WebRtcGetUserMediaBrowserTest: public WebRtcContentBrowserTest {
   void StartTracing() {
     CHECK(trace_log_ == NULL) << "Can only can start tracing once";
     trace_log_ = base::debug::TraceLog::GetInstance();
+    base::debug::TraceOptions trace_options(base::debug::RECORD_UNTIL_FULL);
+    trace_options.enable_sampling = true;
     trace_log_->SetEnabled(base::debug::CategoryFilter("video"),
                            base::debug::TraceLog::RECORDING_MODE,
-                           base::debug::TraceLog::ENABLE_SAMPLING);
+                           trace_options);
     // Check that we are indeed recording.
     EXPECT_EQ(trace_log_->GetNumTracesRecorded(), 1);
   }
diff --git a/content/browser/tracing/trace_message_filter.cc b/content/browser/tracing/trace_message_filter.cc
index ba8ec65..e74ca96 100644
--- a/content/browser/tracing/trace_message_filter.cc
+++ b/content/browser/tracing/trace_message_filter.cc
@@ -57,12 +57,12 @@ bool TraceMessageFilter::OnMessageReceived(const IPC::Message& message) {
 }
 
 void TraceMessageFilter::SendBeginTracing(
-    const std::string& category_filter_str,
-    base::debug::TraceLog::Options options) {
+    const base::debug::CategoryFilter& category_filter,
+    const base::debug::TraceOptions& options) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  Send(new TracingMsg_BeginTracing(category_filter_str,
+  Send(new TracingMsg_BeginTracing(category_filter.ToString(),
                                    base::TimeTicks::NowFromSystemTraceTime(),
-                                   options));
+                                   options.ToString()));
 }
 
 void TraceMessageFilter::SendEndTracing() {
@@ -73,12 +73,12 @@ void TraceMessageFilter::SendEndTracing() {
 }
 
 void TraceMessageFilter::SendEnableMonitoring(
-    const std::string& category_filter_str,
-    base::debug::TraceLog::Options options) {
+    const base::debug::CategoryFilter& category_filter,
+    const base::debug::TraceOptions& options) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  Send(new TracingMsg_EnableMonitoring(category_filter_str,
+  Send(new TracingMsg_EnableMonitoring(category_filter.ToString(),
       base::TimeTicks::NowFromSystemTraceTime(),
-      options));
+      options.ToString()));
 }
 
 void TraceMessageFilter::SendDisableMonitoring() {
diff --git a/content/browser/tracing/trace_message_filter.h b/content/browser/tracing/trace_message_filter.h
index 4233fe0..8e13989 100644
--- a/content/browser/tracing/trace_message_filter.h
+++ b/content/browser/tracing/trace_message_filter.h
@@ -24,11 +24,11 @@ class TraceMessageFilter : public BrowserMessageFilter {
   virtual void OnChannelClosing() OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
-  void SendBeginTracing(const std::string& category_filter_str,
-                        base::debug::TraceLog::Options options);
+  void SendBeginTracing(const base::debug::CategoryFilter& category_filter_str,
+                        const base::debug::TraceOptions& options);
   void SendEndTracing();
-  void SendEnableMonitoring(const std::string& category_filter_str,
-                            base::debug::TraceLog::Options options);
+  void SendEnableMonitoring(const base::debug::CategoryFilter& category_filter,
+                            const base::debug::TraceOptions& options);
   void SendDisableMonitoring();
   void SendCaptureMonitoringSnapshot();
   void SendGetTraceBufferPercentFull();
diff --git a/content/browser/tracing/tracing_controller_browsertest.cc b/content/browser/tracing/tracing_controller_browsertest.cc
index de41b20..85c2908 100644
--- a/content/browser/tracing/tracing_controller_browsertest.cc
+++ b/content/browser/tracing/tracing_controller_browsertest.cc
@@ -10,6 +10,11 @@
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 
+using base::debug::CategoryFilter;
+using base::debug::TraceOptions;
+using base::debug::RECORD_CONTINUOUSLY;
+using base::debug::RECORD_UNTIL_FULL;
+
 namespace content {
 
 class TracingControllerTest : public ContentBrowserTest {
@@ -122,7 +127,7 @@ class TracingControllerTest : public ContentBrowserTest {
                      base::Unretained(this),
                      run_loop.QuitClosure());
       bool result = controller->EnableRecording(
-          "", TracingController::DEFAULT_OPTIONS, callback);
+          CategoryFilter(), TraceOptions(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
@@ -149,16 +154,15 @@ class TracingControllerTest : public ContentBrowserTest {
 
     {
       bool is_monitoring;
-      std::string category_filter;
-      TracingController::Options options;
-      controller->GetMonitoringStatus(&is_monitoring,
-                                      &category_filter,
-                                      &options);
+      CategoryFilter category_filter("");
+      TraceOptions options;
+      controller->GetMonitoringStatus(
+          &is_monitoring, &category_filter, &options);
       EXPECT_FALSE(is_monitoring);
-      EXPECT_EQ("-*Debug,-*Test", category_filter);
-      EXPECT_FALSE(options & TracingController::ENABLE_SYSTRACE);
-      EXPECT_FALSE(options & TracingController::RECORD_CONTINUOUSLY);
-      EXPECT_FALSE(options & TracingController::ENABLE_SAMPLING);
+      EXPECT_EQ("-*Debug,-*Test", category_filter.ToString());
+      EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
+      EXPECT_FALSE(options.enable_sampling);
+      EXPECT_FALSE(options.enable_systrace);
     }
 
     {
@@ -167,8 +171,14 @@ class TracingControllerTest : public ContentBrowserTest {
           base::Bind(&TracingControllerTest::EnableMonitoringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
+
+      TraceOptions trace_options;
+      trace_options.enable_sampling = true;
+
       bool result = controller->EnableMonitoring(
-          "*", TracingController::ENABLE_SAMPLING, callback);
+          CategoryFilter("*"),
+          trace_options,
+          callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_monitoring_done_callback_count(), 1);
@@ -176,16 +186,15 @@ class TracingControllerTest : public ContentBrowserTest {
 
     {
       bool is_monitoring;
-      std::string category_filter;
-      TracingController::Options options;
-      controller->GetMonitoringStatus(&is_monitoring,
-                                      &category_filter,
-                                      &options);
+      CategoryFilter category_filter("");
+      TraceOptions options;
+      controller->GetMonitoringStatus(
+          &is_monitoring, &category_filter, &options);
       EXPECT_TRUE(is_monitoring);
-      EXPECT_EQ("*", category_filter);
-      EXPECT_FALSE(options & TracingController::ENABLE_SYSTRACE);
-      EXPECT_FALSE(options & TracingController::RECORD_CONTINUOUSLY);
-      EXPECT_TRUE(options & TracingController::ENABLE_SAMPLING);
+      EXPECT_EQ("*", category_filter.ToString());
+      EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
+      EXPECT_TRUE(options.enable_sampling);
+      EXPECT_FALSE(options.enable_systrace);
     }
 
     {
@@ -215,16 +224,16 @@ class TracingControllerTest : public ContentBrowserTest {
 
     {
       bool is_monitoring;
-      std::string category_filter;
-      TracingController::Options options;
+      CategoryFilter category_filter("");
+      TraceOptions options;
       controller->GetMonitoringStatus(&is_monitoring,
                                       &category_filter,
                                       &options);
       EXPECT_FALSE(is_monitoring);
-      EXPECT_EQ("", category_filter);
-      EXPECT_FALSE(options & TracingController::ENABLE_SYSTRACE);
-      EXPECT_FALSE(options & TracingController::RECORD_CONTINUOUSLY);
-      EXPECT_FALSE(options & TracingController::ENABLE_SAMPLING);
+      EXPECT_EQ("", category_filter.ToString());
+      EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
+      EXPECT_FALSE(options.enable_sampling);
+      EXPECT_FALSE(options.enable_systrace);
     }
   }
 
@@ -272,7 +281,8 @@ IN_PROC_BROWSER_TEST_F(TracingControllerTest,
 
   TracingController* controller = TracingController::GetInstance();
   EXPECT_TRUE(controller->EnableRecording(
-      "", TracingController::DEFAULT_OPTIONS,
+      CategoryFilter(),
+      TraceOptions(),
       TracingController::EnableRecordingDoneCallback()));
   EXPECT_TRUE(controller->DisableRecording(
       base::FilePath(), TracingController::TracingFileResultCallback()));
@@ -306,8 +316,11 @@ IN_PROC_BROWSER_TEST_F(
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
+  TraceOptions trace_options;
+  trace_options.enable_sampling = true;
   EXPECT_TRUE(controller->EnableMonitoring(
-      "*", TracingController::ENABLE_SAMPLING,
+      CategoryFilter("*"),
+      trace_options,
       TracingController::EnableMonitoringDoneCallback()));
   controller->CaptureMonitoringSnapshot(
       base::FilePath(), TracingController::TracingFileResultCallback());
diff --git a/content/browser/tracing/tracing_controller_impl.cc b/content/browser/tracing/tracing_controller_impl.cc
index 0db1405..5fe4d2f 100644
--- a/content/browser/tracing/tracing_controller_impl.cc
+++ b/content/browser/tracing/tracing_controller_impl.cc
@@ -24,6 +24,8 @@
 #endif
 
 using base::debug::TraceLog;
+using base::debug::TraceOptions;
+using base::debug::CategoryFilter;
 
 namespace content {
 
@@ -191,8 +193,8 @@ bool TracingControllerImpl::GetCategories(
   // message. So to get known categories, just begin and end tracing immediately
   // afterwards. This will ping all the child processes for categories.
   pending_get_categories_done_callback_ = callback;
-  if (!EnableRecording("*", TracingController::Options(),
-                       EnableRecordingDoneCallback())) {
+  if (!EnableRecording(
+          CategoryFilter("*"), TraceOptions(), EnableRecordingDoneCallback())) {
     pending_get_categories_done_callback_.Reset();
     return false;
   }
@@ -203,16 +205,14 @@ bool TracingControllerImpl::GetCategories(
 }
 
 void TracingControllerImpl::SetEnabledOnFileThread(
-    const std::string& category_filter,
+    const CategoryFilter& category_filter,
     int mode,
-    int trace_options,
+    const TraceOptions& trace_options,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   TraceLog::GetInstance()->SetEnabled(
-      base::debug::CategoryFilter(category_filter),
-      static_cast<TraceLog::Mode>(mode),
-      static_cast<TraceLog::Options>(trace_options));
+      category_filter, static_cast<TraceLog::Mode>(mode), trace_options);
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
@@ -225,8 +225,8 @@ void TracingControllerImpl::SetDisabledOnFileThread(
 }
 
 bool TracingControllerImpl::EnableRecording(
-    const std::string& category_filter,
-    TracingController::Options options,
+    const CategoryFilter& category_filter,
+    const TraceOptions& trace_options,
     const EnableRecordingDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ -239,14 +239,9 @@ bool TracingControllerImpl::EnableRecording(
     TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
-  options_ = options;
-  int trace_options = (options & RECORD_CONTINUOUSLY) ?
-      TraceLog::RECORD_CONTINUOUSLY : TraceLog::RECORD_UNTIL_FULL;
-  if (options & ENABLE_SAMPLING) {
-    trace_options |= TraceLog::ENABLE_SAMPLING;
-  }
+  trace_options_ = trace_options;
 
-  if (options & ENABLE_SYSTRACE) {
+  if (trace_options.enable_systrace) {
 #if defined(OS_CHROMEOS)
     DCHECK(!is_system_tracing_);
     chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->
@@ -275,16 +270,15 @@ bool TracingControllerImpl::EnableRecording(
 }
 
 void TracingControllerImpl::OnEnableRecordingDone(
-    const std::string& category_filter,
-    int trace_options,
+    const CategoryFilter& category_filter,
+    const TraceOptions& trace_options,
     const EnableRecordingDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Notify all child processes.
   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
       it != trace_message_filters_.end(); ++it) {
-    it->get()->SendBeginTracing(category_filter,
-                                static_cast<TraceLog::Options>(trace_options));
+    it->get()->SendBeginTracing(category_filter, trace_options);
   }
 
   if (!callback.is_null())
@@ -299,7 +293,7 @@ bool TracingControllerImpl::DisableRecording(
   if (!can_disable_recording())
     return false;
 
-  options_ = TracingController::Options();
+  trace_options_ = TraceOptions();
   // Disable local trace early to avoid traces during end-tracing process from
   // interfering with the process.
   base::Closure on_disable_recording_done_callback =
@@ -374,8 +368,8 @@ void TracingControllerImpl::OnDisableRecordingDone(
 }
 
 bool TracingControllerImpl::EnableMonitoring(
-    const std::string& category_filter,
-    TracingController::Options options,
+    const CategoryFilter& category_filter,
+    const TraceOptions& trace_options,
     const EnableMonitoringDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ -387,10 +381,7 @@ bool TracingControllerImpl::EnableMonitoring(
   TraceLog::GetInstance()->AddClockSyncMetadataEvent();
 #endif
 
-  options_ = options;
-  int trace_options = 0;
-  if (options & ENABLE_SAMPLING)
-    trace_options |= TraceLog::ENABLE_SAMPLING;
+  trace_options_ = trace_options;
 
   base::Closure on_enable_monitoring_done_callback =
       base::Bind(&TracingControllerImpl::OnEnableMonitoringDone,
@@ -407,16 +398,15 @@ bool TracingControllerImpl::EnableMonitoring(
 }
 
 void TracingControllerImpl::OnEnableMonitoringDone(
-    const std::string& category_filter,
-    int trace_options,
+    const CategoryFilter& category_filter,
+    const TraceOptions& trace_options,
     const EnableMonitoringDoneCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Notify all child processes.
   for (TraceMessageFilterSet::iterator it = trace_message_filters_.begin();
       it != trace_message_filters_.end(); ++it) {
-    it->get()->SendEnableMonitoring(category_filter,
-        static_cast<TraceLog::Options>(trace_options));
+    it->get()->SendEnableMonitoring(category_filter, trace_options);
   }
 
   if (!callback.is_null())
@@ -430,7 +420,7 @@ bool TracingControllerImpl::DisableMonitoring(
   if (!can_disable_monitoring())
     return false;
 
-  options_ = TracingController::Options();
+  trace_options_ = TraceOptions();
   base::Closure on_disable_monitoring_done_callback =
       base::Bind(&TracingControllerImpl::OnDisableMonitoringDone,
                  base::Unretained(this), callback);
@@ -459,12 +449,11 @@ void TracingControllerImpl::OnDisableMonitoringDone(
 
 void TracingControllerImpl::GetMonitoringStatus(
     bool* out_enabled,
-    std::string* out_category_filter,
-    TracingController::Options* out_options) {
+    CategoryFilter* out_category_filter,
+    TraceOptions* out_trace_options) {
   *out_enabled = is_monitoring_;
-  *out_category_filter =
-      TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString();
-  *out_options = options_;
+  *out_category_filter = TraceLog::GetInstance()->GetCurrentCategoryFilter();
+  *out_trace_options = trace_options_;
 }
 
 bool TracingControllerImpl::CaptureMonitoringSnapshot(
@@ -599,13 +588,13 @@ void TracingControllerImpl::AddTraceMessageFilter(
   }
   if (can_disable_recording()) {
     trace_message_filter->SendBeginTracing(
-        TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString(),
-        TraceLog::GetInstance()->trace_options());
+        TraceLog::GetInstance()->GetCurrentCategoryFilter(),
+        TraceLog::GetInstance()->GetCurrentTraceOptions());
   }
   if (can_disable_monitoring()) {
     trace_message_filter->SendEnableMonitoring(
-        TraceLog::GetInstance()->GetCurrentCategoryFilter().ToString(),
-        TraceLog::GetInstance()->trace_options());
+        TraceLog::GetInstance()->GetCurrentCategoryFilter(),
+        TraceLog::GetInstance()->GetCurrentTraceOptions());
   }
 }
 
diff --git a/content/browser/tracing/tracing_controller_impl.h b/content/browser/tracing/tracing_controller_impl.h
index d4d5722..bd4aaa1 100644
--- a/content/browser/tracing/tracing_controller_impl.h
+++ b/content/browser/tracing/tracing_controller_impl.h
@@ -30,21 +30,22 @@ class TracingControllerImpl : public TracingController {
   virtual bool GetCategories(
       const GetCategoriesDoneCallback& callback) OVERRIDE;
   virtual bool EnableRecording(
-      const std::string& category_filter,
-      TracingController::Options options,
+      const base::debug::CategoryFilter& category_filter,
+      const base::debug::TraceOptions& trace_options,
       const EnableRecordingDoneCallback& callback) OVERRIDE;
   virtual bool DisableRecording(
       const base::FilePath& result_file_path,
       const TracingFileResultCallback& callback) OVERRIDE;
-  virtual bool EnableMonitoring(const std::string& category_filter,
-      TracingController::Options options,
+  virtual bool EnableMonitoring(
+      const base::debug::CategoryFilter& category_filter,
+      const base::debug::TraceOptions& trace_options,
       const EnableMonitoringDoneCallback& callback) OVERRIDE;
   virtual bool DisableMonitoring(
       const DisableMonitoringDoneCallback& callback) OVERRIDE;
   virtual void GetMonitoringStatus(
       bool* out_enabled,
-      std::string* out_category_filter,
-      TracingController::Options* out_options) OVERRIDE;
+      base::debug::CategoryFilter* out_category_filter,
+      base::debug::TraceOptions* out_trace_options) OVERRIDE;
   virtual bool CaptureMonitoringSnapshot(
       const base::FilePath& result_file_path,
       const TracingFileResultCallback& callback) OVERRIDE;
@@ -131,19 +132,21 @@ class TracingControllerImpl : public TracingController {
 
   void OnWatchEventMatched();
 
-  void SetEnabledOnFileThread(const std::string& category_filter,
-                              int mode,
-                              int options,
-                              const base::Closure& callback);
+  void SetEnabledOnFileThread(
+      const base::debug::CategoryFilter& category_filter,
+      int mode,
+      const base::debug::TraceOptions& trace_options,
+      const base::Closure& callback);
   void SetDisabledOnFileThread(const base::Closure& callback);
-  void OnEnableRecordingDone(const std::string& category_filter,
-                             int trace_options,
+  void OnEnableRecordingDone(const base::debug::CategoryFilter& category_filter,
+                             const base::debug::TraceOptions& trace_options,
                              const EnableRecordingDoneCallback& callback);
   void OnDisableRecordingDone(const base::FilePath& result_file_path,
                               const TracingFileResultCallback& callback);
-  void OnEnableMonitoringDone(const std::string& category_filter,
-                              int trace_options,
-                              const EnableMonitoringDoneCallback& callback);
+  void OnEnableMonitoringDone(
+      const base::debug::CategoryFilter& category_filter,
+      const base::debug::TraceOptions& trace_options,
+      const EnableMonitoringDoneCallback& callback);
   void OnDisableMonitoringDone(const DisableMonitoringDoneCallback& callback);
 
   void OnMonitoringStateChanged(bool is_monitoring);
@@ -166,7 +169,7 @@ class TracingControllerImpl : public TracingController {
 #endif
   bool is_recording_;
   bool is_monitoring_;
-  TracingController::Options options_;
+  base::debug::TraceOptions trace_options_;
 
   GetCategoriesDoneCallback pending_get_categories_done_callback_;
   TracingFileResultCallback pending_disable_recording_done_callback_;
diff --git a/content/browser/tracing/tracing_ui.cc b/content/browser/tracing/tracing_ui.cc
index 3edcd18..d977d21 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"
@@ -54,8 +55,8 @@ void OnGotCategories(const WebUIDataSource::GotDataCallback& callback,
 }
 
 bool GetTracingOptions(const std::string& data64,
-                       std::string* category_filter_string,
-                       int* tracing_options) {
+                       base::debug::CategoryFilter* category_filter,
+                       base::debug::TraceOptions* tracing_options) {
   std::string data;
   if (!base::Base64Decode(data64, &data)) {
     LOG(ERROR) << "Options were not base64 encoded.";
@@ -73,28 +74,39 @@ bool GetTracingOptions(const std::string& data64,
     return false;
   }
 
-  bool use_system_tracing;
-  bool use_continuous_tracing;
-  bool use_sampling;
+  if (!category_filter) {
+    LOG(ERROR) << "category_filter can't be passed as NULL";
+    return false;
+  }
+
+  if (!tracing_options) {
+    LOG(ERROR) << "tracing_options can't be passed as NULL";
+    return false;
+  }
 
   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);
+  std::string category_filter_string;
+  options_ok &= options->GetString("categoryFilter", &category_filter_string);
+  *category_filter = base::debug::CategoryFilter(category_filter_string);
+
+  options_ok &= options->GetBoolean("useSystemTracing",
+                                    &tracing_options->enable_systrace);
+  options_ok &=
+      options->GetBoolean("useSampling", &tracing_options->enable_sampling);
+
+  bool use_continuous_tracing;
+  options_ok &=
+      options->GetBoolean("useContinuousTracing", &use_continuous_tracing);
+
+  if (use_continuous_tracing)
+    tracing_options->record_mode = base::debug::RECORD_CONTINUOUSLY;
+  else
+    tracing_options->record_mode = base::debug::RECORD_UNTIL_FULL;
+
   if (!options_ok) {
     LOG(ERROR) << "Malformed options";
     return false;
   }
-
-  *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;
   return true;
 }
 
@@ -102,14 +114,14 @@ 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::CategoryFilter category_filter("");
+  base::debug::TraceOptions tracing_options;
+  if (!GetTracingOptions(data64, &category_filter, &tracing_options))
     return false;
 
   return TracingController::GetInstance()->EnableRecording(
-      category_filter_string,
-      static_cast<TracingController::Options>(tracing_options),
+      category_filter,
+      tracing_options,
       base::Bind(&OnRecordingEnabledAck, callback));
 }
 
@@ -145,14 +157,14 @@ 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;
+  base::debug::CategoryFilter category_filter("");
+  if (!GetTracingOptions(data64, &category_filter, &tracing_options))
     return false;
 
   return TracingController::GetInstance()->EnableMonitoring(
-      category_filter_string,
-      static_cast<TracingController::Options>(tracing_options),
+      category_filter,
+      tracing_options,
       base::Bind(OnMonitoringEnabledAck, callback));
 }
 
@@ -168,21 +180,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::CategoryFilter category_filter("");
+  base::debug::TraceOptions options;
   TracingController::GetInstance()->GetMonitoringStatus(
       &is_monitoring, &category_filter, &options);
 
   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->SetString("categoryFilter", category_filter.ToString());
+  monitoring_options->SetBoolean("useSystemTracing", options.enable_systrace);
+  monitoring_options->SetBoolean(
+      "useContinuousTracing",
+      options.record_mode == base::debug::RECORD_CONTINUOUSLY);
+  monitoring_options->SetBoolean("useSampling", options.enable_sampling);
 
   std::string monitoring_options_json;
   base::JSONWriter::Write(monitoring_options.get(), &monitoring_options_json);
diff --git a/content/common/gpu/client/gl_helper_unittest.cc b/content/common/gpu/client/gl_helper_unittest.cc
index 44ab118..f2a148e 100644
--- a/content/common/gpu/client/gl_helper_unittest.cc
+++ b/content/common/gpu/client/gl_helper_unittest.cc
@@ -77,7 +77,8 @@ class GLHelperTest : public testing::Test {
     base::debug::TraceLog::GetInstance()->SetEnabled(
         base::debug::CategoryFilter(filter),
         base::debug::TraceLog::RECORDING_MODE,
-        base::debug::TraceLog::RECORD_UNTIL_FULL);
+        base::debug::TraceOptions(
+            base::debug::RECORD_UNTIL_FULL));
   }
 
   static void TraceDataCB(
diff --git a/content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java b/content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java
index 514ab6a..0f5122b4 100644
--- a/content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java
+++ b/content/public/android/java/src/org/chromium/content/browser/TracingControllerAndroid.java
@@ -143,11 +143,10 @@ public class TracingControllerAndroid {
     /**
      * Start profiling to a new file in the Downloads directory.
      *
-     * Calls #startTracing(String, boolean, String, boolean) with a new timestamped filename.
-     * @see #startTracing(String, boolean, String, boolean)
+     * Calls #startTracing(String, boolean, String, String) with a new timestamped filename.
+     * @see #startTracing(String, boolean, String, String)
      */
-    public boolean startTracing(boolean showToasts, String categories,
-            boolean recordContinuously) {
+    public boolean startTracing(boolean showToasts, String categories, String traceOptions) {
         mShowToasts = showToasts;
 
         String filePath = generateTracingFilePath();
@@ -155,7 +154,7 @@ public class TracingControllerAndroid {
           logAndToastError(
               mContext.getString(R.string.profiler_no_storage_toast));
         }
-        return startTracing(filePath, showToasts, categories, recordContinuously);
+        return startTracing(filePath, showToasts, categories, traceOptions);
     }
 
     private void initializeNativeControllerIfNeeded() {
@@ -177,11 +176,12 @@ public class TracingControllerAndroid {
      * notifications about the profiling system.
      * @param categories Which categories to trace. See TracingControllerAndroid::BeginTracing()
      * (in content/public/browser/trace_controller.h) for the format.
-     * @param recordContinuously Record until the user ends the trace. The trace buffer is fixed
-     * size and we use it as a ring buffer during recording.
+     * @param traceOptions Which trace options to use. See
+     * TraceOptions::TraceOptions(const std::string& options_string)
+     * (in base/debug/trace_event_impl.h) for the format.
      */
     public boolean startTracing(String filename, boolean showToasts, String categories,
-            boolean recordContinuously) {
+            String traceOptions) {
         mShowToasts = showToasts;
         if (isTracing()) {
             // Don't need a toast because this shouldn't happen via the UI.
@@ -191,7 +191,7 @@ public class TracingControllerAndroid {
         // Lazy initialize the native side, to allow construction before the library is loaded.
         initializeNativeControllerIfNeeded();
         if (!nativeStartTracing(mNativeTracingControllerAndroid, categories,
-                recordContinuously)) {
+                traceOptions.toString())) {
             logAndToastError(mContext.getString(R.string.profiler_error_toast));
             return false;
         }
@@ -290,13 +290,14 @@ public class TracingControllerAndroid {
                     categories = categories.replaceFirst(
                             DEFAULT_CHROME_CATEGORIES_PLACE_HOLDER, nativeGetDefaultCategories());
                 }
-                boolean recordContinuously =
-                        intent.getStringExtra(RECORD_CONTINUOUSLY_EXTRA) != null;
+                String traceOptions =
+                        intent.getStringExtra(RECORD_CONTINUOUSLY_EXTRA) == null ?
+                        "record-until-full" : "record-continuously";
                 String filename = intent.getStringExtra(FILE_EXTRA);
                 if (filename != null) {
-                    startTracing(filename, true, categories, recordContinuously);
+                    startTracing(filename, true, categories, traceOptions);
                 } else {
-                    startTracing(true, categories, recordContinuously);
+                    startTracing(true, categories, traceOptions);
                 }
             } else if (intent.getAction().endsWith(ACTION_STOP)) {
                 stopTracing();
@@ -312,7 +313,7 @@ public class TracingControllerAndroid {
     private native long nativeInit();
     private native void nativeDestroy(long nativeTracingControllerAndroid);
     private native boolean nativeStartTracing(
-            long nativeTracingControllerAndroid, String categories, boolean recordContinuously);
+            long nativeTracingControllerAndroid, String categories, String traceOptions);
     private native void nativeStopTracing(long nativeTracingControllerAndroid, String filename);
     private native boolean nativeGetKnownCategoryGroupsAsync(long nativeTracingControllerAndroid);
     private native String nativeGetDefaultCategories();
diff --git a/content/public/android/javatests/src/org/chromium/content/browser/TracingControllerAndroidTest.java b/content/public/android/javatests/src/org/chromium/content/browser/TracingControllerAndroidTest.java
index 72d6c68..9810e90 100644
--- a/content/public/android/javatests/src/org/chromium/content/browser/TracingControllerAndroidTest.java
+++ b/content/public/android/javatests/src/org/chromium/content/browser/TracingControllerAndroidTest.java
@@ -33,7 +33,8 @@ public class TracingControllerAndroidTest extends ContentShellTestBase {
         ThreadUtils.runOnUiThreadBlocking(new Runnable() {
             @Override
             public void run() {
-                assertTrue(tracingController.startTracing(true, "*", false));
+                assertTrue(tracingController.startTracing(
+                    true, "*", "record-until-full"));
             }
         });
 
diff --git a/content/public/browser/tracing_controller.h b/content/public/browser/tracing_controller.h
index 68184a5..67a28cd 100644
--- a/content/public/browser/tracing_controller.h
+++ b/content/public/browser/tracing_controller.h
@@ -9,6 +9,7 @@
 #include <string>
 
 #include "base/callback.h"
+#include "base/debug/trace_event.h"
 #include "content/common/content_export.h"
 
 namespace base {
@@ -25,12 +26,6 @@ class TracingController;
 // the UI thread.
 class TracingController {
  public:
-  enum Options {
-    DEFAULT_OPTIONS = 0,
-    ENABLE_SYSTRACE = 1 << 0,
-    ENABLE_SAMPLING = 1 << 1,
-    RECORD_CONTINUOUSLY = 1 << 2,  // For EnableRecording() only.
-  };
 
   CONTENT_EXPORT static TracingController* GetInstance();
 
@@ -65,8 +60,8 @@ class TracingController {
   // |options| controls what kind of tracing is enabled.
   typedef base::Callback<void()> EnableRecordingDoneCallback;
   virtual bool EnableRecording(
-      const std::string& category_filter,
-      TracingController::Options options,
+      const base::debug::CategoryFilter& category_filter,
+      const base::debug::TraceOptions& trace_options,
       const EnableRecordingDoneCallback& callback) = 0;
 
   // Stop recording on all processes.
@@ -105,8 +100,8 @@ class TracingController {
   // |options| controls what kind of tracing is enabled.
   typedef base::Callback<void()> EnableMonitoringDoneCallback;
   virtual bool EnableMonitoring(
-      const std::string& category_filter,
-      TracingController::Options options,
+      const base::debug::CategoryFilter& category_filter,
+      const base::debug::TraceOptions& trace_options,
       const EnableMonitoringDoneCallback& callback) = 0;
 
   // Stop monitoring on all processes.
@@ -118,9 +113,10 @@ class TracingController {
       const DisableMonitoringDoneCallback& callback) = 0;
 
   // Get the current monitoring configuration.
-  virtual void GetMonitoringStatus(bool* out_enabled,
-                                   std::string* out_category_filter,
-                                   TracingController::Options* out_options) = 0;
+  virtual void GetMonitoringStatus(
+      bool* out_enabled,
+      base::debug::CategoryFilter* out_category_filter,
+      base::debug::TraceOptions* out_trace_options) = 0;
 
   // Get the current monitoring traced data.
   //
diff --git a/content/renderer/devtools/devtools_agent.cc b/content/renderer/devtools/devtools_agent.cc
index a3c37b6..18bd3ef 100644
--- a/content/renderer/devtools/devtools_agent.cc
+++ b/content/renderer/devtools/devtools_agent.cc
@@ -44,6 +44,7 @@ using blink::WebVector;
 using blink::WebView;
 
 using base::debug::TraceLog;
+using base::debug::TraceOptions;
 
 namespace content {
 
@@ -173,7 +174,7 @@ void DevToolsAgent::enableTracing(const WebString& category_filter) {
   TraceLog* trace_log = TraceLog::GetInstance();
   trace_log->SetEnabled(base::debug::CategoryFilter(category_filter.utf8()),
                         TraceLog::RECORDING_MODE,
-                        TraceLog::RECORD_UNTIL_FULL);
+                        TraceOptions());
 }
 
 void DevToolsAgent::disableTracing() {