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

content/browser/tracing/tracing_controller_browsertest.cc

 // Copyright 2013 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/files/file_util.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/run_loop.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/tracing_controller.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 
-using base::trace_event::CategoryFilter;
-using base::trace_event::TraceOptions;
 using base::trace_event::RECORD_CONTINUOUSLY;
 using base::trace_event::RECORD_UNTIL_FULL;
+using base::trace_event::TraceConfig;
 
 namespace content {
 
 class TracingControllerTestEndpoint
     : public TracingController::TraceDataEndpoint {
  public:
   TracingControllerTestEndpoint(
       base::Callback<void(base::RefCountedString*)> done_callback)
       : done_callback_(done_callback) {}
 
@@ skipping 129 matching lines @@
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::EnableRecordingDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
       bool result = controller->EnableRecording(
-          CategoryFilter(), TraceOptions(), callback);
+          TraceConfig(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       base::Callback<void(base::RefCountedString*)> callback = base::Bind(
           &TracingControllerTest::DisableRecordingStringDoneCallbackTest,
           base::Unretained(this),
           run_loop.QuitClosure());
       bool result = controller->DisableRecording(
           TracingController::CreateStringSink(callback));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
   void TestEnableAndDisableRecordingCompressed() {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::EnableRecordingDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
                      base::Unretained(this), run_loop.QuitClosure());
-      bool result = controller->EnableRecording(CategoryFilter(),
-                                                TraceOptions(), callback);
+      bool result = controller->EnableRecording(TraceConfig(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       base::Callback<void(base::RefCountedString*)> callback = base::Bind(
           &TracingControllerTest::DisableRecordingStringDoneCallbackTest,
           base::Unretained(this), run_loop.QuitClosure());
@@ skipping 10 matching lines @@
       const base::FilePath& result_file_path) {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::EnableRecordingDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
                      base::Unretained(this), run_loop.QuitClosure());
-      bool result = controller->EnableRecording(CategoryFilter(),
-                                                TraceOptions(), callback);
+      bool result = controller->EnableRecording(TraceConfig(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       base::Closure callback = base::Bind(
           &TracingControllerTest::DisableRecordingFileDoneCallbackTest,
           base::Unretained(this), run_loop.QuitClosure(), result_file_path);
@@ skipping 12 matching lines @@
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::EnableRecordingDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
-      bool result = controller->EnableRecording(
-          CategoryFilter(), TraceOptions(), callback);
+      bool result = controller->EnableRecording(TraceConfig(), callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       base::Closure callback = base::Bind(
           &TracingControllerTest::DisableRecordingFileDoneCallbackTest,
           base::Unretained(this),
           run_loop.QuitClosure(),
           result_file_path);
       bool result = controller->DisableRecording(
           TracingController::CreateFileSink(result_file_path, callback));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
   void TestEnableCaptureAndDisableMonitoring(
       const base::FilePath& result_file_path) {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       bool is_monitoring;
-      CategoryFilter category_filter("");
-      TraceOptions options;
+      TraceConfig trace_config("", "");
       controller->GetMonitoringStatus(
-          &is_monitoring, &category_filter, &options);
+          &is_monitoring, &trace_config);
       EXPECT_FALSE(is_monitoring);
-      EXPECT_EQ("-*Debug,-*Test", category_filter.ToString());
-      EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
-      EXPECT_FALSE(options.enable_sampling);
-      EXPECT_FALSE(options.enable_systrace);
+      EXPECT_EQ("-*Debug,-*Test", trace_config.ToCategoryFilterString());
+      EXPECT_FALSE(trace_config.GetTraceRecordMode() == RECORD_CONTINUOUSLY);
+      EXPECT_FALSE(trace_config.IsSamplingEnabled());
+      EXPECT_FALSE(trace_config.IsSystraceEnabled());
     }
 
     {
       base::RunLoop run_loop;
       TracingController::EnableMonitoringDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableMonitoringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
 
-      TraceOptions trace_options;
-      trace_options.enable_sampling = true;
-
-      bool result = controller->EnableMonitoring(
-          CategoryFilter("*"),
-          trace_options,
-          callback);
+      TraceConfig trace_config("*", "");
+      trace_config.EnableSampling();
+      bool result = controller->EnableMonitoring(trace_config, callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_monitoring_done_callback_count(), 1);
     }
 
     {
       bool is_monitoring;
-      CategoryFilter category_filter("");
-      TraceOptions options;
-      controller->GetMonitoringStatus(
-          &is_monitoring, &category_filter, &options);
+      TraceConfig trace_config("", "");
+      controller->GetMonitoringStatus(&is_monitoring, &trace_config);
       EXPECT_TRUE(is_monitoring);
-      EXPECT_EQ("*", category_filter.ToString());
-      EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
-      EXPECT_TRUE(options.enable_sampling);
-      EXPECT_FALSE(options.enable_systrace);
+      EXPECT_EQ("*", trace_config.ToCategoryFilterString());
+      EXPECT_FALSE(trace_config.GetTraceRecordMode() == RECORD_CONTINUOUSLY);
+      EXPECT_TRUE(trace_config.IsSamplingEnabled());
+      EXPECT_FALSE(trace_config.IsSystraceEnabled());
     }
 
     {
       base::RunLoop run_loop;
       base::Closure callback = base::Bind(
           &TracingControllerTest::CaptureMonitoringSnapshotDoneCallbackTest,
           base::Unretained(this),
           run_loop.QuitClosure(),
           result_file_path);
       ASSERT_TRUE(controller->CaptureMonitoringSnapshot(
           TracingController::CreateFileSink(result_file_path, callback)));
       run_loop.Run();
       EXPECT_EQ(capture_monitoring_snapshot_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       TracingController::DisableMonitoringDoneCallback callback =
           base::Bind(&TracingControllerTest::DisableMonitoringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
       bool result = controller->DisableMonitoring(callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_monitoring_done_callback_count(), 1);
     }
 
     {
       bool is_monitoring;
-      CategoryFilter category_filter("");
-      TraceOptions options;
-      controller->GetMonitoringStatus(&is_monitoring,
-                                      &category_filter,
-                                      &options);
+      TraceConfig trace_config("", "");
+      controller->GetMonitoringStatus(&is_monitoring, &trace_config);
       EXPECT_FALSE(is_monitoring);
-      EXPECT_EQ("", category_filter.ToString());
-      EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
-      EXPECT_FALSE(options.enable_sampling);
-      EXPECT_FALSE(options.enable_systrace);
+      EXPECT_EQ("", trace_config.ToCategoryFilterString());
+      EXPECT_FALSE(trace_config.GetTraceRecordMode() == RECORD_CONTINUOUSLY);
+      EXPECT_FALSE(trace_config.IsSamplingEnabled());
+      EXPECT_FALSE(trace_config.IsSystraceEnabled());
     }
   }
 
  private:
   int get_categories_done_callback_count_;
   int enable_recording_done_callback_count_;
   int disable_recording_done_callback_count_;
   int enable_monitoring_done_callback_count_;
   int disable_monitoring_done_callback_count_;
   int capture_monitoring_snapshot_done_callback_count_;
@@ skipping 40 matching lines @@
   TestEnableAndDisableRecordingCompressedFile(file_path);
   EXPECT_EQ(file_path.value(), last_actual_recording_file_path().value());
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableAndDisableRecordingWithEmptyFileAndNullCallback) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
   EXPECT_TRUE(controller->EnableRecording(
-      CategoryFilter(),
-      TraceOptions(),
+      TraceConfig(),
       TracingController::EnableRecordingDoneCallback()));
   EXPECT_TRUE(controller->DisableRecording(NULL));
   base::RunLoop().RunUntilIdle();
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableCaptureAndDisableMonitoring) {
   base::FilePath file_path;
   base::CreateTemporaryFile(&file_path);
   TestEnableCaptureAndDisableMonitoring(file_path);
@@ skipping 14 matching lines @@
 #else
 #define MAYBE_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback \
     EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback
 #endif
 IN_PROC_BROWSER_TEST_F(
     TracingControllerTest,
     MAYBE_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
-  TraceOptions trace_options;
-  trace_options.enable_sampling = true;
+  TraceConfig trace_config("*", "");
+  trace_config.EnableSampling();
   EXPECT_TRUE(controller->EnableMonitoring(
-      CategoryFilter("*"),
-      trace_options,
+      trace_config,
       TracingController::EnableMonitoringDoneCallback()));
   controller->CaptureMonitoringSnapshot(NULL);
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(controller->DisableMonitoring(
       TracingController::DisableMonitoringDoneCallback()));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace content