Pass navigator.connect calls through to the browser process.

content/child/navigator_connect/navigator_connect_provider.cc

+// 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 "content/child/navigator_connect/navigator_connect_provider.h"
+
+#include "base/lazy_instance.h"
+#include "content/child/thread_safe_sender.h"
+#include "content/child/webmessageportchannel_impl.h"
+#include "content/common/navigator_connect_messages.h"
+#include "third_party/WebKit/public/platform/WebCallbacks.h"
+#include "third_party/WebKit/public/platform/WebURL.h"
+
+namespace content {
+
+namespace {
+
+base::LazyInstance<base::ThreadLocalPointer<NavigatorConnectProvider>>::Leaky
+    g_provider_tls = LAZY_INSTANCE_INITIALIZER;
+
+NavigatorConnectProvider* const kHasBeenDeleted =
+    reinterpret_cast<NavigatorConnectProvider*>(0x1);
+
+int CurrentWorkerId() {
+  return WorkerTaskRunner::Instance()->CurrentWorkerId();
+}
+
+}  // namespace
+
+NavigatorConnectProvider::NavigatorConnectProvider(
+    ThreadSafeSender* thread_safe_sender)
+    : thread_safe_sender_(thread_safe_sender) {
+  g_provider_tls.Pointer()->Set(this);
+}
+
+NavigatorConnectProvider::~NavigatorConnectProvider() {
+  g_provider_tls.Pointer()->Set(kHasBeenDeleted);
+}
+
+void NavigatorConnectProvider::connect(
+    const blink::WebURL& target_url,
+    blink::WebMessagePortChannel* port,
+    blink::WebCallbacks<void, void>* callbacks) {
+  int request_id = requests_.Add(callbacks);
+
+  // Extract the port ID.
+  WebMessagePortChannelImpl* webchannel =
+      static_cast<WebMessagePortChannelImpl*>(port);
+  int message_port_id = webchannel->message_port_id();
+  DCHECK(message_port_id != MSG_ROUTING_NONE);
+  webchannel->QueueMessages();
+
+  thread_safe_sender_->Send(new NavigatorConnectHostMsg_Connect(
+      CurrentWorkerId(), request_id, target_url, message_port_id));
+}
+
+void NavigatorConnectProvider::OnMessageReceived(const IPC::Message& msg) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(NavigatorConnectProvider, msg)
+  IPC_MESSAGE_HANDLER(NavigatorConnectMsg_ConnectResult, OnConnectResult)
+  IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  DCHECK(handled) << "Unhandled message:" << msg.type();
+}
+
+NavigatorConnectProvider* NavigatorConnectProvider::ThreadSpecificInstance(
+    ThreadSafeSender* thread_safe_sender) {
+  if (g_provider_tls.Pointer()->Get() == kHasBeenDeleted) {
+    NOTREACHED() << "Re-instantiating TLS NavigatorConnectProvider.";
+    g_provider_tls.Pointer()->Set(NULL);
+  }
+  if (g_provider_tls.Pointer()->Get())
+    return g_provider_tls.Pointer()->Get();
+
+  NavigatorConnectProvider* provider =
+      new NavigatorConnectProvider(thread_safe_sender);
+  if (WorkerTaskRunner::Instance()->CurrentWorkerId())
+    WorkerTaskRunner::Instance()->AddStopObserver(provider);
+  return provider;
+}
+
+void NavigatorConnectProvider::OnConnectResult(int thread_id,
+                                               int request_id,
+                                               bool allow_connect) {
+  ConnectCallback* callbacks = requests_.Lookup(request_id);
+  DCHECK(callbacks);
+
+  if (allow_connect) {
+    callbacks->onSuccess();
+  } else {
+    callbacks->onError();
+  }
+  requests_.Remove(request_id);
+}
+
+void NavigatorConnectProvider::OnWorkerRunLoopStopped() {
+  delete this;
+}
+
+}  // namespace content