Move push event dispatching out of ServiceWorkerVersion.

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 <stdint.h>
 
 #include <map>
@@ skipping 208 matching lines @@
   // associated with the |request_id| is called. Any messages sent back in
   // response to this event are passed on to the response |callback|.
   // ResponseMessage is the type of the IPC message that is used for the
   // response, and its first argument MUST be the request_id.
   // This must be called when the worker is running.
   template <typename ResponseMessage, typename ResponseCallbackType>
   void DispatchEvent(int request_id,
                      const IPC::Message& message,
                      const ResponseCallbackType& callback);
 
+  // Combines StartRequest and DispatchEvent, and automatically calls
+  // FinishRequest before passing a response to the response callback.
+  // ResponseMessage must have a int request_id and
+  // blink::WebServiceWorkerEventResult.
+  template <typename EventMessage,
+            typename ResponseMessage,
+            typename... EventArgs>
+  int DispatchSimpleEvent(ServiceWorkerMetrics::EventType event_type,
+                          const StatusCallback& callback,
+                          EventArgs... event_args);
+
   // Sends a message event to the associated embedded worker.
   void DispatchMessageEvent(
       const base::string16& message,
       const std::vector<TransferredMessagePort>& sent_message_ports,
       const StatusCallback& callback);
 
   // Sends install event to the associated embedded worker and asynchronously
   // calls |callback| when it errors out or it gets a response from the worker
   // to notify install completion.
   //
@@ skipping 26 matching lines @@
   // asynchronously calls |callback| when it errors out or it gets a response
   // from the worker to notify completion.
   //
   // This must be called when the status() is ACTIVATED.
   void DispatchNotificationClickEvent(
       const StatusCallback& callback,
       int64_t persistent_notification_id,
       const PlatformNotificationData& notification_data,
       int action_index);
 
-  // Sends push event to the associated embedded worker and asynchronously calls
-  // |callback| when it errors out or it gets a response from the worker to
-  // notify completion.
-  //
-  // This must be called when the status() is ACTIVATED.
-  void DispatchPushEvent(const StatusCallback& callback,
-                         const std::string& data);
-
   // Sends a cross origin message event to the associated embedded worker and
   // asynchronously calls |callback| when the message was sent (or failed to
   // sent).
   // It is the responsibility of the code calling this method to make sure that
   // 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,
@@ skipping 106 matching lines @@
                            MixedRequestTimeouts);
 
   class Metrics;
   class PingController;
 
   enum RequestType {
     REQUEST_ACTIVATE,
     REQUEST_INSTALL,
     REQUEST_FETCH,
     REQUEST_NOTIFICATION_CLICK,
-    REQUEST_PUSH,
     REQUEST_CUSTOM,
     NUM_REQUEST_TYPES
   };
 
   struct RequestInfo {
     RequestInfo(int id,
                 RequestType type,
                 ServiceWorkerMetrics::EventType event_type,
                 const base::TimeTicks& expiration,
                 TimeoutBehavior timeout_behavior);
@@ skipping 141 matching lines @@
                     const ServiceWorkerClientQueryOptions& options);
 
   void OnActivateEventFinished(int request_id,
                                blink::WebServiceWorkerEventResult result);
   void OnInstallEventFinished(int request_id,
                               blink::WebServiceWorkerEventResult result);
   void OnFetchEventFinished(int request_id,
                             ServiceWorkerFetchEventResult result,
                             const ServiceWorkerResponse& response);
   void OnNotificationClickEventFinished(int request_id);
-  void OnPushEventFinished(int request_id,
-                           blink::WebServiceWorkerEventResult result);
   void OnOpenWindow(int request_id, GURL url);
   void OnOpenWindowFinished(int request_id,
                             ServiceWorkerStatusCode status,
                             const std::string& client_uuid,
                             const ServiceWorkerClientInfo& client_info);
 
   void OnSetCachedMetadata(const GURL& url, const std::vector<char>& data);
   void OnSetCachedMetadataFinished(int64_t callback_id, int result);
   void OnClearCachedMetadata(const GURL& url);
   void OnClearCachedMetadataFinished(int64_t callback_id, int result);
