Adds a command-line flag indicating an open and listening socket to

headless/app/headless_shell.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 <sstream>
 #include <string>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/public/common/content_switches.h"
 #include "headless/app/headless_shell.h"
 #include "headless/app/headless_shell_switches.h"
+#include "headless/lib/browser/headless_devtools.h"
 #include "headless/public/headless_devtools_target.h"
 #include "headless/public/util/deterministic_http_protocol_handler.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_address.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace headless {
 namespace {
@@ skipping 409 matching lines @@
   }
 }
 
 void HeadlessShell::OnFileClosed(base::File::Error error_code) {
   Shutdown();
 }
 
 bool HeadlessShell::RemoteDebuggingEnabled() const {
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
-  return command_line.HasSwitch(switches::kRemoteDebuggingPort);
+  return (command_line.HasSwitch(switches::kRemoteDebuggingPort) ||
+          command_line.HasSwitch(switches::kRemoteDebuggingSocketFd));
 }
 
 bool ValidateCommandLine(const base::CommandLine& command_line) {
-  if (!command_line.HasSwitch(switches::kRemoteDebuggingPort)) {
+#if !defined(OS_POSIX)
+  if (command_line.HasSwitch(switches::kRemoteDebuggingSocketFd)) {
+    LOG(ERROR) << "Remote-debugging-socket can't be set on non-Posix systems";
+    return false;
+  }
+#endif
+  if (command_line.HasSwitch(switches::kRemoteDebuggingPort) &&
+      command_line.HasSwitch(switches::kRemoteDebuggingSocketFd)) {
+    LOG(ERROR) << "Remote-debugging-port and remote-debugging-socket "
+               << "can't both be set.";
+    return false;
+  }
+  if (!command_line.HasSwitch(switches::kRemoteDebuggingPort) &&
+      !command_line.HasSwitch(switches::kRemoteDebuggingSocketFd)) {
     if (command_line.GetArgs().size() <= 1)
       return true;
-    LOG(ERROR) << "Open multiple tabs is only supported when the "
-               << "remote debug port is set.";
+    LOG(ERROR) << "Open multiple tabs is only supported when "
+               << "remote debugging is enabled.";
     return false;
   }
   if (command_line.HasSwitch(switches::kDefaultBackgroundColor)) {
     LOG(ERROR) << "Setting default background color is disabled "
                << "when remote debugging is enabled.";
     return false;
   }
   if (command_line.HasSwitch(switches::kDumpDom)) {
     LOG(ERROR) << "Dump DOM is disabled when remote debugging is enabled.";
     return false;
@@ skipping 25 matching lines @@
   }
   return true;
 }
 
 int HeadlessShellMain(int argc, const char** argv) {
   base::CommandLine::Init(argc, argv);
   RunChildProcessIfNeeded(argc, argv);
   HeadlessShell shell;
   HeadlessBrowser::Options::Builder builder(argc, argv);
 
-  // Enable devtools if requested.
   const base::CommandLine& command_line(
       *base::CommandLine::ForCurrentProcess());
   if (!ValidateCommandLine(command_line))
     return EXIT_FAILURE;
 
   if (command_line.HasSwitch(::switches::kEnableCrashReporter))
     builder.SetCrashReporterEnabled(true);
   if (command_line.HasSwitch(switches::kCrashDumpsDir)) {
     builder.SetCrashDumpsDir(
         command_line.GetSwitchValuePath(switches::kCrashDumpsDir));
   }
 
+  // Enable devtools if requested, either by specifying a port (and optional
+  // address), or by specifying the fd of an already-open socket.
   if (command_line.HasSwitch(::switches::kRemoteDebuggingPort)) {
     std::string address = kDevToolsHttpServerAddress;
     if (command_line.HasSwitch(switches::kRemoteDebuggingAddress)) {
       address =
           command_line.GetSwitchValueASCII(switches::kRemoteDebuggingAddress);
       net::IPAddress parsed_address;
       if (!net::ParseURLHostnameToAddress(address, &parsed_address)) {
         LOG(ERROR) << "Invalid devtools server address";
         return EXIT_FAILURE;
       }
     }
     int parsed_port;
     std::string port_str =
         command_line.GetSwitchValueASCII(::switches::kRemoteDebuggingPort);
     if (!base::StringToInt(port_str, &parsed_port) ||
         !base::IsValueInRangeForNumericType<uint16_t>(parsed_port)) {
       LOG(ERROR) << "Invalid devtools server port";
       return EXIT_FAILURE;
     }
     net::IPAddress devtools_address;
     bool result = devtools_address.AssignFromIPLiteral(address);
     DCHECK(result);
-    builder.EnableDevToolsServer(net::IPEndPoint(
-        devtools_address, base::checked_cast<uint16_t>(parsed_port)));
+    const net::IPEndPoint endpoint(devtools_address,
+                                   base::checked_cast<uint16_t>(parsed_port));
+    builder.EnableDevToolsServer(endpoint);
+  } else if (command_line.HasSwitch(switches::kRemoteDebuggingSocketFd)) {
+    int parsed_fd;
+    std::string fd_str =
+        command_line.GetSwitchValueASCII(switches::kRemoteDebuggingSocketFd);
+    if (!base::StringToInt(fd_str, &parsed_fd) ||
+        !base::IsValueInRangeForNumericType<size_t>(parsed_fd)) {
+      LOG(ERROR) << "Invalid devtools server socket fd";
+      return EXIT_FAILURE;
+    }
+    builder.EnableDevToolsServer(base::checked_cast<size_t>(parsed_fd));
   }
 
   if (command_line.HasSwitch(switches::kProxyServer)) {
     std::string proxy_server =
         command_line.GetSwitchValueASCII(switches::kProxyServer);
     net::HostPortPair parsed_proxy_server =
         net::HostPortPair::FromString(proxy_server);
     if (parsed_proxy_server.host().empty() || !parsed_proxy_server.port()) {
       LOG(ERROR) << "Malformed proxy server url";
       return EXIT_FAILURE;
@@ skipping 38 matching lines @@
     if (net::HttpUtil::IsValidHeaderValue(ua))
       builder.SetUserAgent(ua);
   }
 
   return HeadlessBrowserMain(
       builder.Build(),
       base::Bind(&HeadlessShell::OnStart, base::Unretained(&shell)));
 }
 
 }  // namespace headless