Re-land first pass BackgroundTracingManager.

content/browser/tracing/background_tracing_manager_browsertest.cc

+// Copyright 2015 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/bind.h"
+#include "content/public/browser/background_tracing_manager.h"
+#include "content/public/browser/background_tracing_preemptive_config.h"
+#include "content/public/browser/background_tracing_reactive_config.h"
+#include "content/public/browser/background_tracing_upload_sink.h"
+#include "content/public/test/content_browser_test.h"
+#include "content/public/test/content_browser_test_utils.h"
+#include "content/public/test/test_utils.h"
+
+namespace content {
+
+class BackgroundTracingManagerBrowserTest : public ContentBrowserTest {
+ public:
+  BackgroundTracingManagerBrowserTest() {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BackgroundTracingManagerBrowserTest);
+};
+
+class BackgroundTracingManagerTestSink : public BackgroundTracingUploadSink {
+ public:
+  BackgroundTracingManagerTestSink(const base::Closure& callback)
+      : callback_(callback), receive_count_(0) {}
+
+  void Upload(const std::string& file_contents,
+              base::Callback<void()> done_callback) override {
+    receive_count_ += 1;
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(done_callback));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(callback_));
+  }
+
+  bool RequiresAnonymizedData() const override { return true; }
+
+  int get_receive_count() const { return receive_count_; }
+
+ private:
+  ~BackgroundTracingManagerTestSink() override {}
+
+  base::Closure callback_;
+  int receive_count_;
+};
+
+void StartedFinalizingCallback(base::Closure callback,
+                               bool expected,
+                               bool value) {
+  EXPECT_EQ(expected, value);
+  if (!callback.is_null())
+    callback.Run();
+}
+
+scoped_refptr<BackgroundTracingPreemptiveConfig> CreatePreemptiveConfig() {
+  scoped_refptr<BackgroundTracingPreemptiveConfig> config =
+      new BackgroundTracingPreemptiveConfig();
+
+  BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+  rule.type =
+      BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+  rule.named_trigger_info.trigger_name = "test";
+
+  config->configs.push_back(rule);
+
+  return config;
+}
+
+void SetupBackgroundTracingManager() {
+  content::BackgroundTracingManager::GetInstance()
+      ->InvalidateTriggerHandlesForTesting();
+}
+
+void DisableScenarioWhenIdle() {
+  BackgroundTracingManager::GetInstance()->SetActiveScenario(NULL, NULL);
+}
+
+// This tests that the endpoint receives the final trace data.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       ReceiveTraceFinalContentsOnTrigger) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop run_loop;
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(run_loop.QuitClosure());
+
+    scoped_refptr<BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    BackgroundTracingManager::TriggerHandle handle =
+        BackgroundTracingManager::GetInstance()->RegisterTriggerType("test");
+
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(config,
+                                                               endpoint);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
+
+    run_loop.Run();
+
+    EXPECT_TRUE(endpoint->get_receive_count() == 1);
+  }
+}
+
+// This tests triggering more than once still only gathers once.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       CallTriggersMoreThanOnceOnlyGatherOnce) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop run_loop;
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(run_loop.QuitClosure());
+
+    scoped_refptr<content::BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test");
+
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(config,
+                                                               endpoint);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle, base::Bind(&StartedFinalizingCallback, base::Closure(), false));
+
+    run_loop.Run();
+
+    EXPECT_TRUE(endpoint->get_receive_count() == 1);
+  }
+}
+
+// This tests multiple triggers still only gathers once.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       CallMultipleTriggersOnlyGatherOnce) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop run_loop;
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(run_loop.QuitClosure());
+
+    scoped_refptr<BackgroundTracingPreemptiveConfig> config =
+        new BackgroundTracingPreemptiveConfig();
+
+    BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+    rule.type =
+        BackgroundTracingPreemptiveConfig::MONITOR_AND_DUMP_WHEN_TRIGGER_NAMED;
+    rule.named_trigger_info.trigger_name = "test1";
+    config->configs.push_back(rule);
+
+    rule.named_trigger_info.trigger_name = "test2";
+    config->configs.push_back(rule);
+
+    BackgroundTracingManager::TriggerHandle handle1 =
+        BackgroundTracingManager::GetInstance()->RegisterTriggerType("test1");
+    BackgroundTracingManager::TriggerHandle handle2 =
+        BackgroundTracingManager::GetInstance()->RegisterTriggerType("test2");
+
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(config,
+                                                               endpoint);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle1, base::Bind(&StartedFinalizingCallback, base::Closure(), true));
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle2,
+        base::Bind(&StartedFinalizingCallback, base::Closure(), false));
+
+    run_loop.Run();
+
+    EXPECT_TRUE(endpoint->get_receive_count() == 1);
+  }
+}
+
+// This tests that you can't trigger without a scenario set.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       CannotTriggerWithoutScenarioSet) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop run_loop;
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(base::Closure());
+
+    scoped_refptr<content::BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test");
+
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle,
+        base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
+
+    run_loop.Run();
+
+    EXPECT_TRUE(endpoint->get_receive_count() == 0);
+  }
+}
+
+// This tests that no trace is triggered with a handle that isn't specified
+// in the config.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       DoesNotTriggerWithWrongHandle) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop run_loop;
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(base::Closure());
+
+    scoped_refptr<content::BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "does_not_exist");
+
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(config,
+                                                               endpoint);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle,
+        base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
+
+    run_loop.Run();
+
+    EXPECT_TRUE(endpoint->get_receive_count() == 0);
+  }
+}
+
+// This tests that no trace is triggered with an invalid handle.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       DoesNotTriggerWithInvalidHandle) {
+  {
+    SetupBackgroundTracingManager();
+
+    base::RunLoop run_loop;
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(base::Closure());
+
+    scoped_refptr<content::BackgroundTracingPreemptiveConfig> config =
+        CreatePreemptiveConfig();
+
+    content::BackgroundTracingManager::TriggerHandle handle =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test");
+
+    content::BackgroundTracingManager::GetInstance()
+        ->InvalidateTriggerHandlesForTesting();
+
+    BackgroundTracingManager::GetInstance()->SetActiveScenario(config,
+                                                               endpoint);
+
+    BackgroundTracingManager::GetInstance()->WhenIdle(
+        base::Bind(&DisableScenarioWhenIdle));
+
+    BackgroundTracingManager::GetInstance()->DidTriggerHappen(
+        handle,
+        base::Bind(&StartedFinalizingCallback, run_loop.QuitClosure(), false));
+
+    run_loop.Run();
+
+    EXPECT_TRUE(endpoint->get_receive_count() == 0);
+  }
+}
+
+// This tests that reactive mode configs will fail.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       DoesNotAllowPreemptiveConfigThatsNotManual) {
+  {
+    SetupBackgroundTracingManager();
+
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(base::Closure());
+
+    scoped_refptr<content::BackgroundTracingPreemptiveConfig> config =
+        new content::BackgroundTracingPreemptiveConfig();
+
+    BackgroundTracingPreemptiveConfig::MonitoringRule rule;
+    rule.type = BackgroundTracingPreemptiveConfig::
+        MONITOR_AND_DUMP_WHEN_SPECIFIC_HISTOGRAM_AND_VALUE;
+    rule.histogram_trigger_info.histogram_name_to_trigger_on = "fake";
+    rule.histogram_trigger_info.histogram_bin_to_trigger_on = 0;
+    config->configs.push_back(rule);
+
+    bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario(
+        config, endpoint);
+
+    EXPECT_FALSE(result);
+  }
+}
+
+// This tests that reactive mode configs will fail.
+IN_PROC_BROWSER_TEST_F(BackgroundTracingManagerBrowserTest,
+                       DoesNotAllowReactiveConfig) {
+  {
+    SetupBackgroundTracingManager();
+
+    scoped_refptr<BackgroundTracingManagerTestSink> endpoint =
+        new BackgroundTracingManagerTestSink(base::Closure());
+
+    scoped_refptr<content::BackgroundTracingReactiveConfig> config =
+        new content::BackgroundTracingReactiveConfig();
+
+    bool result = BackgroundTracingManager::GetInstance()->SetActiveScenario(
+        config, endpoint);
+
+    EXPECT_FALSE(result);
+  }
+}
+
+}  // namespace content