Remove TraceController

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/file_util.h"
 #include "base/run_loop.h"
 #include "content/browser/tracing/tracing_controller_impl.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/shell/browser/shell.h"
 #include "content/test/content_browser_test.h"
@@ skipping 104 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(
-          base::debug::CategoryFilter(""), TracingController::Options(),
-          callback);
+          "", TracingController::DEFAULT_OPTIONS, callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_recording_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       TracingController::TracingFileResultCallback callback =
           base::Bind(&TracingControllerTest::DisableRecordingDoneCallbackTest,
                      base::Unretained(this),
@@ skipping 11 matching lines @@
 
     TracingController* controller = TracingController::GetInstance();
 
     {
       base::RunLoop run_loop;
       TracingController::EnableMonitoringDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableMonitoringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
       bool result = controller->EnableMonitoring(
-          base::debug::CategoryFilter(""), TracingController::ENABLE_SAMPLING,
-          callback);
+          "", TracingController::ENABLE_SAMPLING, callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_monitoring_done_callback_count(), 1);
     }
 
     {
       base::RunLoop run_loop;
       TracingController::TracingFileResultCallback callback =
           base::Bind(&TracingControllerTest::
                          CaptureMonitoringSnapshotDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
-      controller->CaptureMonitoringSnapshot(result_file_path, callback);
+      ASSERT_TRUE(controller->CaptureMonitoringSnapshot(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());
@@ skipping 18 matching lines @@
 IN_PROC_BROWSER_TEST_F(TracingControllerTest, GetCategories) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
 
   base::RunLoop run_loop;
   TracingController::GetCategoriesDoneCallback callback =
       base::Bind(&TracingControllerTest::GetCategoriesDoneCallbackTest,
                  base::Unretained(this),
                  run_loop.QuitClosure());
-  controller->GetCategories(callback);
+  ASSERT_TRUE(controller->GetCategories(callback));
   run_loop.Run();
   EXPECT_EQ(get_categories_done_callback_count(), 1);
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest, EnableAndDisableRecording) {
   TestEnableAndDisableRecording(base::FilePath());
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableAndDisableRecordingWithFilePath) {
   base::FilePath file_path;
   file_util::CreateTemporaryFile(&file_path);
   TestEnableAndDisableRecording(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(
-      base::debug::CategoryFilter(""), TracingController::Options(),
+      "", TracingController::DEFAULT_OPTIONS,
       TracingController::EnableRecordingDoneCallback()));
   EXPECT_TRUE(controller->DisableRecording(
       base::FilePath(), TracingController::TracingFileResultCallback()));
   base::RunLoop().RunUntilIdle();
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableCaptureAndDisableMonitoring) {
   TestEnableCaptureAndDisableMonitoring(base::FilePath());
 }
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
                        EnableCaptureAndDisableMonitoringWithFilePath) {
   base::FilePath file_path;
   file_util::CreateTemporaryFile(&file_path);
   TestEnableCaptureAndDisableMonitoring(file_path);
   EXPECT_EQ(file_path.value(), last_actual_monitoring_file_path().value());
 }
 
 IN_PROC_BROWSER_TEST_F(
     TracingControllerTest,
     EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
   EXPECT_TRUE(controller->EnableMonitoring(
-      base::debug::CategoryFilter(""), TracingController::ENABLE_SAMPLING,
+      "", TracingController::ENABLE_SAMPLING,
       TracingController::EnableMonitoringDoneCallback()));
   controller->CaptureMonitoringSnapshot(
       base::FilePath(), TracingController::TracingFileResultCallback());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(controller->DisableMonitoring(
       TracingController::DisableMonitoringDoneCallback()));
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace content