Pass navigator.connect calls through to the browser process.

content/browser/navigator_connect/navigator_connect_dispatcher_host.cc

+// Copyright 2014 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 "content/browser/navigator_connect/navigator_connect_dispatcher_host.h"
+
+#include "content/browser/message_port_service.h"
+#include "content/common/navigator_connect_messages.h"
+
+namespace content {
+
+NavigatorConnectDispatcherHost::NavigatorConnectDispatcherHost()
+    : BrowserMessageFilter(NavigatorConnectMsgStart) {
+}
+
+NavigatorConnectDispatcherHost::~NavigatorConnectDispatcherHost() {
+}
+
+bool NavigatorConnectDispatcherHost::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(NavigatorConnectDispatcherHost, message)
+  IPC_MESSAGE_HANDLER(NavigatorConnectHostMsg_Connect, OnConnect)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void NavigatorConnectDispatcherHost::OnConnect(int thread_id,
+                                               int request_id,
+                                               const GURL& target_url,
+                                               int message_port_id) {
+  // TODO(mek): Actually setup a connection.

[palmer, 2014/12/10 01:40:44]

Should there be any check that the |target_url| has permission to talk
to/through the given message port? Does the |target_url| have to be in the same
origin as the code on the other end of the message port, or...?

[Marijn Kruisselbrink, 2014/12/10 17:14:26]

It is completely up to the (service worker controlling the) target_url if it
wants to accept or reject a connection. And generally |target_url| will be in a
different origin than the code on the other end of the message port. For the
target url to be able to make this decision, the idea currently is to give it
access to the origin of the page/worker that called navigator.connect (see
http://mkruisselbrink.github.io/navigator-connect/#idl-def-CrossOriginService...
for the interface the service worker will have access to when having to decide
if it should allow or deny a connection attempt).
Currently this origin of the client attempting to make a connection isn't passed
through yet (but then it isn't possible to actually setup a connection yet
either).

I suppose I could change the code to make it the responsibility of the service
to create a message port pair when it accepts a connection (and then pass one
port back from the service to the client), although it doesn't seem like that
really is any more secure than the current design where the client creates a
message port pair passing one port off to the service. Either way the browser
process will be in between and can ensure no messages are passed until the
connection as been accepted by the service.

+
+  // Close port since connection fails.
+  MessagePortService::GetInstance()->ClosePort(message_port_id);
+  Send(new NavigatorConnectMsg_ConnectResult(thread_id, request_id, false));
+}
+
+}  // namespace content