public:

TCPServerSocketFactory(const std::string& address, int port)

: address_(address), port_(port) {}

// disable copy

TCPServerSocketFactory(const TCPServerSocketFactory&) = delete;

TCPServerSocketFactory& operator=(const TCPServerSocketFactory&) = delete;

private:

// content::ServerSocketFactory.

std::unique_ptr<net::ServerSocket> CreateForHttpServer() override {

auto socket =

std::make_unique<net::TCPServerSocket>(nullptr, net::NetLogSource());

if (socket->ListenWithAddressAndPort(address_, port_, 10) != net::OK)

return std::unique_ptr<net::ServerSocket>();

return socket;

}

std::unique_ptr<net::ServerSocket> CreateForTethering(

std::string* name) override {

return std::unique_ptr<net::ServerSocket>();

}

std::string address_;

uint16_t port_;

auto& command_line = *base::CommandLine::ForCurrentProcess();

// See if the user specified a port on the command line (useful for

// automation). If not, use an ephemeral port by specifying 0.

int port = 0;

if (command_line.HasSwitch(switches::kRemoteDebuggingPort)) {

int temp_port;

std::string port_str =

command_line.GetSwitchValueASCII(switches::kRemoteDebuggingPort);

if (base::StringToInt(port_str, &temp_port) && temp_port >= 0 &&

temp_port < 65535) {

port = temp_port;

} else {

DLOG(WARNING) << "Invalid http debugger port number " << temp_port;

}

}

return std::make_unique<TCPServerSocketFactory>("127.0.0.1", port);

base::FilePath session_data;

base::PathService::Get(DIR_SESSION_DATA, &session_data);

content::DevToolsAgentHost::StartRemoteDebuggingServer(

CreateSocketFactory(), session_data, base::FilePath());

content::DevToolsAgentHostClientChannel* channel,

base::span<const uint8_t> message,

NotHandledCallback callback) {

crdtp::Dispatchable dispatchable(crdtp::SpanFrom(message));

DCHECK(dispatchable.ok());

if (crdtp::SpanEquals(crdtp::SpanFrom(kBrowserCloseMethod),

dispatchable.Method())) {

// In theory, we should respond over the protocol saying that the

// Browser.close was handled. But doing so requires instantiating the

// protocol UberDispatcher and generating proper protocol handlers.

// Since we only have one method and it is supposed to close Electron,

// we don't need to add this complexity. Should we decide to support

// methods like Browser.setWindowBounds, we'll need to do it though.

content::GetUIThreadTaskRunner({})->PostTask(

FROM_HERE, base::BindOnce([]() { Browser::Get()->Quit(); }));

return;

}

std::move(callback).Run(message);