Initial implementation of stashed message ports, content side

content/browser/service_worker/service_worker_version.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <map>
 #include <queue>
 #include <set>
@@ skipping 53 matching lines @@
     : NON_EXPORTED_BASE(public base::RefCounted<ServiceWorkerVersion>),
       public EmbeddedWorkerInstance::Listener {
  public:
   typedef base::Callback<void(ServiceWorkerStatusCode)> StatusCallback;
   typedef base::Callback<void(ServiceWorkerStatusCode,
                               ServiceWorkerFetchEventResult,
                               const ServiceWorkerResponse&)> FetchCallback;
   typedef base::Callback<void(ServiceWorkerStatusCode,
                               bool /* accept_connction */)>
       CrossOriginConnectCallback;
+  typedef base::Callback<void(ServiceWorkerStatusCode, const std::vector<int>&)>
+      SendStashedPortsCallback;
 
   enum RunningStatus {
     STOPPED = EmbeddedWorkerInstance::STOPPED,
     STARTING = EmbeddedWorkerInstance::STARTING,
     RUNNING = EmbeddedWorkerInstance::RUNNING,
     STOPPING = EmbeddedWorkerInstance::STOPPING,
   };
 
   // Current version status; some of the status (e.g. INSTALLED and ACTIVATED)
   // should be persisted unlike running status.
@@ skipping 168 matching lines @@
   // any transferred message ports are put on hold while potentially a process
   // for the service worker is spun up.
   //
   // This must be called when the status() is ACTIVATED.
   void DispatchCrossOriginMessageEvent(
       const NavigatorConnectClient& client,
       const base::string16& message,
       const std::vector<TransferredMessagePort>& sent_message_ports,
       const StatusCallback& callback);
 
+  // Transfers one or more stashed message ports to the associated embedded
+  // worker, and asynchronously calls |callback| with the new route ids for the
+  // transferred ports as soon as the ports are sent to the renderer.
+  // Once the ports are received by the renderer, the ports themselves will
+  // inform MessagePortService, which will enable actual messages to be sent.
+  void SendStashedMessagePorts(
+      const std::vector<TransferredMessagePort>& stashed_message_ports,
+      const std::vector<base::string16>& port_names,
+      const SendStashedPortsCallback& callback);
+
   // Adds and removes |provider_host| as a controllee of this ServiceWorker.
   // A potential controllee is a host having the version as its .installing
   // or .waiting version.
   void AddControllee(ServiceWorkerProviderHost* provider_host);
   void RemoveControllee(ServiceWorkerProviderHost* provider_host);
 
   // Returns if it has controllee.
   bool HasControllee() const { return !controllee_map_.empty(); }
 
   // Adds and removes |request_job| as a dependent job not to stop the
@@ skipping 148 matching lines @@
   void OnClearCachedMetadataFinished(int64 callback_id, int result);
 
   void OnPostMessageToClient(
       const std::string& client_uuid,
       const base::string16& message,
       const std::vector<TransferredMessagePort>& sent_message_ports);
   void OnFocusClient(int request_id, const std::string& client_uuid);
   void OnSkipWaiting(int request_id);
   void OnClaimClients(int request_id);
   void OnPongFromWorker();
+  void OnStashMessagePort(int message_port_id, const base::string16& name);
 
   void OnFocusClientFinished(int request_id,
                              const std::string& client_uuid,
                              const ServiceWorkerClientInfo& client);
 
   void DidEnsureLiveRegistrationForStartWorker(
       bool pause_after_download,
       const StatusCallback& callback,
       ServiceWorkerStatusCode status,
       const scoped_refptr<ServiceWorkerRegistration>& protect);
@@ skipping 114 matching lines @@
   ServiceWorkerStatusCode start_worker_status_ = SERVICE_WORKER_OK;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_