Tracing: Removed monitoring mode

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 "content/public/browser/tracing_controller.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/files/file_util.h"
@@ skipping 81 matching lines @@
 };
 
 class TracingControllerTest : public ContentBrowserTest {
  public:
   TracingControllerTest() {}
 
   void SetUp() override {
     get_categories_done_callback_count_ = 0;
     enable_recording_done_callback_count_ = 0;
     disable_recording_done_callback_count_ = 0;
-    enable_monitoring_done_callback_count_ = 0;
-    disable_monitoring_done_callback_count_ = 0;
-    capture_monitoring_snapshot_done_callback_count_ = 0;
     ContentBrowserTest::SetUp();
   }
 
   void TearDown() override { ContentBrowserTest::TearDown(); }
 
   void Navigate(Shell* shell) {
     NavigateToURL(shell, GetTestUrl("", "title.html"));
   }
 
   void GetCategoriesDoneCallbackTest(base::Closure quit_callback,
@@ skipping 23 matching lines @@
                                             const base::FilePath& file_path) {
     disable_recording_done_callback_count_++;
     EXPECT_TRUE(PathExists(file_path));
     int64_t file_size;
     base::GetFileSize(file_path, &file_size);
     EXPECT_TRUE(file_size > 0);
     quit_callback.Run();
     last_actual_recording_file_path_ = file_path;
   }
 
-  void StartMonitoringDoneCallbackTest(base::Closure quit_callback) {
-    enable_monitoring_done_callback_count_++;
-    quit_callback.Run();
-  }
-
-  void StopMonitoringDoneCallbackTest(base::Closure quit_callback) {
-    disable_monitoring_done_callback_count_++;
-    quit_callback.Run();
-  }
-
-  void CaptureMonitoringSnapshotDoneCallbackTest(
-      base::Closure quit_callback, const base::FilePath& file_path) {
-    capture_monitoring_snapshot_done_callback_count_++;
-    EXPECT_TRUE(PathExists(file_path));
-    int64_t file_size;
-    base::GetFileSize(file_path, &file_size);
-    EXPECT_TRUE(file_size > 0);
-    quit_callback.Run();
-    last_actual_monitoring_file_path_ = file_path;
-  }
-
-  int get_categories_done_callback_count() const {
+    int get_categories_done_callback_count() const {
     return get_categories_done_callback_count_;
   }
 
   int enable_recording_done_callback_count() const {
     return enable_recording_done_callback_count_;
   }
 
   int disable_recording_done_callback_count() const {
     return disable_recording_done_callback_count_;
   }
 
-  int enable_monitoring_done_callback_count() const {
-    return enable_monitoring_done_callback_count_;
-  }
-
-  int disable_monitoring_done_callback_count() const {
-    return disable_monitoring_done_callback_count_;
-  }
-
-  int capture_monitoring_snapshot_done_callback_count() const {
-    return capture_monitoring_snapshot_done_callback_count_;
-  }
-
   base::FilePath last_actual_recording_file_path() const {
     return last_actual_recording_file_path_;
   }
 
-  base::FilePath last_actual_monitoring_file_path() const {
-    return last_actual_monitoring_file_path_;
-  }
-
   const base::DictionaryValue* last_metadata() const {
     return last_metadata_.get();
   }
 
   const std::string& last_data() const {
     return last_data_;
   }
 
   void TestStartAndStopTracingString() {
     Navigate(shell());
@@ skipping 164 matching lines @@
           run_loop.QuitClosure(),
           result_file_path);
       bool result = controller->StopTracing(
           TracingController::CreateFileSink(result_file_path, callback));
       ASSERT_TRUE(result);
       run_loop.Run();
       EXPECT_EQ(disable_recording_done_callback_count(), 1);
     }
   }
 
