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

Source/modules/navigatorconnect/ServicePort.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/ServicePort.h"
+
+#include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/SerializedScriptValueFactory.h"
+#include "core/dom/MessagePort.h"
+#include "modules/navigatorconnect/ServicePortCollection.h"
+#include "public/platform/Platform.h"
+#include "public/platform/modules/navigator_services/WebServicePortProvider.h"
+
+namespace blink {
+
+ServicePort* ServicePort::create(WeakPtrWillBeRawPtr<ServicePortCollection> collection, const WebServicePort& port)
+{
+    return new ServicePort(collection, port);
+}
+
+ServicePort::~ServicePort()
+{
+    if (m_isOpen && m_collection) {
+        m_collection->closePort(this);
+    }
+}
+
+String ServicePort::targetURL() const
+{
+    return m_port.targetUrl.string();
+}
+
+String ServicePort::name() const
+{
+    return m_port.name;
+}
+
+ScriptValue ServicePort::data(ScriptState* scriptState) const
+{
+    if (!m_serializedData)
+        return ScriptValue::createNull(scriptState);
+
+    // TODO(mek): Deserializing this every time it is accessed is a bit wasteful,
+    // investigate caching this similar to how MessageEvent caches data.

[haraken, 2015/06/24 23:59:59]

If this really becomes a performance problem, we can consider caching it
somehow. However, it is going to be very complicated. The way MessageEvent
caches it is not already correct -- it causes a memory leak :)

[Marijn Kruisselbrink, 2015/06/25 01:07:26]

Ah, okay, I'll just remove that comment for now then.

+    return ScriptValue(scriptState, m_serializedData->deserialize(scriptState->isolate()));
+}
+
+void ServicePort::postMessage(ExecutionContext* executionContext, PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, ExceptionState& exceptionState)
+{
+    OwnPtr<MessagePortChannelArray> channels;
+    if (ports) {
+        channels = MessagePort::disentanglePorts(executionContext, ports, exceptionState);
+        if (exceptionState.hadException())
+            return;
+    }
+
+    WebString messageString = message->toWireString();
+    OwnPtr<WebMessagePortChannelArray> webChannels = MessagePort::toWebMessagePortChannelArray(channels.release());
+    if (m_collection) {
+        WebServicePortProvider* provider = m_collection->provider();
+        provider->postMessage(m_port.id, messageString, webChannels.leakPtr());
+    }
+}
+
+void ServicePort::close()
+{
+    // TODO(mek): Figure out if this should throw instead of just quietly fail.
+    if (!m_isOpen)
+        return;
+
+    if (m_collection) {
+        m_collection->closePort(this);
+        m_collection = nullptr;
+    }
+    m_isOpen = false;
+}
+
+ServicePort::ServicePort(WeakPtrWillBeRawPtr<ServicePortCollection> collection, const WebServicePort& port)
+    : m_isOpen(true), m_port(port), m_collection(collection)
+{
+    if (!m_port.data.isEmpty()) {
+        m_serializedData = SerializedScriptValueFactory::instance().createFromWire(m_port.data);
+    }
+}
+
+} // namespace blink
+