Implement BroadcastChannel

components/webmessaging/broadcast_channel_service.cc

Index: components/webmessaging/broadcast_channel_service.cc
diff --git a/components/webmessaging/broadcast_channel_service.cc b/components/webmessaging/broadcast_channel_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..8287a472bb2205bb8f2f498de766859157e47312
--- /dev/null
+++ b/components/webmessaging/broadcast_channel_service.cc
@@ -0,0 +1,116 @@
+// 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 "components/webmessaging/broadcast_channel_service.h"
+
+#include "base/bind.h"
+#include "base/stl_util.h"
+#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/interface_ptr_set.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+
+namespace webmessaging {
+
+// There is a one-to-one mapping of BroadcastChannel instances in the renderer
+// and Connection instances in the browser. The Connection is owned by a
+// BroadcastChannelService.
+class BroadcastChannelService::Connection
+    : public mojom::BroadcastChannelClient {
+ public:
+  Connection(const url::Origin& origin,
+             const mojo::String& name,
+             mojom::BroadcastChannelClientAssociatedPtrInfo client,
+             mojom::BroadcastChannelClientAssociatedRequest connection,
+             webmessaging::BroadcastChannelService* service);
+
+  void OnMessage(const mojo::String& message) override;
+  void MessageToClient(const mojo::String& message) const {
+    client_->OnMessage(message);
+  }
+  const url::Origin& origin() const { return origin_; }
+  const std::string& name() const { return name_; }
+
+  void set_connection_error_handler(const base::Closure& error_handler) {
+    binding_.set_connection_error_handler(error_handler);
+    client_.set_connection_error_handler(error_handler);
+  }
+
+ private:
+  mojo::AssociatedBinding<mojom::BroadcastChannelClient> binding_;
+  mojom::BroadcastChannelClientAssociatedPtr client_;
+
+  webmessaging::BroadcastChannelService* service_;
+  url::Origin origin_;
+  std::string name_;
+};
+
+BroadcastChannelService::Connection::Connection(
+    const url::Origin& origin,
+    const mojo::String& name,
+    mojom::BroadcastChannelClientAssociatedPtrInfo client,
+    mojom::BroadcastChannelClientAssociatedRequest connection,
+    webmessaging::BroadcastChannelService* service)
+    : binding_(this, std::move(connection)),
+      service_(service),
+      origin_(origin),
+      name_(name) {
+  client_.Bind(std::move(client));
+}
+
+void BroadcastChannelService::Connection::OnMessage(
+    const mojo::String& message) {
+  service_->ReceivedMessageOnConnection(this, message);
+}
+
+BroadcastChannelService::BroadcastChannelService() {}
+
+void BroadcastChannelService::Connect(
+    mojo::InterfaceRequest<mojom::BroadcastChannelService> request) {
+  bindings_.AddBinding(this, std::move(request));
+}
+
+void BroadcastChannelService::ConnectToChannel(
+    const url::Origin& origin,
+    const mojo::String& name,
+    mojom::BroadcastChannelClientAssociatedPtrInfo client,
+    mojom::BroadcastChannelClientAssociatedRequest connection) {
+  std::unique_ptr<Connection> c(new Connection(origin, name, std::move(client),
+                                               std::move(connection), this));
+  c->set_connection_error_handler(
+      base::Bind(&BroadcastChannelService::UnregisterConnection,
+                 base::Unretained(this), c.get()));
+  connections_[origin].insert(std::make_pair(name, std::move(c)));
+}
+
+BroadcastChannelService::~BroadcastChannelService() {}
+
+void BroadcastChannelService::UnregisterConnection(Connection* c) {
+  url::Origin origin = c->origin();
+  auto& connections = connections_[origin];
+  for (auto it = connections.lower_bound(c->name()),
+            end = connections.upper_bound(c->name());
+       it != end; ++it) {
+    if (it->second.get() == c) {
+      connections.erase(it);
+      break;
+    }
+  }
+  if (connections.empty())
+    connections_.erase(origin);
+}
+
+void BroadcastChannelService::ReceivedMessageOnConnection(
+    Connection* c,
+    const mojo::String& message) {
+  auto& connections = connections_[c->origin()];
+  for (auto it = connections.lower_bound(c->name()),
+            end = connections.upper_bound(c->name());
+       it != end; ++it) {
+    if (it->second.get() != c) {
+      it->second->MessageToClient(message);
+    }

[kinuko, 2016/06/24 14:28:03]

nit: no {} for one-line body for consistency

[Marijn Kruisselbrink, 2016/06/24 18:12:26]

done

+  }
+}
+
+}  // namespace webmessaging