Initial implementation of stashed message ports, content side

content/browser/service_worker/service_worker_version.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_version.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/message_port_message_filter.h"
 #include "content/browser/message_port_service.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.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_metrics.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_utils.h"
+#include "content/browser/service_worker/stashed_port_manager.h"
 #include "content/browser/storage_partition_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/page_navigator.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/common/child_process_host.h"
@@ skipping 119 matching lines @@
   }
   callback.Run(status);
 }
 
 void RunErrorCrossOriginConnectCallback(
     const ServiceWorkerVersion::CrossOriginConnectCallback& callback,
     ServiceWorkerStatusCode status) {
   callback.Run(status, false /* accept_connection */);
 }
 
+void RunErrorSendStashedPortsCallback(
+    const ServiceWorkerVersion::SendStashedPortsCallback& callback,
+    ServiceWorkerStatusCode status) {
+  callback.Run(status, std::vector<int>());
+}
+
 using WindowOpenedCallback = base::Callback<void(int, int)>;
 
 // The WindowOpenedObserver class is a WebContentsObserver that will wait for a
 // new Window's WebContents to be initialized, run the |callback| passed to its
 // constructor then self destroy.
 // The callback will receive the process and frame ids. If something went wrong
 // those will be (kInvalidUniqueID, MSG_ROUTING_NONE).
 // The callback will be called in the IO thread.
 class WindowOpenedObserver : public WebContentsObserver {
  public:
@@ skipping 180 matching lines @@
     case ServiceWorkerVersion::ACTIVATED:
       return true;
     case ServiceWorkerVersion::REDUNDANT:
       NOTREACHED() << "Cannot use REDUNDANT here.";
       return false;
   }
   NOTREACHED() << "Unexpected status: " << status;
   return false;
 }
 
+scoped_refptr<StashedPortManager> GetStashedPortManagerOnUIThread(
+    const scoped_refptr<ServiceWorkerContextWrapper>& context_wrapper) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  return context_wrapper->storage_partition()->GetStashedPortManager();
+}
+
+void StashPortImpl(
+    const scoped_refptr<ServiceWorkerVersion> service_worker,

[falken, 2015/05/15 06:08:02]

Can this be const&? And stashed_port_manager too?

[Marijn Kruisselbrink, 2015/05/18 22:19:36]

Of course it can, done.

+    int message_port_id,
+    const base::string16& name,
+    const scoped_refptr<StashedPortManager> stashed_port_manager) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  stashed_port_manager->AddPort(service_worker.get(), message_port_id, name);
+}
+
 }  // namespace
 
 const int ServiceWorkerVersion::kStartWorkerTimeoutMinutes = 5;
 const int ServiceWorkerVersion::kRequestTimeoutMinutes = 5;
 
 ServiceWorkerVersion::ServiceWorkerVersion(
     ServiceWorkerRegistration* registration,
     const GURL& script_url,
     int64 version_id,
     base::WeakPtr<ServiceWorkerContextCore> context)
@@ skipping 411 matching lines @@
   MessagePortMessageFilter* filter =
       embedded_worker_->message_port_message_filter();
   std::vector<int> new_routing_ids;
   filter->UpdateMessagePortsWithNewRoutes(sent_message_ports, &new_routing_ids);
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_CrossOriginMessageToWorker(
           client, message, sent_message_ports, new_routing_ids));
   RunSoon(base::Bind(callback, status));
 }
 
+void ServiceWorkerVersion::SendStashedMessagePorts(
+    const std::vector<TransferredMessagePort>& stashed_message_ports,
+    const std::vector<base::string16>& port_names,
+    const SendStashedPortsCallback& callback) {
+  if (running_status() != RUNNING) {
+    // Schedule calling this method after starting the worker.
+    StartWorker(base::Bind(
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(),
+        base::Bind(&RunErrorSendStashedPortsCallback, callback),
+        base::Bind(&self::SendStashedMessagePorts, weak_factory_.GetWeakPtr(),
+                   stashed_message_ports, port_names, callback)));
+    return;
+  }
+
+  MessagePortMessageFilter* filter =
+      embedded_worker_->message_port_message_filter();
+  std::vector<int> new_routing_ids(stashed_message_ports.size());
+  for (size_t i = 0; i < stashed_message_ports.size(); ++i)
+    new_routing_ids[i] = filter->GetNextRoutingID();
+
+  ServiceWorkerStatusCode status =
+      embedded_worker_->SendMessage(ServiceWorkerMsg_SendStashedMessagePorts(
+          stashed_message_ports, new_routing_ids, port_names));
+  RunSoon(base::Bind(callback, status, new_routing_ids));
+}
+
 void ServiceWorkerVersion::AddControllee(
     ServiceWorkerProviderHost* provider_host) {
   const std::string& uuid = provider_host->client_uuid();
   CHECK(!provider_host->client_uuid().empty());
   DCHECK(!ContainsKey(controllee_map_, uuid));
   controllee_map_[uuid] = provider_host;
   // Keep the worker alive a bit longer right after a new controllee is added.
   RestartTick(&idle_time_);
 }
 
@@ skipping 234 matching lines @@
                         OnClearCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToClient,
                         OnPostMessageToClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FocusClient,
                         OnFocusClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SkipWaiting,
                         OnSkipWaiting)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ClaimClients,
                         OnClaimClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_Pong, OnPongFromWorker)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_StashMessagePort,
+                        OnStashMessagePort)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void ServiceWorkerVersion::OnStartSentAndScriptEvaluated(
     ServiceWorkerStatusCode status) {
   if (status != SERVICE_WORKER_OK) {
     RunCallbacks(this, &start_callbacks_,
                  DeduceStartWorkerFailureReason(status));
@@ skipping 455 matching lines @@
 
   embedded_worker_->SendMessage(ServiceWorkerMsg_ClaimClientsError(
       request_id, blink::WebServiceWorkerError::ErrorTypeAbort,
       base::ASCIIToUTF16(kClaimClientsShutdownErrorMesage)));
 }
 
 void ServiceWorkerVersion::OnPongFromWorker() {
   ClearTick(&ping_time_);
 }
 
+void ServiceWorkerVersion::OnStashMessagePort(int message_port_id,
+                                              const base::string16& name) {
+  // Just abort if we are shutting down.
+  if (!context_)
+    return;
+
+  ServiceWorkerRegistration* registration =
+      context_->GetLiveRegistration(registration_id_);
+  if (!registration)
+    return;
+
+  // TODO(mek): Figure out a way to avoid this round-trip through the UI thread.
+  BrowserThread::PostTaskAndReplyWithResult(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&GetStashedPortManagerOnUIThread,
+                 make_scoped_refptr(context_->wrapper())),
+      base::Bind(&StashPortImpl, make_scoped_refptr(this), message_port_id,
+                 name));
+}
+
 void ServiceWorkerVersion::DidEnsureLiveRegistrationForStartWorker(
     bool pause_after_download,
     const StatusCallback& callback,
     ServiceWorkerStatusCode status,
     const scoped_refptr<ServiceWorkerRegistration>& protect) {
   if (status != SERVICE_WORKER_OK) {
     RecordStartWorkerResult(status);
     RunSoon(base::Bind(callback, SERVICE_WORKER_ERROR_START_WORKER_FAILED));
     return;
   }
@@ skipping 344 matching lines @@
         return SERVICE_WORKER_ERROR_ABORT;
       default:
         return SERVICE_WORKER_ERROR_NETWORK;
     }
   }
 
   return default_code;
 }
 
 }  // namespace content