@@ skipping 89 matching lines @@
   void OnStoppedInternal(EmbeddedWorkerInstance::Status old_status);
 
   // Called when the remote side of a connection to a mojo service is lost.
   void OnMojoConnectionError(const char* service_name);
 
   // Called at the beginning of each Dispatch*Event function: records
   // the time elapsed since idle (generally the time since the previous
   // event ended).
   void OnBeginEvent();
 
+  void ResponseCallbackWrapper(const StatusCallback& callback,
+                               int request_id,
+                               blink::WebServiceWorkerEventResult result) {
+    // TODO(mek): trace?
+    if (!FinishRequest(request_id))
+      NOTREACHED() << "Should only receive one reply per event";
+
+    ServiceWorkerStatusCode status = SERVICE_WORKER_OK;
+    if (result == blink::WebServiceWorkerEventResultRejected)
+      status = SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED;
+    callback.Run(status);
+  }
+
   const int64_t version_id_;
   const int64_t registration_id_;
   const GURL script_url_;
   const GURL scope_;
   std::vector<GURL> foreign_fetch_scopes_;
 
   Status status_ = NEW;
   scoped_ptr<EmbeddedWorkerInstance> embedded_worker_;
   std::vector<StatusCallback> start_callbacks_;
   std::vector<StatusCallback> stop_callbacks_;
   std::vector<base::Closure> status_change_callbacks_;
 
   // Message callbacks. (Update HasInflightRequests() too when you update this
   // list.)
   IDMap<PendingRequest<StatusCallback>, IDMapOwnPointer> activate_requests_;
   IDMap<PendingRequest<StatusCallback>, IDMapOwnPointer> install_requests_;
   IDMap<PendingRequest<FetchCallback>, IDMapOwnPointer> fetch_requests_;
   IDMap<PendingRequest<StatusCallback>, IDMapOwnPointer>
       notification_click_requests_;
-  IDMap<PendingRequest<StatusCallback>, IDMapOwnPointer> push_requests_;
   IDMap<PendingRequest<StatusCallback>, IDMapOwnPointer> custom_requests_;
 
   // Stores all open connections to mojo services. Maps the service name to
   // the actual interface pointer. When a connection is closed it is removed
   // from this map.
   // mojo_services_[Interface::Name_] is assumed to always contain a
   // MojoServiceWrapper<Interface> instance.
   base::ScopedPtrHashMap<const char*, scoped_ptr<BaseMojoServiceWrapper>>
       mojo_services_;
 
@@ skipping 91 matching lines @@
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(request->callback, status));
     custom_requests_.Remove(request_id);
   } else {
     request->listener.reset(
         new EventResponseHandler<ResponseMessage, ResponseCallbackType>(
             embedded_worker(), request_id, callback));
   }
 }
 
+template <typename EventMessage,
+          typename ResponseMessage,
+          typename... EventArgs>
+int ServiceWorkerVersion::DispatchSimpleEvent(
+    ServiceWorkerMetrics::EventType event_type,
+    const StatusCallback& callback,
+    EventArgs... event_args) {
+  int request_id = StartRequest(event_type, callback);
+  DispatchEvent<ResponseMessage>(
+      request_id, EventMessage(request_id, event_args...),
+      base::Bind(&ServiceWorkerVersion::ResponseCallbackWrapper, this,
+                 callback));
+  return request_id;
+}
+
 template <typename ResponseMessage, typename CallbackType>
 bool ServiceWorkerVersion::EventResponseHandler<ResponseMessage, CallbackType>::
     OnMessageReceived(const IPC::Message& message) {
   if (message.type() != ResponseMessage::ID)
     return false;
   int received_request_id;
   bool result = base::PickleIterator(message).ReadInt(&received_request_id);
   if (!result || received_request_id != request_id_)
     return false;
 
+  CallbackType protect(callback_);
   // Essentially same code as what IPC_MESSAGE_FORWARD expands to.
   void* param = nullptr;
   if (!ResponseMessage::Dispatch(&message, &callback_, this, param,
                                  &CallbackType::Run))
     message.set_dispatch_error();
 
   return true;
 }
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_