Implement notificationclose event

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 252 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 notificationclose 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 DispatchNotificationCloseEvent(
+      const StatusCallback& callback,
+      int64_t persistent_notification_id,
+      const PlatformNotificationData& notification_data);
+
   // 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
@@ skipping 114 matching lines @@
                            MixedRequestTimeouts);
 
   class Metrics;
   class PingController;
 
   enum RequestType {
     REQUEST_ACTIVATE,
     REQUEST_INSTALL,
     REQUEST_FETCH,
     REQUEST_NOTIFICATION_CLICK,
+    REQUEST_NOTIFICATION_CLOSE,
     REQUEST_PUSH,
     REQUEST_CUSTOM,
     NUM_REQUEST_TYPES
   };
 
   struct RequestInfo {
     RequestInfo(int id,
                 RequestType type,
                 ServiceWorkerMetrics::EventType event_type,
                 const base::TimeTicks& expiration,
@@ skipping 145 matching lines @@
                                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 OnNotificationCloseEventFinished(int request_id);
   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 107 matching lines @@
   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>
+      notification_close_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 114 matching lines @@
   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_