WIP DO NOT COMMIT chromium side of navigator.connect

content/browser/service_worker/service_worker_dispatcher_host.cc

 // Copyright 2013 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/browser/service_worker/service_worker_dispatcher_host.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
+#include "content/browser/service_worker/navigator_connect_message_handler.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_handle.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_registration_handle.h"
 #include "content/browser/service_worker/service_worker_utils.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/service_worker_messages.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/net_util.h"
 #include "third_party/WebKit/public/platform/WebServiceWorkerError.h"
 #include "url/gurl.h"
 
 using blink::WebServiceWorkerError;
 
 namespace content {
@@ skipping 159 matching lines @@
                         OnReportConsoleMessage)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_IncrementServiceWorkerRefCount,
                         OnIncrementServiceWorkerRefCount)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_DecrementServiceWorkerRefCount,
                         OnDecrementServiceWorkerRefCount)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_IncrementRegistrationRefCount,
                         OnIncrementRegistrationRefCount)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_DecrementRegistrationRefCount,
                         OnDecrementRegistrationRefCount)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_TerminateWorker, OnTerminateWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NavigatorConnect,
+                        OnNavigatorConnect)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   if (!handled && GetContext()) {
     handled =
         GetContext()->embedded_worker_registry()->OnMessageReceived(message);
     if (!handled)
       BadMessageReceived();
   }
 
@@ skipping 652 matching lines @@
 void ServiceWorkerDispatcherHost::OnTerminateWorker(int handle_id) {
   ServiceWorkerHandle* handle = handles_.Lookup(handle_id);
   if (!handle) {
     BadMessageReceived();
     return;
   }
   handle->version()->StopWorker(
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 }
 
+void ServiceWorkerDispatcherHost::OnNavigatorConnect(int thread_id,
+                                                     int request_id,
+                                                     const GURL& target_url,
+                                                     int message_port_id) {
+  LOG(INFO) << "OnNavigatorConnect " << target_url << " " << message_port_id;
+  if (!GetContext()) {
+    LOG(INFO) << "No SW context";
+    MessagePortService::GetInstance()->ClosePort(message_port_id);
+    Send(new ServiceWorkerMsg_NavigatorConnectResult(thread_id, request_id,
+                                                     false));
+    return;
+  }
+  NavigatorConnectMessageHandler* message_handler =
+      GetContext()->navigator_connect_message_handler();
+  if (!message_handler) {
+    LOG(INFO) << "No message handler";
+    MessagePortService::GetInstance()->ClosePort(message_port_id);
+    Send(new ServiceWorkerMsg_NavigatorConnectResult(thread_id, request_id,
+                                                     false));
+    return;
+  }
+
+  message_handler->RegisterMessagePort(
+      CrossOriginServiceWorkerClient(target_url, message_port_id));
+
+  GetContext()->storage()->FindRegistrationForDocument(
+      target_url,
+      base::Bind(&ServiceWorkerDispatcherHost::NavigatorConnectGotRegistration,
+                 this,
+                 NavigatorConnectParams(thread_id, request_id, message_port_id),
+                 target_url));
+}
+
+void ServiceWorkerDispatcherHost::NavigatorConnectGotRegistration(
+    const NavigatorConnectParams& params,
+    const GURL& target_url,
+    ServiceWorkerStatusCode status,
+    const scoped_refptr<ServiceWorkerRegistration>& registration) {
+  LOG(INFO) << status;
+  if (status != SERVICE_WORKER_OK) {
+    LOG(INFO) << "No SW found";
+    // No SW found, reject connection attempt.
+    NavigatorConnectResult(params, registration, SERVICE_WORKER_OK, false);
+    return;
+  }
+
+  ServiceWorkerVersion* active_version = registration->active_version();
+  if (!active_version) {
+    LOG(INFO) << "No active version";
+    // No active version, reject connection attempt.
+    NavigatorConnectResult(params, registration, SERVICE_WORKER_OK, false);
+    return;
+  }
+
+  active_version->DispatchCrossOriginConnectEvent(
+      base::Bind(&ServiceWorkerDispatcherHost::NavigatorConnectResult, this,
+                 params, registration),
+      target_url, params.message_port_id);
+}
+
+void ServiceWorkerDispatcherHost::NavigatorConnectResult(
+    const NavigatorConnectParams& params,
+    const scoped_refptr<ServiceWorkerRegistration>& registration,
+    ServiceWorkerStatusCode status,
+    bool allow_connect) {
+  LOG(INFO) << "Result " << status << " " << allow_connect;
+  if (!allow_connect) {
+    GetContext()->navigator_connect_message_handler()->ClearRegistration(
+        params.message_port_id);
+  } else {
+    GetContext()
+        ->navigator_connect_message_handler()
+        ->SetServiceWorkerRegistation(params.message_port_id, registration);
+  }
+  Send(new ServiceWorkerMsg_NavigatorConnectResult(
+      params.thread_id, params.request_id, allow_connect));
+}
+
 }  // namespace content