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

base/debug/trace_event_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/debug/trace_event_unittest.h"
 
 #include <math.h>
 #include <cstdlib>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/debug/trace_event_synthetic_delay.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/process/process_handle.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using base::debug::HighResSleepForTraceTest;
-
 namespace base {
 namespace debug {
 
 namespace {
 
 enum CompareOp {
   IS_EQUAL,
   IS_NOT_EQUAL,
 };
 
@@ skipping 33 matching lines @@
     trace_parsed_.Clear();
     json_output_.json_output.clear();
   }
 
   void BeginTrace() {
     BeginSpecificTrace("*");
   }
 
   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() {
     WaitableEvent flush_complete_event(false, false);
     EndTraceAndFlushAsync(&flush_complete_event);
     flush_complete_event.Wait();
   }
 
   // Used when testing thread-local buffers which requires the thread initiating
   // flush to have a message loop.
@@ skipping 45 matching lines @@
       EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
     PlatformThread::SetName(old_thread_name_ ? old_thread_name_ : "");
     free(old_thread_name_);
     old_thread_name_ = NULL;
     // We want our singleton torn down after each test.
     TraceLog::DeleteForTesting();
   }
 
   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:
   // We want our singleton torn down after each test.
   ShadowingAtExitManager at_exit_manager_;
   Lock lock_;
 };
 
 void TraceEventTestFixture::OnTraceDataCollected(
     WaitableEvent* flush_complete_event,
@@ skipping 711 matching lines @@
 
 void HighResSleepForTraceTest(base::TimeDelta elapsed) {
   base::TimeTicks end_time = base::TimeTicks::HighResNow() + elapsed;
   do {
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
   } while (base::TimeTicks::HighResNow() < end_time);
 }
 
 // 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);
 
   EndTraceAndFlush();
 
   ValidateAllTraceMacrosCreatedData(trace_parsed_);
 }
 
 class MockEnabledStateChangedObserver :
