HTML MessagePort as mojo::MessagePipeHandle

content/browser/shared_worker/shared_worker_host.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/browser/shared_worker/shared_worker_host.h"
 
 #include "base/metrics/histogram_macros.h"
 #include "content/browser/devtools/shared_worker_devtools_manager.h"
-#include "content/browser/message_port_message_filter.h"
-#include "content/browser/message_port_service.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 
@@ skipping 29 matching lines @@
 }  // namespace
 
 SharedWorkerHost::SharedWorkerHost(SharedWorkerInstance* instance,
                                    SharedWorkerMessageFilter* filter,
                                    int worker_route_id)
     : instance_(instance),
       worker_document_set_(new WorkerDocumentSet()),
       worker_render_filter_(filter),
       worker_process_id_(filter->render_process_id()),
       worker_route_id_(worker_route_id),
+      next_connection_request_id_(1),
       creation_time_(base::TimeTicks::Now()),
       weak_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(instance_);
   DCHECK(worker_render_filter_);
 }
 
 SharedWorkerHost::~SharedWorkerHost() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UMA_HISTOGRAM_LONG_TIMES("SharedWorker.TimeToDeleted",
@@ skipping 12 matching lines @@
   params.security_policy_type = instance_->security_policy_type();
   params.creation_address_space = instance_->creation_address_space();
   params.pause_on_start = pause_on_start;
   params.route_id = worker_route_id_;
   Send(new WorkerProcessMsg_CreateWorker(params));
 
   for (const FilterInfo& info : filters_)
     info.filter()->Send(new ViewMsg_WorkerCreated(info.route_id()));
 }
 
-bool SharedWorkerHost::FilterConnectionMessage(
-    int route_id,
-    int sent_message_port_id,
-    SharedWorkerMessageFilter* incoming_filter) {
-  if (!IsAvailable() || !HasFilter(incoming_filter, route_id))
+bool SharedWorkerHost::SendConnectToWorker(int worker_route_id,
+                                           const MessagePort& port,
+                                           SharedWorkerMessageFilter* filter) {
+  if (!IsAvailable() || !HasFilter(filter, worker_route_id))
     return false;
 
-  Connect(route_id, sent_message_port_id, incoming_filter);
+  int connection_request_id = next_connection_request_id_++;
+
+  SetConnectionRequestID(filter, worker_route_id, connection_request_id);
+
+  // Send the connect message with the new connection_request_id.
+  Send(new WorkerMsg_Connect(worker_route_id_, connection_request_id, port));
   return true;
 }
 
 void SharedWorkerHost::FilterShutdown(SharedWorkerMessageFilter* filter) {
   RemoveFilters(filter);
   worker_document_set_->RemoveAll(filter);
   if (worker_document_set_->IsEmpty()) {
     // This worker has no more associated documents - shut it down.
     TerminateWorker();
   }
@@ skipping 54 matching lines @@
                       base::TimeTicks::Now() - creation_time_);
 }
 
 void SharedWorkerHost::WorkerScriptLoadFailed() {
   UMA_HISTOGRAM_TIMES("SharedWorker.TimeToScriptLoadFailed",
                       base::TimeTicks::Now() - creation_time_);
   for (const FilterInfo& info : filters_)
     info.filter()->Send(new ViewMsg_WorkerScriptLoadFailed(info.route_id()));
 }
 
-void SharedWorkerHost::WorkerConnected(int message_port_id) {
+void SharedWorkerHost::WorkerConnected(int connection_request_id) {
+  if (!instance_)
+    return;
   for (const FilterInfo& info : filters_) {
-    if (info.message_port_id() != message_port_id)
+    if (info.connection_request_id() != connection_request_id)
       continue;
     info.filter()->Send(
         new ViewMsg_WorkerConnected(info.route_id(), used_features_));
     return;
   }
 }
 
 void SharedWorkerHost::AllowFileSystem(
     const GURL& url,
     std::unique_ptr<IPC::Message> reply_msg) {
@@ skipping 65 matching lines @@
 
 bool SharedWorkerHost::HasFilter(SharedWorkerMessageFilter* filter,
                                  int route_id) const {
   for (const FilterInfo& info : filters_) {
     if (info.filter() == filter && info.route_id() == route_id)
       return true;
   }
   return false;
 }
 
-void SharedWorkerHost::Connect(int route_id,
-                               int sent_message_port_id,
-                               SharedWorkerMessageFilter* incoming_filter) {
-  DCHECK(IsAvailable());
-  DCHECK(HasFilter(incoming_filter, route_id));
-  DCHECK(worker_render_filter_);
-
-  int new_routing_id = worker_render_filter_->GetNextRoutingID();
-  MessagePortService::GetInstance()->UpdateMessagePort(
-      sent_message_port_id,
-      worker_render_filter_->message_port_message_filter(), new_routing_id);
-  SetMessagePortID(incoming_filter, route_id, sent_message_port_id);
-  Send(new WorkerMsg_Connect(worker_route_id_, sent_message_port_id,
-                             new_routing_id));
-
-  // Send any queued messages for the sent port.
-  MessagePortService::GetInstance()->SendQueuedMessagesIfPossible(
-      sent_message_port_id);
-}
-
-void SharedWorkerHost::SetMessagePortID(SharedWorkerMessageFilter* filter,
-                                        int route_id,
-                                        int message_port_id) {
-  for (FilterInfo& info : filters_) {
-    if (info.filter() == filter && info.route_id() == route_id) {
-      info.set_message_port_id(message_port_id);
+void SharedWorkerHost::SetConnectionRequestID(SharedWorkerMessageFilter* filter,
+                                              int route_id,
+                                              int connection_request_id) {
+  for (FilterList::iterator i = filters_.begin(); i != filters_.end(); ++i) {
+    if (i->filter() == filter && i->route_id() == route_id) {
+      i->set_connection_request_id(connection_request_id);
       return;
     }
   }
 }
 
 bool SharedWorkerHost::Send(IPC::Message* message) {
   return worker_render_filter_->Send(message);
 }
 
 }  // namespace content