Implement TracingController::GetMonitoringStatus

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 130 matching lines @@
     }
   }
 
   void TestEnableCaptureAndDisableMonitoring(
       const base::FilePath& result_file_path) {
     Navigate(shell());
 
     TracingController* controller = TracingController::GetInstance();
 
     {
+      bool is_monitoring;
+      std::string category_filter;
+      TracingController::Options 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);
+    }
+
+    {
       base::RunLoop run_loop;
       TracingController::EnableMonitoringDoneCallback callback =
           base::Bind(&TracingControllerTest::EnableMonitoringDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
       bool result = controller->EnableMonitoring(
-          "", TracingController::ENABLE_SAMPLING, callback);
+          "*", TracingController::ENABLE_SAMPLING, callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(enable_monitoring_done_callback_count(), 1);
     }
 
     {
+      bool is_monitoring;
+      std::string category_filter;
+      TracingController::Options 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);
+    }
+
+    {
       base::RunLoop run_loop;
       TracingController::TracingFileResultCallback callback =
           base::Bind(&TracingControllerTest::
                          CaptureMonitoringSnapshotDoneCallbackTest,
                      base::Unretained(this),
                      run_loop.QuitClosure());
       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());
       bool result = controller->DisableMonitoring(callback);
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_monitoring_done_callback_count(), 1);
     }
+
+    {
+      bool is_monitoring;
+      std::string category_filter;
+      TracingController::Options 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);
+    }
   }
 
  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_;
   base::FilePath last_actual_recording_file_path_;
@@ skipping 53 matching lines @@
   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(
-      "", 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