content/browser/tracing/background_tracing_manager_browsertest.cc

   1 // Copyright 2015 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/bind.h"
   6 #include "base/trace_event/trace_event.h"
   7 #include "content/public/browser/background_tracing_manager.h"
   8 #include "content/public/browser/background_tracing_preemptive_config.h"
   9 #include "content/public/browser/background_tracing_reactive_config.h"
  10 #include "content/public/test/content_browser_test.h"
  11 #include "content/public/test/content_browser_test_utils.h"
  12 #include "content/public/test/test_utils.h"
  13 #include "third_party/zlib/zlib.h"
  14
  15 namespace content {
  16
  17 class BackgroundTracingManagerBrowserTest : public ContentBrowserTest {
  18  public:
  19   BackgroundTracingManagerBrowserTest() {}
  20
  21  private:
  22   DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerBrowserTest);
  23 };
  24
  25 class BackgroundTracingManagerUploadConfigWrapper {
  26  public:
  27   BackgroundTracingManagerUploadConfigWrapper(const base::Closure& callback)
  28       : callback_(callback), receive_count_(0) {
  29     receive_callback_ =
  30         base::Bind(&BackgroundTracingManagerUploadConfigWrapper::Upload,
  31                    base::Unretained(this));
  32   }
  33
  34   void Upload(const scoped_refptr<base::RefCountedString>& file_contents,
  35               base::Callback<void()> done_callback) {
  36     receive_count_ += 1;
  37     EXPECT_TRUE(file_contents);
  38
  39     size_t compressed_length = file_contents->data().length();
  40     const size_t kOutputBufferLength = 10 * 1024 * 1024;
  41     std::vector<char> output_str(kOutputBufferLength);
  42
  43     z_stream stream = {0};
  44     stream.avail_in = compressed_length;
  45     stream.avail_out = kOutputBufferLength;
  46     stream.next_in = (Bytef*)&file_contents->data()[0];
  47     stream.next_out = (Bytef*)vector_as_array(&output_str);
  48
  49     // 16 + MAX_WBITS means only decoding gzip encoded streams, and using
  50     // the biggest window size, according to zlib.h
  51     int result = inflateInit2(&stream, 16 + MAX_WBITS);
  52     EXPECT_EQ(Z_OK, result);
  53     result = inflate(&stream, Z_FINISH);
  54     int bytes_written = kOutputBufferLength - stream.avail_out;
  55
  56     inflateEnd(&stream);
  57     EXPECT_EQ(Z_STREAM_END, result);
  58
  59     last_file_contents_.assign(vector_as_array(&output_str), bytes_written);
  60     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
  61                             base::Bind(done_callback));
  62     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
  63                             base::Bind(callback_));
  64   }
  65
  66   bool TraceHasMatchingString(const char* str) {
  67     return last_file_contents_.find(str) != std::string::npos;
  68   }
  69
  70   int get_receive_count() const { return receive_count_; }
  71
  72   const BackgroundTracingManager::ReceiveCallback& get_receive_callback()
  73       const {
  74     return receive_callback_;
  75   }
  76
  77  private:
  78   BackgroundTracingManager::ReceiveCallback receive_callback_;
  79   base::Closure callback_;
  80   int receive_count_;
  81   std::string last_file_contents_;
  82 };
  83
  84 void StartedFinalizingCallback(base::Closure callback,
  85                                bool expected,
  86                                bool value) {
  87   EXPECT_EQ(expected, value);
  88   if (!callback.is_null())
  89     callback.Run();
  90 }
  91
  92 scoped_ptr<BackgroundTracingPreemptiveConfig> CreatePreemptiveConfig() {
  93   scoped_ptr<BackgroundTracingPreemptiveConfig> config(
  94       new BackgroundTracingPreemptiveConfig());
  95
  96   BackgroundTracingPreemptiveConfig::MonitoringRule rule;
  97   rule.type =
  98       BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
  99   rule.named_trigger_info.trigger_name = "preemptive_test";
 100
 101   config->configs.push_back(rule);
 102
 103   return config.Pass();
 104 }
 105
 106 scoped_ptr<BackgroundTracingReactiveConfig> CreateReactiveConfig() {
 107   scoped_ptr<BackgroundTracingReactiveConfig> config(
 108       new BackgroundTracingReactiveConfig());
 109
 110   BackgroundTracingReactiveConfig::TracingRule rule;
 111   rule.type =
 112       BackgroundTracingReactiveConfig::TRACE_FOR_10S_OR_TRIGGER_OR_FULL;
 113   rule.trigger_name = "reactive_test";
 114   rule.category_preset =
 115       BackgroundTracingConfig::CategoryPreset::BENCHMARK_DEEP;
 116
 117   config->configs.push_back(rule);
 118
 119   return config.Pass();
 120 }
 121
 122 void SetupBackgroundTracingManager() {
 123   content::BackgroundTracingManager::GetInstance()
 124       ->InvalidateTriggerHandlesForTesting();
 125 }
 126
 127 void DisableScenarioWhenIdle() {
 128   BackgroundTracingManager::GetInstance()->SetActiveScenario(
 129       NULL, BackgroundTracingManager::ReceiveCallback(),
 130       BackgroundTracingManager::NO_DATA_FILTERING);
 131 }
 132
 133 // This tests that the endpoint receives the final trace data.
 134 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 135                        ReceiveTraceFinalContentsOnTrigger) {
 136   {
 137     SetupBackgroundTracingManager();
 138
 139     base::RunLoop run_loop;
 140     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 141         run_loop.QuitClosure());
 142
 143     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 144         CreatePreemptiveConfig();
 145
 146     BackgroundTracingManager::TriggerHandle handle =
 147         BackgroundTracingManager::
 148             GetInstance()->RegisterTriggerType("preemptive_test");
 149
 150     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 151         config.Pass(), upload_config_wrapper.get_receive_callback(),
 152         BackgroundTracingManager::NO_DATA_FILTERING);
 153
 154     BackgroundTracingManager::GetInstance()->WhenIdle(
 155         base::Bind(&DisableScenarioWhenIdle));
 156
 157     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 158         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 159
 160     run_loop.Run();
 161
 162     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 163   }
 164 }
 165
 166 // This tests triggering more than once still only gathers once.
 167 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 168                        CallTriggersMoreThanOnceOnlyGatherOnce) {
 169   {
 170     SetupBackgroundTracingManager();
 171
 172     base::RunLoop run_loop;
 173     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 174         run_loop.QuitClosure());
 175
 176     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 177         CreatePreemptiveConfig();
 178
 179     content::BackgroundTracingManager::TriggerHandle handle =
 180         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
 181             "preemptive_test");
 182
 183     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 184         config.Pass(), upload_config_wrapper.get_receive_callback(),
 185         BackgroundTracingManager::NO_DATA_FILTERING);
 186
 187     BackgroundTracingManager::GetInstance()->WhenIdle(
 188         base::Bind(&DisableScenarioWhenIdle));
 189
 190     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 191         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 192     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 193         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 194
 195     run_loop.Run();
 196
 197     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 198   }
 199 }
 200
 201 namespace {
 202
 203 bool IsTraceEventArgsWhitelisted(const char* category_group_name,
 204                                  const char* event_name) {
 205   if (MatchPattern(category_group_name, "benchmark") &&
 206       MatchPattern(event_name, "whitelisted")) {
 207     return true;
 208   }
 209
 210   return false;
 211 }
 212
 213 }  // namespace
 214
 215 // This tests that non-whitelisted args get stripped if required.
 216 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 217                        NoWhitelistedArgsStripped) {
 218   SetupBackgroundTracingManager();
 219
 220   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
 221       base::Bind(&IsTraceEventArgsWhitelisted));
 222
 223   base::RunLoop wait_for_upload;
 224   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 225       wait_for_upload.QuitClosure());
 226
 227   scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 228       CreatePreemptiveConfig();
 229
 230   content::BackgroundTracingManager::TriggerHandle handle =
 231       content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
 232           "preemptive_test");
 233
 234   base::RunLoop wait_for_activated;
 235   BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting(
 236       wait_for_activated.QuitClosure());
 237   EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario(
 238       config.Pass(), upload_config_wrapper.get_receive_callback(),
 239       BackgroundTracingManager::ANONYMIZE_DATA));
 240
 241   wait_for_activated.Run();
 242
 243   TRACE_EVENT1("benchmark", "whitelisted", "find_this", 1);
 244   TRACE_EVENT1("benchmark", "not_whitelisted", "this_not_found", 1);
 245
 246   BackgroundTracingManager::GetInstance()->WhenIdle(
 247       base::Bind(&DisableScenarioWhenIdle));
 248
 249   BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 250       handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 251
 252   wait_for_upload.Run();
 253
 254   EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 255   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("{"));
 256   EXPECT_TRUE(upload_config_wrapper.TraceHasMatchingString("find_this"));
 257   EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("this_not_found"));
 258 }
 259
 260 // This tests subprocesses (like a navigating renderer) which gets told to
 261 // provide a argument-filtered trace and has no predicate in place to do the
 262 // filtering (in this case, only the browser process gets it set), will crash
 263 // rather than return potential PII.
 264 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 265                        CrashWhenSubprocessWithoutArgumentFilter) {
 266   SetupBackgroundTracingManager();
 267
 268   base::trace_event::TraceLog::GetInstance()->SetArgumentFilterPredicate(
 269       base::Bind(&IsTraceEventArgsWhitelisted));
 270
 271   base::RunLoop wait_for_upload;
 272   BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 273       wait_for_upload.QuitClosure());
 274
 275   scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 276       CreatePreemptiveConfig();
 277
 278   content::BackgroundTracingManager::TriggerHandle handle =
 279       content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
 280           "preemptive_test");
 281
 282   base::RunLoop wait_for_activated;
 283   BackgroundTracingManager::GetInstance()->SetTracingEnabledCallbackForTesting(
 284       wait_for_activated.QuitClosure());
 285   EXPECT_TRUE(BackgroundTracingManager::GetInstance()->SetActiveScenario(
 286       config.Pass(), upload_config_wrapper.get_receive_callback(),
 287       BackgroundTracingManager::ANONYMIZE_DATA));
 288
 289   wait_for_activated.Run();
 290
 291   NavigateToURL(shell(), GetTestUrl("", "about:blank"));
 292
 293   BackgroundTracingManager::GetInstance()->WhenIdle(
 294       base::Bind(&DisableScenarioWhenIdle));
 295
 296   BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 297       handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 298
 299   wait_for_upload.Run();
 300
 301   EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 302   // We should *not* receive anything at all from the renderer,
 303   // the process should've crashed rather than letting that happen.
 304   EXPECT_TRUE(!upload_config_wrapper.TraceHasMatchingString("CrRendererMain"));
 305 }
 306
 307 // This tests multiple triggers still only gathers once.
 308 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 309                        CallMultipleTriggersOnlyGatherOnce) {
 310   {
 311     SetupBackgroundTracingManager();
 312
 313     base::RunLoop run_loop;
 314     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 315         run_loop.QuitClosure());
 316
 317     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 318         CreatePreemptiveConfig();
 319
 320     BackgroundTracingPreemptiveConfig::MonitoringRule rule;
 321     rule.type =
 322         BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
 323     rule.named_trigger_info.trigger_name = "test1";
 324     config->configs.push_back(rule);
 325
 326     rule.named_trigger_info.trigger_name = "test2";
 327     config->configs.push_back(rule);
 328
 329     BackgroundTracingManager::TriggerHandle handle1 =
 330         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1");
 331     BackgroundTracingManager::TriggerHandle handle2 =
 332         BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2");
 333
 334     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 335         config.Pass(), upload_config_wrapper.get_receive_callback(),
 336         BackgroundTracingManager::NO_DATA_FILTERING);
 337
 338     BackgroundTracingManager::GetInstance()->WhenIdle(
 339         base::Bind(&DisableScenarioWhenIdle));
 340
 341     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 342         handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 343     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 344         handle2,
 345         base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 346
 347     run_loop.Run();
 348
 349     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 350   }
 351 }
 352
 353 // This tests that you can't trigger without a scenario set.
 354 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 355                        CannotTriggerWithoutScenarioSet) {
 356   {
 357     SetupBackgroundTracingManager();
 358
 359     base::RunLoop run_loop;
 360     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 361         (base::Closure()));
 362
 363     scoped_ptr<BackgroundTracingConfig> config = CreatePreemptiveConfig();
 364
 365     content::BackgroundTracingManager::TriggerHandle handle =
 366         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
 367             "preemptive_test");
 368
 369     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 370         handle,
 371         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 372
 373     run_loop.Run();
 374
 375     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
 376   }
 377 }
 378
 379 // This tests that no trace is triggered with a handle that isn't specified
 380 // in the config.
 381 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 382                        DoesNotTriggerWithWrongHandle) {
 383   {
 384     SetupBackgroundTracingManager();
 385
 386     base::RunLoop run_loop;
 387     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 388         (base::Closure()));
 389
 390     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 391         CreatePreemptiveConfig();
 392
 393     content::BackgroundTracingManager::TriggerHandle handle =
 394         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
 395             "does_not_exist");
 396
 397     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 398         config.Pass(), upload_config_wrapper.get_receive_callback(),
 399         BackgroundTracingManager::NO_DATA_FILTERING);
 400
 401     BackgroundTracingManager::GetInstance()->WhenIdle(
 402         base::Bind(&DisableScenarioWhenIdle));
 403
 404     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 405         handle,
 406         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 407
 408     run_loop.Run();
 409
 410     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
 411   }
 412 }
 413
 414 // This tests that no trace is triggered with an invalid handle.
 415 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 416                        DoesNotTriggerWithInvalidHandle) {
 417   {
 418     SetupBackgroundTracingManager();
 419
 420     base::RunLoop run_loop;
 421     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 422         (base::Closure()));
 423
 424     scoped_ptr<BackgroundTracingPreemptiveConfig> config =
 425         CreatePreemptiveConfig();
 426
 427     content::BackgroundTracingManager::TriggerHandle handle =
 428         content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
 429             "preemptive_test");
 430
 431     content::BackgroundTracingManager::GetInstance()
 432         ->InvalidateTriggerHandlesForTesting();
 433
 434     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 435         config.Pass(), upload_config_wrapper.get_receive_callback(),
 436         BackgroundTracingManager::NO_DATA_FILTERING);
 437
 438     BackgroundTracingManager::GetInstance()->WhenIdle(
 439         base::Bind(&DisableScenarioWhenIdle));
 440
 441     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 442         handle,
 443         base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
 444
 445     run_loop.Run();
 446
 447     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 0);
 448   }
 449 }
 450
 451 // This tests that preemptive mode configs will fail.
 452 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 453                        DoesNotAllowPreemptiveConfigThatsNotManual) {
 454   {
 455     SetupBackgroundTracingManager();
 456
 457     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 458         (base::Closure()));
 459
 460     scoped_ptr<BackgroundTracingPreemptiveConfig> config(
 461         new content::BackgroundTracingPreemptiveConfig());
 462
 463     BackgroundTracingPreemptiveConfig::MonitoringRule rule;
 464     rule.type = BackgroundTracingPreemptiveConfig::
 465         MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
 466     rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake";
 467     rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0;
 468     config->configs.push_back(rule);
 469
 470     bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario(
 471         config.Pass(), upload_config_wrapper.get_receive_callback(),
 472         BackgroundTracingManager::NO_DATA_FILTERING);
 473
 474     EXPECT_FALSE(result);
 475   }
 476 }
 477
 478 // This tests that reactive mode records and terminates with timeout.
 479 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 480                        ReactiveTimeoutTermination) {
 481   {
 482     SetupBackgroundTracingManager();
 483
 484     base::RunLoop run_loop;
 485     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 486         run_loop.QuitClosure());
 487
 488     scoped_ptr<BackgroundTracingReactiveConfig> config =
 489         CreateReactiveConfig();
 490
 491     BackgroundTracingManager::TriggerHandle handle =
 492         BackgroundTracingManager::
 493             GetInstance()->RegisterTriggerType("reactive_test");
 494
 495     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 496         config.Pass(), upload_config_wrapper.get_receive_callback(),
 497         BackgroundTracingManager::NO_DATA_FILTERING);
 498
 499     BackgroundTracingManager::GetInstance()->WhenIdle(
 500         base::Bind(&DisableScenarioWhenIdle));
 501
 502     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 503         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 504
 505     BackgroundTracingManager::GetInstance()->FireTimerForTesting();
 506
 507     run_loop.Run();
 508
 509     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 510   }
 511 }
 512
 513 // This tests that reactive mode records and terminates with a second trigger.
 514 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 515                        ReactiveSecondTriggerTermination) {
 516   {
 517     SetupBackgroundTracingManager();
 518
 519     base::RunLoop run_loop;
 520     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 521         run_loop.QuitClosure());
 522
 523     scoped_ptr<BackgroundTracingReactiveConfig> config =
 524         CreateReactiveConfig();
 525
 526     BackgroundTracingManager::TriggerHandle handle =
 527         BackgroundTracingManager::
 528             GetInstance()->RegisterTriggerType("reactive_test");
 529
 530     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 531         config.Pass(), upload_config_wrapper.get_receive_callback(),
 532         BackgroundTracingManager::NO_DATA_FILTERING);
 533
 534     BackgroundTracingManager::GetInstance()->WhenIdle(
 535         base::Bind(&DisableScenarioWhenIdle));
 536
 537     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 538         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 539     // second trigger to terminate.
 540     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 541         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 542
 543     run_loop.Run();
 544
 545     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 546   }
 547 }
 548
 549 // This tests a third trigger in reactive more does not start another trace.
 550 IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
 551                        ReactiveThirdTriggerTimeout) {
 552   {
 553     SetupBackgroundTracingManager();
 554
 555     base::RunLoop run_loop;
 556     BackgroundTracingManagerUploadConfigWrapper upload_config_wrapper(
 557         run_loop.QuitClosure());
 558
 559     scoped_ptr<BackgroundTracingReactiveConfig> config =
 560         CreateReactiveConfig();
 561
 562     BackgroundTracingManager::TriggerHandle handle =
 563         BackgroundTracingManager::
 564             GetInstance()->RegisterTriggerType("reactive_test");
 565
 566     BackgroundTracingManager::GetInstance()->SetActiveScenario(
 567         config.Pass(), upload_config_wrapper.get_receive_callback(),
 568         BackgroundTracingManager::NO_DATA_FILTERING);
 569
 570     BackgroundTracingManager::GetInstance()->WhenIdle(
 571         base::Bind(&DisableScenarioWhenIdle));
 572
 573     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 574         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 575     // second trigger to terminate.
 576     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 577         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
 578     // third trigger to trigger again, fails as it is still gathering.
 579     BackgroundTracingManager::GetInstance()->TriggerNamedEvent(
 580         handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
 581
 582     run_loop.Run();
 583
 584     EXPECT_TRUE(upload_config_wrapper.get_receive_count() == 1);
 585   }
 586 }
 587
 588 }  // namespace content