Implement BroadcastChannel

third_party/WebKit/Source/modules/broadcastchannel/BroadcastChannelConnection.cpp

+// Copyright 2016 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 "modules/broadcastchannel/BroadcastChannelConnection.h"
+
+#include "platform/ThreadSafeFunctional.h"
+#include "platform/mojo/MojoHelper.h"
+#include "public/platform/Platform.h"
+#include "public/platform/ServiceRegistry.h"
+#include "public/platform/WebTaskRunner.h"
+#include "public/platform/WebTraceLocation.h"
+
+namespace blink {
+
+namespace {
+
+void connectToService(webmessaging::mojom::blink::BroadcastChannelServiceRequest request)
+{
+    DCHECK(Platform::current()->mainThread()->isCurrentThread());
+    Platform::current()->serviceRegistry()->connectToRemoteService(std::move(request));
+}
+
+webmessaging::mojom::blink::BroadcastChannelServicePtr& getThreadSpecificService()
+{
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<webmessaging::mojom::blink::BroadcastChannelServicePtr>, service, new ThreadSpecific<webmessaging::mojom::blink::BroadcastChannelServicePtr>);
+    if (!service.isSet()) {
+        Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE,
+            threadSafeBind(&connectToService, passed(mojo::GetProxy(&*service))));
+    }
+    return *service;
+}
+
+// BroadcastChannelConnection instances are jointly owned by the clients using
+// the connection. This map is merely a way for new clients to lookup the
+// connection to use, hence it stores weak references to connections.
+using ConnectionKey = std::pair<RefPtr<SecurityOrigin>, String>;
+using ConnectionMap = HeapHashMap<ConnectionKey, WeakMember<BroadcastChannelConnection>>;
+
+ConnectionMap* getConnectionMap()
+{
+    DEFINE_THREAD_SAFE_STATIC_LOCAL(ThreadSpecific<Persistent<ConnectionMap>>, connectionMap, new ThreadSpecific<Persistent<ConnectionMap>>);

[haraken, 2016/06/07 00:53:26]

How about creating a map from ExecutionContext* to BroadcastChannelConnection?
Then you won't need a thread-specific map. (We don't want to add unnecessary
dependency on thread-local storage.)

[Marijn Kruisselbrink, 2016/06/07 01:18:39]

Maybe I should just go back to not having any kind of connection map, like I had
in PS4. It really is more of a performance optimization that isn't obviously
useful (it really depends on how people might end up using BroadcastChannel),
and it does complicate things quite a bit. Not sure why in my mind having the
current .mojom interface was linked was also doing this local connections
optimization, but it really isn't. Having a per-thread
BroadcastChannelServicePtr (with the current interface) already will result in
the correct ordering. The only downside would be that according to a strict
reading of the spec all events for BroadcastChannel instances for the same
messages should be queued as tasks synchronously, and by having different mojo
calls for each instance it would be possible for other tasks to be queued in
between (which would be script observable). Not sure if that's worth the extra
complication of this connection map...

[haraken, 2016/06/07 01:29:56]

Yeah, let's exclude the optimization from this CL. We can iterate later.

+    if (!connectionMap.isSet()) {
+        *connectionMap = new ConnectionMap;
+        connectionMap->registerAsStaticReference();
+    }
+    return *connectionMap;
+}
+
+} // namespace
+
+// static
+BroadcastChannelConnection* BroadcastChannelConnection::getForChannel(const RefPtr<SecurityOrigin>& origin, const String& name)
+{
+    ConnectionMap* connectionMap = getConnectionMap();
+    auto it = connectionMap->find(ConnectionKey(origin, name));
+    if (it != connectionMap->end())
+        return it->value;
+
+    webmessaging::mojom::blink::BroadcastChannelServicePtr& service = getThreadSpecificService();
+    webmessaging::mojom::blink::BroadcastChannelClientAssociatedPtrInfo localClientInfo;
+    BroadcastChannelConnection* connection = new BroadcastChannelConnection(name, origin, &localClientInfo, service.associated_group());
+    service->Subscribe(origin, name, std::move(localClientInfo));
+    return connection;
+}
+
+BroadcastChannelConnection::~BroadcastChannelConnection()
+{
+}
+
+void BroadcastChannelConnection::registerClient(Client* client)
+{
+    m_clients.add(client);
+}
+
+void BroadcastChannelConnection::unregisterClient(Client* client)
+{
+    m_clients.remove(client);
+}
+
+void BroadcastChannelConnection::broadcast(Client* from, const String& message)
+{
+    for (Client* client : m_clients) {
+        if (client != from)
+            client->onMessage(message);
+    }
+    getThreadSpecificService()->Broadcast(from->origin(), from->name(), message);
+}
+
+DEFINE_TRACE(BroadcastChannelConnection)
+{
+    visitor->trace(m_clients);
+}
+
+BroadcastChannelConnection::BroadcastChannelConnection(const String& name, const RefPtr<SecurityOrigin>& origin, webmessaging::mojom::blink::BroadcastChannelClientAssociatedPtrInfo* clientInfo, mojo::AssociatedGroup* associatedGroup)
+    : m_name(name)
+    , m_origin(origin)
+    , m_binding(this, clientInfo, associatedGroup)
+{
+    m_binding.set_connection_error_handler(createBaseCallback(bind(&BroadcastChannelConnection::onError, WeakPersistentThisPointer<BroadcastChannelConnection>(this))));
+    auto result = getConnectionMap()->set(ConnectionKey(m_origin, m_name), this);
+    DCHECK(result.isNewEntry) << "There should only be one connection per channel per thread.";
+    ALLOW_UNUSED_LOCAL(result);
+}
+
+void BroadcastChannelConnection::OnMessage(const String& message)
+{
+    for (Client* client : m_clients)
+        client->onMessage(message);
+}
+
+void BroadcastChannelConnection::onError()
+{
+    for (Client* client : m_clients)
+        client->onError();
+    m_clients.clear();
+    getConnectionMap()->remove(ConnectionKey(m_origin, m_name));
+}
+
+} // namespace blink