-  void TestEnableCaptureAndStopMonitoring(
-      const base::FilePath& result_file_path) {
-    Navigate(shell());
-
-    TracingController* controller = TracingController::GetInstance();
-
-    {
-      bool is_monitoring;
-      TraceConfig trace_config("", "");
-      controller->GetMonitoringStatus(
-          &is_monitoring, &trace_config);
-      EXPECT_FALSE(is_monitoring);
-      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::StartMonitoringDoneCallback callback =
-          base::Bind(&TracingControllerTest::StartMonitoringDoneCallbackTest,
-                     base::Unretained(this),
-                     run_loop.QuitClosure());
-
-      TraceConfig trace_config("*", "");
-      trace_config.EnableSampling();
-      bool result = controller->StartMonitoring(trace_config, callback);
-      ASSERT_TRUE(result);
-      run_loop.Run();
-      EXPECT_EQ(enable_monitoring_done_callback_count(), 1);
-    }
-
-    {
-      bool is_monitoring;
-      TraceConfig trace_config("", "");
-      controller->GetMonitoringStatus(&is_monitoring, &trace_config);
-      EXPECT_TRUE(is_monitoring);
-      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::StopMonitoringDoneCallback callback =
-          base::Bind(&TracingControllerTest::StopMonitoringDoneCallbackTest,
-                     base::Unretained(this),
-                     run_loop.QuitClosure());
-      bool result = controller->StopMonitoring(callback);
-      ASSERT_TRUE(result);
-      run_loop.Run();
-      EXPECT_EQ(disable_monitoring_done_callback_count(), 1);
-    }
-
-    {
-      bool is_monitoring;
-      TraceConfig trace_config("", "");
-      controller->GetMonitoringStatus(&is_monitoring, &trace_config);
-      EXPECT_FALSE(is_monitoring);
-      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_;
   base::FilePath last_actual_recording_file_path_;
-  base::FilePath last_actual_monitoring_file_path_;
   scoped_ptr<const base::DictionaryValue> last_metadata_;
   std::string last_data_;
 };
 
 IN_PROC_BROWSER_TEST_F(TracingControllerTest, GetCategories) {
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
 
   base::RunLoop run_loop;
@@ skipping 93 matching lines @@
   Navigate(shell());
 
   TracingController* controller = TracingController::GetInstance();
   EXPECT_TRUE(controller->StartTracing(
       TraceConfig(),
       TracingController::StartTracingDoneCallback()));
   EXPECT_TRUE(controller->StopTracing(NULL));
   base::RunLoop().RunUntilIdle();
 }
 
-IN_PROC_BROWSER_TEST_F(TracingControllerTest,
-                       EnableCaptureAndStopMonitoring) {
-  base::FilePath file_path;
-  base::CreateTemporaryFile(&file_path);
-  TestEnableCaptureAndStopMonitoring(file_path);
-}
-
-IN_PROC_BROWSER_TEST_F(TracingControllerTest,
-                       EnableCaptureAndStopMonitoringWithFilePath) {
-  base::FilePath file_path;
-  base::CreateTemporaryFile(&file_path);
-  TestEnableCaptureAndStopMonitoring(file_path);
-  EXPECT_EQ(file_path.value(), last_actual_monitoring_file_path().value());
-}
-
-// See http://crbug.com/392446
-#if defined(OS_ANDROID)
-#define MAYBE_EnableCaptureAndStopMonitoringWithEmptyFileAndNullCallback \
-    DISABLED_EnableCaptureAndStopMonitoringWithEmptyFileAndNullCallback
-#else
-#define MAYBE_EnableCaptureAndStopMonitoringWithEmptyFileAndNullCallback \
-    EnableCaptureAndStopMonitoringWithEmptyFileAndNullCallback
-#endif
-IN_PROC_BROWSER_TEST_F(
-    TracingControllerTest,
-    MAYBE_EnableCaptureAndStopMonitoringWithEmptyFileAndNullCallback) {
-  Navigate(shell());
-
-  TracingController* controller = TracingController::GetInstance();
-  TraceConfig trace_config("*", "");
-  trace_config.EnableSampling();
-  EXPECT_TRUE(controller->StartMonitoring(
-      trace_config,
-      TracingController::StartMonitoringDoneCallback()));
-  controller->CaptureMonitoringSnapshot(NULL);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(controller->StopMonitoring(
-      TracingController::StopMonitoringDoneCallback()));
-  base::RunLoop().RunUntilIdle();
-}
-
 }  // namespace content