Update client side navigator.connect API to use ServicePortCollection [1/3]

Source/modules/navigatorconnect/ServicePortCollection.cpp

 // 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 "config.h"
 #include "modules/navigatorconnect/ServicePortCollection.h"
 
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "bindings/core/v8/SerializedScriptValueFactory.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/ExceptionCode.h"
+#include "core/dom/MessagePort.h"
+#include "core/events/MessageEvent.h"
 #include "modules/EventTargetModules.h"
+#include "modules/navigatorconnect/ServicePort.h"
+#include "modules/navigatorconnect/ServicePortConnectOptions.h"
+#include "public/platform/Platform.h"
+#include "public/platform/modules/navigator_services/WebServicePortProvider.h"
 
 namespace blink {
 
+namespace {
+
+class ConnectCallbacks : public WebServicePortConnectCallbacks {
+public:
+    ConnectCallbacks(PassRefPtrWillBeRawPtr<ScriptPromiseResolver> resolver, PassRefPtrWillBeRawPtr<ServicePortCollection> collection, const KURL& targetUrl, const String& portName, const String& serializedPortData)
+        : m_resolver(resolver), m_collection(collection), m_targetUrl(targetUrl), m_portName(portName), m_serializedPortData(serializedPortData)
+    {
+        ASSERT(m_resolver);
+    }
+
+    ~ConnectCallbacks() override { }
+
+    void onSuccess(WebServicePortID* portIdRaw) override
+    {
+        OwnPtr<WebServicePortID> webPortId = adoptPtr(portIdRaw);
+        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped()) {
+            return;
+        }
+        WebServicePort webPort;
+        webPort.id = *webPortId;
+        webPort.targetUrl = m_targetUrl;
+        webPort.name = m_portName;
+        webPort.data = m_serializedPortData;
+#if !ENABLE(OILPAN)
+        ServicePort* port = ServicePort::create(m_collection->weakPtr(), webPort);
+#else
+        ServicePort* port = ServicePort::create(m_collection, webPort);
+#endif
+        m_collection->addPort(port);
+        m_resolver->resolve(port);
+    }
+
+    void onError() override
+    {
+        // TODO(mek): Pass actual error code back.
+        if (!m_resolver->executionContext() || m_resolver->executionContext()->activeDOMObjectsAreStopped()) {
+            return;
+        }
+        m_resolver->reject(DOMException::create(AbortError));
+    }
+
+private:
+    RefPtrWillBePersistent<ScriptPromiseResolver> m_resolver;
+    RefPtrWillBePersistent<ServicePortCollection> m_collection;
+    KURL m_targetUrl;
+    String m_portName;
+    String m_serializedPortData;
+
+    WTF_MAKE_NONCOPYABLE(ConnectCallbacks);
+};
+
+} // namespace
+
 PassRefPtrWillBeRawPtr<ServicePortCollection> ServicePortCollection::create(ExecutionContext* context)
 {
     return adoptRefWillBeNoop(new ServicePortCollection(context));
 }
 
-ServicePortCollection::ServicePortCollection(ExecutionContext* context)
-    : ContextLifecycleObserver(context)
-{
-}
-
 ServicePortCollection::~ServicePortCollection()
 {
 }
 
-ScriptPromise ServicePortCollection::connect(ScriptState* scriptState, const String& url, const ServicePortConnectOptions& options)
+void ServicePortCollection::addPort(ServicePort* port)
 {
-    return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+    m_ports.append(port);
+}
+
+void ServicePortCollection::closePort(ServicePort* port)
+{
+    m_ports.remove(m_ports.find(port));
+    m_provider->closePort(port->id());
+}
+
+ScriptPromise ServicePortCollection::connect(ScriptState* scriptState, const String& url, const ServicePortConnectOptions& options, ExceptionState& exceptionState)
+{
+    if (!m_provider)
+        return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
+
+    RefPtr<SerializedScriptValue> portData;
+    if (options.hasData()) {
+        portData = SerializedScriptValueFactory::instance().create(options.data().isolate(), options.data(), nullptr, exceptionState);
+        if (exceptionState.hadException())
+            return exceptionState.reject(scriptState);
+    }
+    RefPtrWillBeRawPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    KURL targetUrl = scriptState->executionContext()->completeURL(url);
+    m_provider->connect(
+        targetUrl,
+        scriptState->executionContext()->securityOrigin()->toString(),
+        new ConnectCallbacks(resolver, this, targetUrl, options.name(), portData ? portData->toWireString() : String()));
+    return promise;
 }
 
 ScriptPromise ServicePortCollection::match(ScriptState* scriptState, const ServicePortMatchOptions& options)
 {
     return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
 }
 
 ScriptPromise ServicePortCollection::matchAll(ScriptState* scriptState, const ServicePortMatchOptions& options)
 {
     return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError));
 }
 
 const AtomicString& ServicePortCollection::interfaceName() const
 {
     return EventTargetNames::ServicePortCollection;
 }
 
 ExecutionContext* ServicePortCollection::executionContext() const
 {
     return ContextLifecycleObserver::executionContext();
 }
 
+void ServicePortCollection::postMessage(WebServicePortID portId, const WebString& messageString, const WebMessagePortChannelArray& webChannels)
+{
+    OwnPtr<MessagePortChannelArray> channels;
+    if (webChannels.size()) {
+        channels = adoptPtr(new MessagePortChannelArray(webChannels.size()));
+        for (size_t i = 0; i < webChannels.size(); ++i)
+            (*channels)[i] = adoptPtr(webChannels[i]);
+    }
+    RefPtr<SerializedScriptValue> message = SerializedScriptValueFactory::instance().createFromWire(messageString);
+
+    OwnPtrWillBeRawPtr<MessagePortArray> ports = MessagePort::entanglePorts(*executionContext(), channels.release());
+    RefPtrWillBeRawPtr<Event> evt = MessageEvent::create(ports.release(), message.release());
+    // TODO(mek): Lookup ServicePort and set events source attribute.
+    dispatchEvent(evt.release(), ASSERT_NO_EXCEPTION);
+}
+
 DEFINE_TRACE(ServicePortCollection)
 {
     EventTargetWithInlineData::trace(visitor);
     ContextLifecycleObserver::trace(visitor);
 }
 
+ServicePortCollection::ServicePortCollection(ExecutionContext* context)
+    : ContextLifecycleObserver(context)
+    , m_provider(adoptPtr(Platform::current()->createServicePortProvider(this)))
+#if !ENABLE(OILPAN)
+    , m_weakFactory(this)
+#endif
+{
+}
+
 } // namespace blink