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

headless/lib/browser/headless_browser_impl.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 "headless/lib/browser/headless_browser_impl.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/app/content_main.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_switches.h"
 #include "headless/app/headless_shell_switches.h"
 #include "headless/lib/browser/headless_browser_context_impl.h"
 #include "headless/lib/browser/headless_browser_main_parts.h"
+#include "headless/lib/browser/headless_devtools_client_impl.h"
 #include "headless/lib/browser/headless_web_contents_impl.h"
 #include "headless/lib/headless_content_main_delegate.h"
 #include "net/http/http_util.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(OS_WIN)
 #include "content/public/app/sandbox_helper_win.h"
 #include "sandbox/win/src/sandbox_types.h"
 #endif
 
+namespace content {
+class DevToolsAgentHost;
+}
+
 namespace headless {
 namespace {
 
 int RunContentMain(
     HeadlessBrowser::Options options,
     const base::Callback<void(HeadlessBrowser*)>& on_browser_start_callback) {
   content::ContentMainParams params(nullptr);
 #if defined(OS_WIN)
   sandbox::SandboxInterfaceInfo sandbox_info = {0};
   content::InitializeSandboxInfo(&sandbox_info);
@@ skipping 15 matching lines @@
 
 }  // namespace
 
 HeadlessBrowserImpl::HeadlessBrowserImpl(
     const base::Callback<void(HeadlessBrowser*)>& on_start_callback,
     HeadlessBrowser::Options options)
     : on_start_callback_(on_start_callback),
       options_(std::move(options)),
       browser_main_parts_(nullptr),
       default_browser_context_(nullptr),
+      agent_host_(nullptr),
       weak_ptr_factory_(this) {}
 
 HeadlessBrowserImpl::~HeadlessBrowserImpl() {}
 
 HeadlessBrowserContext::Builder
 HeadlessBrowserImpl::CreateBrowserContextBuilder() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return HeadlessBrowserContext::Builder(this);
 }
 
@@ skipping 46 matching lines @@
   return browser_main_parts_;
 }
 
 void HeadlessBrowserImpl::set_browser_main_parts(
     HeadlessBrowserMainParts* browser_main_parts) {
   DCHECK(!browser_main_parts_);
   browser_main_parts_ = browser_main_parts;
 }
 
 void HeadlessBrowserImpl::RunOnStartCallback() {
+  // We don't support the tethering domain on this agent host.
+  agent_host_ = content::DevToolsAgentHost::CreateForBrowser(
+      nullptr, content::DevToolsAgentHost::CreateServerSocketCallback());
+
   PlatformCreateWindow();
   on_start_callback_.Run(this);
   on_start_callback_ = base::Callback<void(HeadlessBrowser*)>();
 }
 
 HeadlessBrowserContext* HeadlessBrowserImpl::CreateBrowserContext(
     HeadlessBrowserContext::Builder* builder) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   std::unique_ptr<HeadlessBrowserContextImpl> browser_context =
@@ skipping 47 matching lines @@
 }
 
 HeadlessBrowserContext* HeadlessBrowserImpl::GetBrowserContextForId(
     const std::string& id) {
   auto find_it = browser_contexts_.find(id);
   if (find_it == browser_contexts_.end())
     return nullptr;
   return find_it->second.get();
 }
 
+HeadlessDevToolsTarget* HeadlessBrowserImpl::GetDevToolsTarget() {
+  return agent_host_ ? this : nullptr;
+}
+
+bool HeadlessBrowserImpl::AttachClient(HeadlessDevToolsClient* client) {
+  DCHECK(agent_host_);
+  return HeadlessDevToolsClientImpl::From(client)->AttachToHost(
+      agent_host_.get());
+}
+
+void HeadlessBrowserImpl::ForceAttachClient(HeadlessDevToolsClient* client) {
+  DCHECK(agent_host_);
+  HeadlessDevToolsClientImpl::From(client)->ForceAttachToHost(
+      agent_host_.get());
+}
+
+void HeadlessBrowserImpl::DetachClient(HeadlessDevToolsClient* client) {
+  DCHECK(agent_host_);
+  HeadlessDevToolsClientImpl::From(client)->DetachFromHost(agent_host_.get());
+}
+
+bool HeadlessBrowserImpl::IsAttached() {
+  DCHECK(agent_host_);
+  return agent_host_->IsAttached();
+}
+
 void RunChildProcessIfNeeded(int argc, const char** argv) {
   base::CommandLine::Init(argc, argv);
   const base::CommandLine& command_line(
       *base::CommandLine::ForCurrentProcess());
 
   if (!command_line.HasSwitch(::switches::kProcessType))
     return;
 
   HeadlessBrowser::Options::Builder builder(argc, argv);
   if (command_line.HasSwitch(switches::kUserAgent)) {
@@ skipping 18 matching lines @@
 
   // Child processes should not end up here.
   DCHECK(!base::CommandLine::ForCurrentProcess()->HasSwitch(
       ::switches::kProcessType));
 #endif
   return RunContentMain(std::move(options),
                         std::move(on_browser_start_callback));
 }
 
 }  // namespace headless