-      public base::debug::TraceLog::EnabledStateObserver {
+      public TraceLog::EnabledStateObserver {
  public:
   MOCK_METHOD0(OnTraceLogEnabled, void());
   MOCK_METHOD0(OnTraceLogDisabled, void());
 };
 
 TEST_F(TraceEventTestFixture, EnabledObserverFiresOnEnable) {
   MockEnabledStateChangedObserver observer;
   TraceLog::GetInstance()->AddEnabledStateObserver(&observer);
 
   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());
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
   TraceLog::GetInstance()->SetDisabled();
 }
 
 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);
 
   EXPECT_CALL(observer, OnTraceLogEnabled())
       .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());
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
   TraceLog::GetInstance()->SetDisabled();
   TraceLog::GetInstance()->SetDisabled();
 }
 
 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);
 
   EXPECT_CALL(observer, OnTraceLogEnabled())
       .Times(0);
   EXPECT_CALL(observer, OnTraceLogDisabled())
       .Times(1);
   TraceLog::GetInstance()->SetDisabled();
   testing::Mock::VerifyAndClear(&observer);
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
   TraceLog::GetInstance()->SetDisabled();
 }
 
 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);
 
   EXPECT_CALL(observer, OnTraceLogDisabled())
       .Times(1);
   TraceLog::GetInstance()->SetDisabled();
   testing::Mock::VerifyAndClear(&observer);
 
   // Cleanup.
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
 }
 
 // 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());
   }
 
   virtual void OnTraceLogDisabled() OVERRIDE {
     EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
   }
 };
 
 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();
   EXPECT_FALSE(TraceLog::GetInstance()->IsEnabled());
 
   TraceLog::GetInstance()->RemoveEnabledStateObserver(&observer);
 }
 
 // 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 {
     TraceLog::GetInstance()->RemoveEnabledStateObserver(this);
   }
 };
 
 TEST_F(TraceEventTestFixture, SelfRemovingObserver) {
   ASSERT_EQ(0u, TraceLog::GetInstance()->GetObserverCountForTest());
 
   SelfRemovingEnabledStateObserver observer;
   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());
 }
 
 bool IsNewTrace() {
   bool is_new_trace;
   TRACE_EVENT_IS_NEW_TRACE(&is_new_trace);
   return is_new_trace;
 }
 
 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());
   EndTraceAndFlush();
 
   // IsNewTrace() should definitely be false now.
   ASSERT_FALSE(IsNewTrace());
 
   // 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());
 
   // Cleanup.
   EndTraceAndFlush();
 }
 
 
 // Test that categories work.
 TEST_F(TraceEventTestFixture, Categories) {
@@ skipping 34 matching lines @@
 
   const std::vector<std::string> empty_categories;
   std::vector<std::string> included_categories;
   std::vector<std::string> excluded_categories;
 
   // Test that category filtering works.
 
   // 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();
   DropTracedMetadataRecords();
   EXPECT_TRUE(trace_parsed_.empty());
 
   // 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();
   DropTracedMetadataRecords();
   EXPECT_TRUE(FindMatchingValue("cat", "inc"));
   EXPECT_FALSE(FindNonMatchingValue("cat", "inc"));
 
   // Include existent wildcard -> all categories matching wildcard
   Clear();
   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);
   TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "included",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "not_inc",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("cat1", "not_inc", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("cat2", "not_inc", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc_wildcard_category,other_category", "included",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0(
       "non_included_category,inc_wildcard_category", "included",
       TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_abc"));
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_"));
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildchar_x_end"));
   EXPECT_FALSE(FindMatchingValue("name", "not_inc"));
   EXPECT_TRUE(FindMatchingValue("cat", "inc_wildcard_category,other_category"));
   EXPECT_TRUE(FindMatchingValue("cat",
                                 "non_included_category,inc_wildcard_category"));
 
   included_categories.clear();
 
   // 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);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "cat1"));
   EXPECT_TRUE(FindMatchingValue("cat", "cat2"));
   EXPECT_TRUE(FindMatchingValue("cat", "category1,category2"));
 
   // 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);
   TRACE_EVENT_INSTANT0("inc,inc2", "name", TRACE_EVENT_SCOPE_THREAD);
   EndTraceAndFlush();
   EXPECT_TRUE(FindMatchingValue("cat", "inc2"));
   EXPECT_FALSE(FindMatchingValue("cat", "inc"));
   EXPECT_FALSE(FindMatchingValue("cat", "inc2,inc"));
   EXPECT_FALSE(FindMatchingValue("cat", "inc,inc2"));
 
   // Exclude existent wildcard -> all categories not matching wildcard
   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",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc_wildchar_x_end", "not_inc",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("inc_wildchar_bla_end", "included",
       TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("cat1", "included", TRACE_EVENT_SCOPE_THREAD);
   TRACE_EVENT_INSTANT0("cat2", "included", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 131 matching lines @@
   TraceLog* tracer = TraceLog::GetInstance();
   // Make sure old events are flushed:
   EndTraceAndFlush();
   EXPECT_EQ(0u, tracer->GetEventsSize());
   const unsigned char* category_group_enabled =
       TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED("cat");
 
   {
     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"),
             "arg2", TRACE_STR_COPY("argval"));
     size_t num_events = tracer->GetEventsSize();
     EXPECT_GT(num_events, 1u);
     const TraceEvent* event1 = tracer->GetEventByHandle(handle1);
     const TraceEvent* event2 = tracer->GetEventByHandle(handle2);
     ASSERT_TRUE(event1);
     ASSERT_TRUE(event2);
     EXPECT_STREQ("name1", event1->name());
     EXPECT_STREQ("name2", event2->name());
     EXPECT_TRUE(event1->parameter_copy_storage() != NULL);
     EXPECT_TRUE(event2->parameter_copy_storage() != NULL);
     EXPECT_GT(event1->parameter_copy_storage()->size(), 0u);
     EXPECT_GT(event2->parameter_copy_storage()->size(), 0u);
     EndTraceAndFlush();
   }
 
   {
     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),
             "arg2", TRACE_STR_COPY(str2));
     size_t num_events = tracer->GetEventsSize();
     EXPECT_GT(num_events, 1u);
     const TraceEvent* event1 = tracer->GetEventByHandle(handle1);
     const TraceEvent* event2 = tracer->GetEventByHandle(handle2);
     ASSERT_TRUE(event1);
     ASSERT_TRUE(event2);
@@ skipping 300 matching lines @@
   TRACE_EVENT_INSTANT1("category", "test", TRACE_EVENT_SCOPE_THREAD, "a", a++);
   EXPECT_EQ(1, a);
 
   EndTraceAndFlush();
 }
 
 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());
   trace_log->SetDisabled();
   EXPECT_FALSE(trace_log->IsEnabled());
 }
 
 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",
                trace_log->GetCurrentCategoryFilter().ToString().c_str());
   trace_log->SetDisabled();
   trace_log->SetDisabled();
   trace_log->SetDisabled();
   EXPECT_FALSE(*trace_log->GetCategoryGroupEnabled("foo"));
   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"));
   EXPECT_STREQ("-foo,-bar",
                trace_log->GetCurrentCategoryFilter().ToString().c_str());
   trace_log->SetDisabled();
   trace_log->SetDisabled();
 
   // 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"));
   EXPECT_STREQ("disabled-by-default-cc,disabled-by-default-gpu",
                trace_log->GetCurrentCategoryFilter().ToString().c_str());
   trace_log->SetDisabled();
   trace_log->SetDisabled();
 }
 
 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();
   TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "cc", "Things");
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
 
   EndTraceAndFlush();
 
   // Make sure we hit at least once.
   EXPECT_TRUE(FindNamePhase("Stuff", "P"));
   EXPECT_TRUE(FindNamePhase("Things", "P"));
 }
 
 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();
   {
     EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "AAA");
     TRACE_EVENT_SCOPED_SAMPLING_STATE("BBB", "name");
     TraceLog::GetInstance()->WaitSamplingEventForTesting();
     EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "BBB");
   }
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
@@ skipping 10 matching lines @@
     TraceLog::GetInstance()->WaitSamplingEventForTesting();
     EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "DDD");
   }
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
   EXPECT_STREQ(TRACE_EVENT_GET_SAMPLING_STATE(), "DDD");
 
   EndTraceAndFlush();
 }
 
 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();
   TRACE_EVENT_SET_SAMPLING_STATE_FOR_BUCKET(1, "category", "BBB");
   TraceLog::GetInstance()->WaitSamplingEventForTesting();
 
   FlushMonitoring();
 
   // Make sure we can get the profiled data.
   EXPECT_TRUE(FindNamePhase("AAA", "P"));
