headless: Initial headless embedder API implementation

headless/lib/browser/headless_devtools.cc

Index: headless/lib/browser/headless_devtools.cc
diff --git a/headless/lib/browser/headless_devtools.cc b/headless/lib/browser/headless_devtools.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8137be1a643ef5ff65aa3743512cff39285d9492
--- /dev/null
+++ b/headless/lib/browser/headless_devtools.cc
@@ -0,0 +1,103 @@
+// 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_devtools.h"
+
+#include "base/files/file_path.h"
+#include "components/devtools_http_handler/devtools_http_handler.h"
+#include "components/devtools_http_handler/devtools_http_handler_delegate.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/devtools_frontend_host.h"
+#include "content/public/browser/navigation_entry.h"
+#include "headless/lib/browser/headless_browser_context.h"
+#include "net/base/net_errors.h"
+#include "net/socket/tcp_server_socket.h"
+#include "ui/base/resource/resource_bundle.h"
+
+using devtools_http_handler::DevToolsHttpHandler;
+
+namespace headless {
+
+namespace {
+
+const int kBackLog = 10;
+
+class TCPServerSocketFactory : public DevToolsHttpHandler::ServerSocketFactory {
+ public:
+  TCPServerSocketFactory(const std::string& address, uint16_t port)

[Ryan Sleevi, 2016/02/25 22:04:36]

DESIGN: This is what IPEndPoint is meant to encapsulate.

I'm trying to get to why ListenWithAddressAndPort was introduced, as I think
that's an API wart, but for your case, it seems fine to go with the IPEndPoint
option - right?

[Sami, 2016/02/26 18:49:16]

Neat, IPEndPoint seems like good fit here. Done.

+      : address_(address), port_(port) {}
+
+ private:
+  // DevToolsHttpHandler::ServerSocketFactory implementation:
+  scoped_ptr<net::ServerSocket> CreateForHttpServer() override {
+    scoped_ptr<net::ServerSocket> socket(
+        new net::TCPServerSocket(nullptr, net::NetLog::Source()));
+    if (socket->ListenWithAddressAndPort(address_, port_, kBackLog) != net::OK)
+      return scoped_ptr<net::ServerSocket>();
+
+    return socket;
+  }
+
+  std::string address_;
+  uint16_t port_;
+
+  DISALLOW_COPY_AND_ASSIGN(TCPServerSocketFactory);
+};
+
+class HeadlessDevToolsDelegate
+    : public devtools_http_handler::DevToolsHttpHandlerDelegate {
+ public:
+  HeadlessDevToolsDelegate();
+  ~HeadlessDevToolsDelegate() override;
+
+  // devtools_http_handler::DevToolsHttpHandlerDelegate implementation:
+  std::string GetDiscoveryPageHTML() override;
+  std::string GetFrontendResource(const std::string& path) override;
+  std::string GetPageThumbnailData(const GURL& url) override;
+  content::DevToolsExternalAgentProxyDelegate* HandleWebSocketConnection(
+      const std::string& path) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(HeadlessDevToolsDelegate);
+};
+
+HeadlessDevToolsDelegate::HeadlessDevToolsDelegate() {}
+
+HeadlessDevToolsDelegate::~HeadlessDevToolsDelegate() {}
+
+std::string HeadlessDevToolsDelegate::GetDiscoveryPageHTML() {
+  return std::string();
+}
+
+std::string HeadlessDevToolsDelegate::GetFrontendResource(
+    const std::string& path) {
+  return content::DevToolsFrontendHost::GetFrontendResource(path).as_string();
+}
+
+std::string HeadlessDevToolsDelegate::GetPageThumbnailData(const GURL& url) {
+  return std::string();
+}
+
+content::DevToolsExternalAgentProxyDelegate*
+HeadlessDevToolsDelegate::HandleWebSocketConnection(const std::string& path) {
+  return nullptr;
+}
+
+}  // namespace
+
+scoped_ptr<DevToolsHttpHandler> CreateLocalDevToolsHttpHandler(
+    HeadlessBrowserContext* browser_context) {
+  std::string address = browser_context->options().devtools_http_address;
+  int port = browser_context->options().devtools_http_port;
+  DCHECK(address.size());

[Ryan Sleevi, 2016/02/25 22:04:36]

DCHECK(!address.empty())

[When dealing with STL containers, .empty() when it exists will always be O(1),
while for some containers, like std::list, .size() can be O(N); for that reason,
whenever using the STL, it's easiest to just idiomatically use .empty()]

[Sami, 2016/02/26 18:49:16]

Done.

+  DCHECK_GE(port, 0);

[Ryan Sleevi, 2016/02/25 22:04:36]

This doesn't seem one of the 'recommended' DCHECKs (see recent chromium-dev
thread)

The same applies to line 93, to be clear, but I wanted to add that remark about
.empty() ;)

[Sami, 2016/02/26 18:49:16]

Did you mean the thread about DCHECKs and pointer dereferences? TBH, I'm not
completely sure how that applies here. The main thing I'm guarding against is
internal API contract violations where we try to turn on the devtools server
without a valid address. I've moved the dcheck into the socket factory -- maybe
it's more obvious that way.

+  scoped_ptr<DevToolsHttpHandler::ServerSocketFactory> socket_factory(
+      new TCPServerSocketFactory(address, port));
+  return make_scoped_ptr(new DevToolsHttpHandler(
+      std::move(socket_factory), std::string(), new HeadlessDevToolsDelegate(),
+      browser_context->GetPath(), base::FilePath(), std::string(),
+      browser_context->options().user_agent));
+}
+
+}  // namespace headless