Re-land first pass BackgroundTracingManager.

content/browser/tracing/background_tracing_manager_browsertest.cc

Index: content/browser/tracing/background_tracing_manager_browsertest.cc
diff --git a/content/browser/tracing/background_tracing_manager_browsertest.cc b/content/browser/tracing/background_tracing_manager_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..7ae96647b55667919a2819ac180808b77f9a1a12
--- /dev/null
+++ b/content/browser/tracing/background_tracing_manager_browsertest.cc
@@ -0,0 +1,315 @@
+// 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/browser/tracing/background_tracing_manager_impl.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;
+    done_callback.Run();
+    callback_.Run();
+  }
+
+  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<content::BackgroundTracingPreemptiveConfig>
+CreatePreemptiveConfig() {
+  scoped_refptr<content::BackgroundTracingPreemptiveConfig> config =
+      new content::BackgroundTracingPreemptiveConfig();
+
+  config->AddNamedTriggerRule("test");
+
+  return config;
+}
+
+void SetupBackgroundTracingManager() {
+  content::BackgroundTracingManagerImpl::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<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));
+
+    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<content::BackgroundTracingPreemptiveConfig> config =
+        new content::BackgroundTracingPreemptiveConfig();
+
+    config->AddNamedTriggerRule("test1");
+    config->AddNamedTriggerRule("test2");
+
+    content::BackgroundTracingManager::TriggerHandle handle1 =
+        content::BackgroundTracingManager::GetInstance()->RegisterTriggerType(
+            "test1");
+    content::BackgroundTracingManager::TriggerHandle handle2 =
+        content::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::BackgroundTracingManagerImpl::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();
+
+    config->AddHistogramTriggerRule("fake", 0);
+
+    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