@@ skipping 22 matching lines @@
   // Make sure disabling the continuous sampling thread clears
   // the profiled data.
   EXPECT_FALSE(FindNamePhase("AAA", "P"));
   EXPECT_FALSE(FindNamePhase("BBB", "P"));
   EXPECT_FALSE(FindNamePhase("CCC", "P"));
   EXPECT_FALSE(FindNamePhase("DDD", "P"));
 
   Clear();
 }
 
-class MyData : public base::debug::ConvertableToTraceFormat {
+class MyData : public ConvertableToTraceFormat {
  public:
   MyData() {}
 
   virtual void AppendAsTraceFormat(std::string* out) const OVERRIDE {
     out->append("{\"foo\":1}");
   }
 
  private:
   virtual ~MyData() {}
   DISALLOW_COPY_AND_ASSIGN(MyData);
 };
 
 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());
   scoped_refptr<ConvertableToTraceFormat> data2(new MyData());
   TRACE_EVENT1("foo", "bar", "data", data);
   TRACE_EVENT2("foo", "baz",
                "data1", data1,
                "data2", data2);
 
 
@@ skipping 83 matching lines @@
   value = NULL;
   convertable_dict = NULL;
   foo_val = 0;
   EXPECT_TRUE(args_dict->Get("convert", &value));
   ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
   EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
   EXPECT_EQ(1, foo_val);
 }
 
 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);
   TRACE_EVENT1("foo", "event3", "float_one", 1.0f);
   TRACE_EVENT1("foo", "event4", "float_half", .5f);
   TRACE_EVENT1("foo", "event5", "float_neghalf", -.5f);
   TRACE_EVENT1("foo", "event6", "float_infinity",
       std::numeric_limits<float>::infinity());
   TRACE_EVENT1("foo", "event6b", "float_neg_infinity",
       -std::numeric_limits<float>::infinity());
