Expose navigator.connect client side API in blink.

Source/modules/navigatorconnect/NavigatorConnect.cpp

Index: Source/modules/navigatorconnect/NavigatorConnect.cpp
diff --git a/Source/modules/navigatorconnect/NavigatorConnect.cpp b/Source/modules/navigatorconnect/NavigatorConnect.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2388975a41b6cc102c0826d88bb0ab549bca1331
--- /dev/null
+++ b/Source/modules/navigatorconnect/NavigatorConnect.cpp
@@ -0,0 +1,78 @@
+// 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 "config.h"
+#include "modules/navigatorconnect/NavigatorConnect.h"
+
+#include "bindings/core/v8/ScriptPromise.h"
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "core/dom/DOMException.h"
+#include "core/dom/ExceptionCode.h"
+#include "core/dom/MessageChannel.h"
+#include "core/dom/MessagePort.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebCallbacks.h"
+#include "public/platform/WebNavigatorConnectProvider.h"
+
+namespace blink {
+
+namespace {
+
+class ConnectCallbacks : public WebCallbacks<void, void> {
+public:
+    ConnectCallbacks(PassRefPtr<ScriptPromiseResolver> resolver, PassRefPtrWillBeRawPtr<MessagePort> port)
+        : m_resolver(resolver), m_port(port)
+    {
+        ASSERT(m_resolver);
+    }
+    ~ConnectCallbacks() override { }
+
+    void onSuccess() override
+    {
+        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped()) {
+            return;
+        }
+        m_resolver->resolve(m_port);
+    }
+
+    void onError() override
+    {
+        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped()) {
+            return;
+        }
+        m_resolver->reject(DOMException::create(AbortError));
+    }
+
+private:
+    RefPtr<ScriptPromiseResolver> m_resolver;
+    RefPtrWillBeMember<MessagePort> m_port;
+    WTF_MAKE_NONCOPYABLE(ConnectCallbacks);
+};
+
+} // namespace
+
+ScriptPromise NavigatorConnect::connect(ScriptState* scriptState, Navigator&, const String& url)
+{
+    WebNavigatorConnectProvider* provider = Platform::current()->navigatorConnectProvider();
+    if (!provider)
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    // Ownership of port1 of this channel is kept in the ConnectCallbacks and
+    // later passed to javascript (or released), the other port is disentangled
+    // and passed to the content layer to be transfered to the service provider.
+    // The MessageChannel object itself will be released at the end of this
+    // method, which is okay as it's only the ports within that matter.

[scheib, 2014/12/05 17:39:35]

It is a bit indirect that ownership of port2 is transfered out. The leakPtr is a
hint, but the ::connect signature doesn't mention ownership transfer.
WebMessagePortChannel class comments sort of deal with this as "object owns
itself", but actually I believe this code is relying on content or later owners
to call destroy manually.

This comment helps, it may be a bit more readable if it were in an enumerated
list form:
Ownership:
port1 ...
port2 ...
channel ...

[Marijn Kruisselbrink, 2014/12/08 18:50:36]

Done.

+    RefPtrWillBeRawPtr<MessageChannel> channel(MessageChannel::create(scriptState->executionContext()));
+    OwnPtr<WebMessagePortChannel> webchannel = channel->port2()->disentangle();
+    provider->connect(
+        scriptState->executionContext()->completeURL(url),
+        webchannel.leakPtr(),
+        new ConnectCallbacks(resolver, channel->port1()));
+    return promise;
+}
+
+
+} // namespace blink