content/browser/tracing/tracing_controller_browsertest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/file_util.h"
   6 #include "base/run_loop.h"
   7 #include "content/browser/tracing/tracing_controller_impl.h"
   8 #include "content/public/test/browser_test_utils.h"
   9 #include "content/public/test/content_browser_test.h"
  10 #include "content/public/test/content_browser_test_utils.h"
  11 #include "content/shell/browser/shell.h"
  12
  13 using base::debug::CategoryFilter;
  14 using base::debug::TraceOptions;
  15 using base::debug::RECORD_CONTINUOUSLY;
  16 using base::debug::RECORD_UNTIL_FULL;
  17
  18 namespace content {
  19
  20 class TracingControllerTest : public ContentBrowserTest {
  21  public:
  22   TracingControllerTest() {}
  23
  24   virtual void SetUp() OVERRIDE {
  25     get_categories_done_callback_count_ = 0;
  26     enable_recording_done_callback_count_ = 0;
  27     disable_recording_done_callback_count_ = 0;
  28     enable_monitoring_done_callback_count_ = 0;
  29     disable_monitoring_done_callback_count_ = 0;
  30     capture_monitoring_snapshot_done_callback_count_ = 0;
  31     ContentBrowserTest::SetUp();
  32   }
  33
  34   virtual void TearDown() OVERRIDE {
  35     ContentBrowserTest::TearDown();
  36   }
  37
  38   void Navigate(Shell* shell) {
  39     NavigateToURL(shell, GetTestUrl("", "title.html"));
  40   }
  41
  42   void GetCategoriesDoneCallbackTest(base::Closure quit_callback,
  43                                      const std::set<std::string>& categories) {
  44     get_categories_done_callback_count_++;
  45     EXPECT_TRUE(categories.size() > 0);
  46     quit_callback.Run();
  47   }
  48
  49   void EnableRecordingDoneCallbackTest(base::Closure quit_callback) {
  50     enable_recording_done_callback_count_++;
  51     quit_callback.Run();
  52   }
  53
  54   void DisableRecordingDoneCallbackTest(base::Closure quit_callback,
  55                                         const base::FilePath& file_path) {
  56     disable_recording_done_callback_count_++;
  57     EXPECT_TRUE(PathExists(file_path));
  58     int64 file_size;
  59     base::GetFileSize(file_path, &file_size);
  60     EXPECT_TRUE(file_size > 0);
  61     quit_callback.Run();
  62     last_actual_recording_file_path_ = file_path;
  63   }
  64
  65   void EnableMonitoringDoneCallbackTest(base::Closure quit_callback) {
  66     enable_monitoring_done_callback_count_++;
  67     quit_callback.Run();
  68   }
  69
  70   void DisableMonitoringDoneCallbackTest(base::Closure quit_callback) {
  71     disable_monitoring_done_callback_count_++;
  72     quit_callback.Run();
  73   }
  74
  75   void CaptureMonitoringSnapshotDoneCallbackTest(
  76       base::Closure quit_callback, const base::FilePath& file_path) {
  77     capture_monitoring_snapshot_done_callback_count_++;
  78     EXPECT_TRUE(PathExists(file_path));
  79     int64 file_size;
  80     base::GetFileSize(file_path, &file_size);
  81     EXPECT_TRUE(file_size > 0);
  82     quit_callback.Run();
  83     last_actual_monitoring_file_path_ = file_path;
  84   }
  85
  86   int get_categories_done_callback_count() const {
  87     return get_categories_done_callback_count_;
  88   }
  89
  90   int enable_recording_done_callback_count() const {
  91     return enable_recording_done_callback_count_;
  92   }
  93
  94   int disable_recording_done_callback_count() const {
  95     return disable_recording_done_callback_count_;
  96   }
  97
  98   int enable_monitoring_done_callback_count() const {
  99     return enable_monitoring_done_callback_count_;
 100   }
 101
 102   int disable_monitoring_done_callback_count() const {
 103     return disable_monitoring_done_callback_count_;
 104   }
 105
 106   int capture_monitoring_snapshot_done_callback_count() const {
 107     return capture_monitoring_snapshot_done_callback_count_;
 108   }
 109
 110   base::FilePath last_actual_recording_file_path() const {
 111     return last_actual_recording_file_path_;
 112   }
 113
 114   base::FilePath last_actual_monitoring_file_path() const {
 115     return last_actual_monitoring_file_path_;
 116   }
 117
 118   void TestEnableAndDisableRecording(const base::FilePath& result_file_path) {
 119     Navigate(shell());
 120
 121     TracingController* controller = TracingController::GetInstance();
 122
 123     {
 124       base::RunLoop run_loop;
 125       TracingController::EnableRecordingDoneCallback callback =
 126           base::Bind(&TracingControllerTest::EnableRecordingDoneCallbackTest,
 127                      base::Unretained(this),
 128                      run_loop.QuitClosure());
 129       bool result = controller->EnableRecording(
 130           CategoryFilter(), TraceOptions(), callback);
 131       ASSERT_TRUE(result);
 132       run_loop.Run();
 133       EXPECT_EQ(enable_recording_done_callback_count(), 1);
 134     }
 135
 136     {
 137       base::RunLoop run_loop;
 138       TracingController::TracingFileResultCallback callback =
 139           base::Bind(&TracingControllerTest::DisableRecordingDoneCallbackTest,
 140                      base::Unretained(this),
 141                      run_loop.QuitClosure());
 142       bool result = controller->DisableRecording(result_file_path, callback);
 143       ASSERT_TRUE(result);
 144       run_loop.Run();
 145       EXPECT_EQ(disable_recording_done_callback_count(), 1);
 146     }
 147   }
 148
 149   void TestEnableCaptureAndDisableMonitoring(
 150       const base::FilePath& result_file_path) {
 151     Navigate(shell());
 152
 153     TracingController* controller = TracingController::GetInstance();
 154
 155     {
 156       bool is_monitoring;
 157       CategoryFilter category_filter("");
 158       TraceOptions options;
 159       controller->GetMonitoringStatus(
 160           &is_monitoring, &category_filter, &options);
 161       EXPECT_FALSE(is_monitoring);
 162       EXPECT_EQ("-*Debug,-*Test", category_filter.ToString());
 163       EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
 164       EXPECT_FALSE(options.enable_sampling);
 165       EXPECT_FALSE(options.enable_systrace);
 166     }
 167
 168     {
 169       base::RunLoop run_loop;
 170       TracingController::EnableMonitoringDoneCallback callback =
 171           base::Bind(&TracingControllerTest::EnableMonitoringDoneCallbackTest,
 172                      base::Unretained(this),
 173                      run_loop.QuitClosure());
 174
 175       TraceOptions trace_options;
 176       trace_options.enable_sampling = true;
 177
 178       bool result = controller->EnableMonitoring(
 179           CategoryFilter("*"),
 180           trace_options,
 181           callback);
 182       ASSERT_TRUE(result);
 183       run_loop.Run();
 184       EXPECT_EQ(enable_monitoring_done_callback_count(), 1);
 185     }
 186
 187     {
 188       bool is_monitoring;
 189       CategoryFilter category_filter("");
 190       TraceOptions options;
 191       controller->GetMonitoringStatus(
 192           &is_monitoring, &category_filter, &options);
 193       EXPECT_TRUE(is_monitoring);
 194       EXPECT_EQ("*", category_filter.ToString());
 195       EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
 196       EXPECT_TRUE(options.enable_sampling);
 197       EXPECT_FALSE(options.enable_systrace);
 198     }
 199
 200     {
 201       base::RunLoop run_loop;
 202       TracingController::TracingFileResultCallback callback =
 203           base::Bind(&TracingControllerTest::
 204                          CaptureMonitoringSnapshotDoneCallbackTest,
 205                      base::Unretained(this),
 206                      run_loop.QuitClosure());
 207       ASSERT_TRUE(controller->CaptureMonitoringSnapshot(result_file_path,
 208                                                         callback));
 209       run_loop.Run();
 210       EXPECT_EQ(capture_monitoring_snapshot_done_callback_count(), 1);
 211     }
 212
 213     {
 214       base::RunLoop run_loop;
 215       TracingController::DisableMonitoringDoneCallback callback =
 216           base::Bind(&TracingControllerTest::DisableMonitoringDoneCallbackTest,
 217                      base::Unretained(this),
 218                      run_loop.QuitClosure());
 219       bool result = controller->DisableMonitoring(callback);
 220       ASSERT_TRUE(result);
 221       run_loop.Run();
 222       EXPECT_EQ(disable_monitoring_done_callback_count(), 1);
 223     }
 224
 225     {
 226       bool is_monitoring;
 227       CategoryFilter category_filter("");
 228       TraceOptions options;
 229       controller->GetMonitoringStatus(&is_monitoring,
 230                                       &category_filter,
 231                                       &options);
 232       EXPECT_FALSE(is_monitoring);
 233       EXPECT_EQ("", category_filter.ToString());
 234       EXPECT_FALSE(options.record_mode == RECORD_CONTINUOUSLY);
 235       EXPECT_FALSE(options.enable_sampling);
 236       EXPECT_FALSE(options.enable_systrace);
 237     }
 238   }
 239
 240  private:
 241   int get_categories_done_callback_count_;
 242   int enable_recording_done_callback_count_;
 243   int disable_recording_done_callback_count_;
 244   int enable_monitoring_done_callback_count_;
 245   int disable_monitoring_done_callback_count_;
 246   int capture_monitoring_snapshot_done_callback_count_;
 247   base::FilePath last_actual_recording_file_path_;
 248   base::FilePath last_actual_monitoring_file_path_;
 249 };
 250
 251 IN_PROC_BROWSER_TEST_F(TracingControllerTest, GetCategories) {
 252   Navigate(shell());
 253
 254   TracingController* controller = TracingController::GetInstance();
 255
 256   base::RunLoop run_loop;
 257   TracingController::GetCategoriesDoneCallback callback =
 258       base::Bind(&TracingControllerTest::GetCategoriesDoneCallbackTest,
 259                  base::Unretained(this),
 260                  run_loop.QuitClosure());
 261   ASSERT_TRUE(controller->GetCategories(callback));
 262   run_loop.Run();
 263   EXPECT_EQ(get_categories_done_callback_count(), 1);
 264 }
 265
 266 IN_PROC_BROWSER_TEST_F(TracingControllerTest, EnableAndDisableRecording) {
 267   TestEnableAndDisableRecording(base::FilePath());
 268 }
 269
 270 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
 271                        EnableAndDisableRecordingWithFilePath) {
 272   base::FilePath file_path;
 273   base::CreateTemporaryFile(&file_path);
 274   TestEnableAndDisableRecording(file_path);
 275   EXPECT_EQ(file_path.value(), last_actual_recording_file_path().value());
 276 }
 277
 278 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
 279                        EnableAndDisableRecordingWithEmptyFileAndNullCallback) {
 280   Navigate(shell());
 281
 282   TracingController* controller = TracingController::GetInstance();
 283   EXPECT_TRUE(controller->EnableRecording(
 284       CategoryFilter(),
 285       TraceOptions(),
 286       TracingController::EnableRecordingDoneCallback()));
 287   EXPECT_TRUE(controller->DisableRecording(
 288       base::FilePath(), TracingController::TracingFileResultCallback()));
 289   base::RunLoop().RunUntilIdle();
 290 }
 291
 292 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
 293                        EnableCaptureAndDisableMonitoring) {
 294   TestEnableCaptureAndDisableMonitoring(base::FilePath());
 295 }
 296
 297 IN_PROC_BROWSER_TEST_F(TracingControllerTest,
 298                        EnableCaptureAndDisableMonitoringWithFilePath) {
 299   base::FilePath file_path;
 300   base::CreateTemporaryFile(&file_path);
 301   TestEnableCaptureAndDisableMonitoring(file_path);
 302   EXPECT_EQ(file_path.value(), last_actual_monitoring_file_path().value());
 303 }
 304
 305 // See http://crbug.com/392446
 306 #if defined(OS_ANDROID)
 307 #define MAYBE_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback \
 308     DISABLED_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback
 309 #else
 310 #define MAYBE_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback \
 311     EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback
 312 #endif
 313 IN_PROC_BROWSER_TEST_F(
 314     TracingControllerTest,
 315     MAYBE_EnableCaptureAndDisableMonitoringWithEmptyFileAndNullCallback) {
 316   Navigate(shell());
 317
 318   TracingController* controller = TracingController::GetInstance();
 319   TraceOptions trace_options;
 320   trace_options.enable_sampling = true;
 321   EXPECT_TRUE(controller->EnableMonitoring(
 322       CategoryFilter("*"),
 323       trace_options,
 324       TracingController::EnableMonitoringDoneCallback()));
 325   controller->CaptureMonitoringSnapshot(
 326       base::FilePath(), TracingController::TracingFileResultCallback());
 327   base::RunLoop().RunUntilIdle();
 328   EXPECT_TRUE(controller->DisableMonitoring(
 329       TracingController::DisableMonitoringDoneCallback()));
 330   base::RunLoop().RunUntilIdle();
 331 }
 332
 333 }  // namespace content