@@ skipping 240 matching lines @@
   EXPECT_EQ(TRACE_EVENT_PHASE_INSTANT, collected_events_phases_[3]);
   EXPECT_EQ("duration", collected_events_names_[4]);
   EXPECT_EQ(TRACE_EVENT_PHASE_END, collected_events_phases_[4]);
   for (size_t i = 1; i < collected_events_timestamps_.size(); i++) {
     EXPECT_LE(collected_events_timestamps_[i - 1],
               collected_events_timestamps_[i]);
   }
 }
 
 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());
   TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("*"),
                                                    Callback);
   TRACE_EVENT_INSTANT0("all", "a snake", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackDisabled();
   ASSERT_EQ(1u, collected_events_names_.size());
   EXPECT_EQ("a snake", collected_events_names_[0]);
 }
 
 // 1: Enable callback, enable recording, disable callback, disable recording.
 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording1) {
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"),
                                                    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();
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
   EndTraceAndFlush();
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
 
   DropTracedMetadataRecords();
   VerifyCallbackAndRecordedEvents(2, 2);
 }
 
 // 2: Enable callback, enable recording, disable recording, disable callback.
 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecording2) {
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("callback"),
                                                    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();
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackDisabled();
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
 
   DropTracedMetadataRecords();
   VerifyCallbackAndRecordedEvents(3, 1);
 }
 
 // 3: Enable recording, enable callback, disable callback, disable recording.
 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"),
                                                    Callback);
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackDisabled();
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
   EndTraceAndFlush();
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
 
   DropTracedMetadataRecords();
   VerifyCallbackAndRecordedEvents(1, 3);
 }
 
 // 4: Enable recording, enable callback, disable recording, disable callback.
 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"),
                                                    Callback);
   TRACE_EVENT_INSTANT0("recording", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   EndTraceAndFlush();
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "yes", TRACE_EVENT_SCOPE_GLOBAL);
   TraceLog::GetInstance()->SetEventCallbackDisabled();
   TRACE_EVENT_INSTANT0("recording", "no", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_INSTANT0("callback", "no", TRACE_EVENT_SCOPE_GLOBAL);
 
   DropTracedMetadataRecords();
   VerifyCallbackAndRecordedEvents(2, 2);
 }
 
 TEST_F(TraceEventCallbackTest, TraceEventCallbackAndRecordingDuration) {
   TraceLog::GetInstance()->SetEventCallbackEnabled(CategoryFilter("*"),
                                                    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");
   }
   TraceLog::GetInstance()->SetEventCallbackDisabled();
 
   ASSERT_EQ(6u, collected_events_names_.size());
   VerifyCollectedEvent(0, TRACE_EVENT_PHASE_BEGIN, "callback", "duration1");
   VerifyCollectedEvent(1, TRACE_EVENT_PHASE_BEGIN, "callback", "duration2");
   VerifyCollectedEvent(2, TRACE_EVENT_PHASE_BEGIN, "callback", "duration3");
   VerifyCollectedEvent(3, TRACE_EVENT_PHASE_END, "callback", "duration3");
   VerifyCollectedEvent(4, TRACE_EVENT_PHASE_END, "callback", "duration2");
   VerifyCollectedEvent(5, TRACE_EVENT_PHASE_END, "callback", "duration1");
 }
 
 #if defined(OS_WIN)
 // http://crbug.com/396403
 #define MAYBE_TraceBufferVectorReportFull DISABLED_TraceBufferVectorReportFull
 #else
 #define MAYBE_TraceBufferVectorReportFull TraceBufferVectorReportFull
 #endif
 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 {
     TRACE_EVENT_BEGIN_WITH_ID_TID_AND_TIMESTAMP0(
         "all", "with_timestamp", 0, 0,
         TimeTicks::NowFromSystemTraceTime().ToInternalValue());
     TRACE_EVENT_END_WITH_ID_TID_AND_TIMESTAMP0(
         "all", "with_timestamp", 0, 0,
         TimeTicks::NowFromSystemTraceTime().ToInternalValue());
   } while (!trace_log->BufferIsFull());
