[headless] Expose DevToolsTarget via HeadlessBrowser + add tracing test.

headless/lib/headless_browser_browsertest.cc

 // Copyright 2016 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 <memory>
 
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test.h"
 #include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/lib/headless_macros.h"
 #include "headless/public/devtools/domains/inspector.h"
 #include "headless/public/devtools/domains/network.h"
 #include "headless/public/devtools/domains/page.h"
+#include "headless/public/devtools/domains/tracing.h"
 #include "headless/public/headless_browser.h"
 #include "headless/public/headless_devtools_client.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/headless_web_contents.h"
 #include "headless/test/headless_browser_test.h"
 #include "headless/test/test_protocol_handler.h"
 #include "headless/test/test_url_request_job.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/cookies/cookie_store.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
@@ skipping 748 matching lines @@
   content::PermissionManager* permission_manager =
       web_contents->browser_context()->GetPermissionManager();
   EXPECT_NE(nullptr, permission_manager);
 
   // Check that the permission manager returns ASK for a given permission type.
   EXPECT_EQ(blink::mojom::PermissionStatus::ASK,
             permission_manager->GetPermissionStatus(
                 content::PermissionType::NOTIFICATIONS, url, url));
 }
 
+namespace {
+
+class TraceHelper : public headless::tracing::ExperimentalObserver {
+ public:
+  TraceHelper(HeadlessBrowserTest* browser_test, HeadlessDevToolsTarget* target)
+      : browser_test_(browser_test),
+        target_(target),
+        client_(HeadlessDevToolsClient::Create()),
+        tracing_data_(base::MakeUnique<base::ListValue>()) {
+    EXPECT_FALSE(target_->IsAttached());
+    target_->AttachClient(client_.get());
+    EXPECT_TRUE(target_->IsAttached());
+
+    client_->GetTracing()->GetExperimental()->AddObserver(this);
+
+    client_->GetTracing()->GetExperimental()->Start(
+        tracing::StartParams::Builder().Build(),
+        base::Bind(&TraceHelper::OnTracingStarted, base::Unretained(this)));
+  }
+
+  ~TraceHelper() override {
+    target_->DetachClient(client_.get());
+    EXPECT_FALSE(target_->IsAttached());
+  }
+
+  std::unique_ptr<base::ListValue> TakeTracingData() {
+    return std::move(tracing_data_);
+  }
+
+ private:
+  void OnTracingStarted(std::unique_ptr<headless::tracing::StartResult>) {
+    // We don't need the callback from End, but the OnTracingComplete event.
+    client_->GetTracing()->GetExperimental()->End(
+        headless::tracing::EndParams::Builder().Build());
+  }
+
+  // headless::tracing::ExperimentalObserver implementation:
+  void OnDataCollected(
+      const headless::tracing::DataCollectedParams& params) override {
+    for (const auto& value : *params.GetValue()) {
+      tracing_data_->Append(value->CreateDeepCopy());
+    }
+  }
+
+  void OnTracingComplete(
+      const headless::tracing::TracingCompleteParams& params) override {
+    browser_test_->FinishAsynchronousTest();
+  }
+
+  HeadlessBrowserTest* browser_test_;  // Not owned.
+  HeadlessDevToolsTarget* target_;     // Not owned.
+  std::unique_ptr<HeadlessDevToolsClient> client_;
+
+  std::unique_ptr<base::ListValue> tracing_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(TraceHelper);
+};
+
+}  // namespace
+
+IN_PROC_BROWSER_TEST_F(HeadlessBrowserTest, TraceUsingBrowserDevToolsTarget) {
+  HeadlessDevToolsTarget* target = browser()->GetDevToolsTarget();
+  EXPECT_NE(nullptr, target);
+
+  TraceHelper helper(this, target);
+  RunAsynchronousTest();
+
+  std::unique_ptr<base::ListValue> tracing_data = helper.TakeTracingData();
+  EXPECT_TRUE(tracing_data);
+  EXPECT_LT(0u, tracing_data->GetSize());
+}
+
 }  // namespace headless