@@ skipping 25 matching lines @@
   EXPECT_TRUE(trace_parsed_.GetDictionary(trace_parsed_.GetSize() - 1,
                                           &last_trace_event));
   EXPECT_TRUE(last_trace_event->GetDouble("ts", &last_trace_event_timestamp));
   EXPECT_LE(last_trace_event_timestamp, buffer_limit_reached_timestamp);
   EXPECT_LE(buffer_limit_reached_timestamp,
             trace_log->OffsetNow().ToInternalValue());
 }
 
 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;
   uint32 last_seq = 0;
   size_t chunk_index;
   EXPECT_EQ(0u, buffer->Size());
 
   scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]);
   for (size_t i = 0; i < num_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
@@ skipping 38 matching lines @@
   }
 
   for (size_t i = 0; i < num_chunks; ++i)
     buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
 
   TraceLog::GetInstance()->SetDisabled();
 }
 
 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;
   size_t chunk_index;
   EXPECT_EQ(0u, buffer->Size());
   EXPECT_FALSE(buffer->NextChunk());
 
   size_t half_chunks = num_chunks / 2;
   scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[half_chunks]);
 
   for (size_t i = 0; i < half_chunks; ++i) {
     chunks[i] = buffer->GetChunk(&chunk_index).release();
     EXPECT_TRUE(chunks[i]);
     EXPECT_EQ(i, chunk_index);
   }
   for (size_t i = 0; i < half_chunks; ++i)
     buffer->ReturnChunk(i, scoped_ptr<TraceBufferChunk>(chunks[i]));
 
   for (size_t i = 0; i < half_chunks; ++i)
     EXPECT_EQ(chunks[i], buffer->NextChunk());
   EXPECT_FALSE(buffer->NextChunk());
   TraceLog::GetInstance()->SetDisabled();
 }
 
 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;
   size_t chunk_index;
   EXPECT_EQ(0u, buffer->Size());
   EXPECT_FALSE(buffer->NextChunk());
 
   scoped_ptr<TraceBufferChunk*[]> chunks(new TraceBufferChunk*[num_chunks]);
 
   for (size_t i = 0; i < num_chunks; ++i) {
@@ skipping 18 matching lines @@
   std::string category_filter_str = default_cf.ToString();
   EXPECT_STREQ("-*Debug,-*Test", category_filter_str.c_str());
   EXPECT_TRUE(default_cf.IsCategoryGroupEnabled("not-excluded-category"));
   EXPECT_FALSE(
       default_cf.IsCategoryGroupEnabled("disabled-by-default-category"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("Category1,CategoryDebug"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("CategoryDebug,Category1"));
   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"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("Category1,CategoryDebug"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("CategoryDebug,Category1"));
   EXPECT_FALSE(default_cf.IsCategoryGroupEnabled("CategoryTest,Category2"));
 
   // Using an arbitrary non-empty filter.
   CategoryFilter cf("included,-excluded,inc_pattern*,-exc_pattern*");
   category_filter_str = cf.ToString();
@@ skipping 96 matching lines @@
       FROM_HERE, Bind(&BlockUntilStopped, &task_start_event, &task_stop_event));
   task_start_event.Wait();
 
   EndTraceAndFlush();
   ValidateAllTraceMacrosCreatedData(trace_parsed_);
 
   task_stop_event.Signal();
   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();
   BlockUntilStopped(task_start_event, task_stop_event);
 }
 
 TEST_F(TraceEventTestFixture, SetCurrentThreadBlocksMessageLoopAfterTracing) {
   BeginTrace();
 
   Thread thread("1");
@@ skipping 71 matching lines @@
     g_log_buffer = new std::string();
   g_log_buffer->append(str);
   return false;
 }
 
 TEST_F(TraceEventTestFixture, EchoToConsole) {
   logging::LogMessageHandlerFunction old_log_message_handler =
       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");
     TRACE_EVENT0("b1", "duration1");
   }
   TRACE_EVENT_INSTANT0("c", "instant", TRACE_EVENT_SCOPE_GLOBAL);
   TRACE_EVENT_END0("a", "begin_end");
 
   EXPECT_NE(std::string::npos, g_log_buffer->find("begin_end[a]\x1b"));
   EXPECT_NE(std::string::npos, g_log_buffer->find("| duration[b]\x1b"));
@@ skipping 13 matching lines @@
                                      const std::string&) {
   TRACE_EVENT0("log", "trace_event");
   return false;
 }
 
 TEST_F(TraceEventTestFixture, EchoToConsoleTraceEventRecursion) {
   logging::LogMessageHandlerFunction old_log_message_handler =
       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");
   }
 
   EndTraceAndFlush();
   logging::SetLogMessageHandler(old_log_message_handler);
 }
 
 TEST_F(TraceEventTestFixture, TimeOffset) {
@@ skipping 66 matching lines @@
   filter1.Merge(filter2);
   EXPECT_EQ(2u, filter1.GetSyntheticDelayValues().size());
 }
 
 TEST_F(TraceEventTestFixture, SyntheticDelayConfigurationToString) {
   const char config[] = "DELAY(test.Delay;16;oneshot)";
   CategoryFilter filter(config);
   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