Implement notificationclose event

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 <stddef.h>
 
 #include <map>
 #include <string>
@@ skipping 638 matching lines @@
   ServiceWorkerStatusCode status =
       embedded_worker_->SendMessage(ServiceWorkerMsg_NotificationClickEvent(
           request_id, persistent_notification_id, notification_data,
           action_index));
   if (status != SERVICE_WORKER_OK) {
     notification_click_requests_.Remove(request_id);
     RunSoon(base::Bind(callback, status));
   }
 }
 
+void ServiceWorkerVersion::DispatchNotificationCloseEvent(

[Nina, 2016/01/21 13:55:36]

Maybe we should refactor a little to avoid code repetition with
DispatchNotificationClickEvent.

+    const StatusCallback& callback,
+    int64_t persistent_notification_id,
+    const PlatformNotificationData& notification_data) {
+  OnBeginEvent();
+  DCHECK_EQ(ACTIVATED, status()) << status();
+  if (running_status() != RUNNING) {
+    // Schedule calling this method after starting the worker.
+    StartWorker(base::Bind(
+        &RunTaskAfterStartWorker, weak_factory_.GetWeakPtr(), callback,
+        base::Bind(&self::DispatchNotificationCloseEvent,
+                   weak_factory_.GetWeakPtr(), callback,
+                   persistent_notification_id, notification_data)));
+    return;
+  }
+
+  int request_id = AddRequest(
+      callback, &notification_close_requests_, REQUEST_NOTIFICATION_CLOSE,
+      ServiceWorkerMetrics::EventType::NOTIFICATION_CLOSE);
+  ServiceWorkerStatusCode status =
+      embedded_worker_->SendMessage(ServiceWorkerMsg_NotificationCloseEvent(
+          request_id, persistent_notification_id, notification_data));
+  if (status != SERVICE_WORKER_OK) {
+    notification_close_requests_.Remove(request_id);
+    RunSoon(base::Bind(callback, status));
+  }
+}
+
 void ServiceWorkerVersion::DispatchPushEvent(const StatusCallback& callback,
                                              const std::string& data) {
   OnBeginEvent();
   DCHECK_EQ(ACTIVATED, status()) << status();
   if (running_status() != RUNNING) {
     // Schedule calling this method after starting the worker.
     StartWorker(base::Bind(&RunTaskAfterStartWorker,
                            weak_factory_.GetWeakPtr(), callback,
                            base::Bind(&self::DispatchPushEvent,
                                       weak_factory_.GetWeakPtr(),
@@ skipping 310 matching lines @@
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ActivateEventFinished,
                         OnActivateEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_InstallEventFinished,
                         OnInstallEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FetchEventFinished,
                         OnFetchEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationClickEventFinished,
                         OnNotificationClickEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PushEventFinished,
                         OnPushEventFinished)
+    IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_NotificationCloseEventFinished,
+                        OnNotificationCloseEventFinished)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_OpenWindow,
                         OnOpenWindow)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_SetCachedMetadata,
                         OnSetCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_ClearCachedMetadata,
                         OnClearCachedMetadata)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_PostMessageToClient,
                         OnPostMessageToClient)
     IPC_MESSAGE_HANDLER(ServiceWorkerHostMsg_FocusClient,
                         OnFocusClient)
@@ skipping 192 matching lines @@
     status = SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED;
 
   ServiceWorkerMetrics::RecordEventDuration(
       request->event_type, base::TimeTicks::Now() - request->start_time);
 
   scoped_refptr<ServiceWorkerVersion> protect(this);
   request->callback.Run(status);
   RemoveCallbackAndStopIfRedundant(&push_requests_, request_id);
 }
 
+void ServiceWorkerVersion::OnNotificationCloseEventFinished(int request_id) {
+  TRACE_EVENT1("ServiceWorker",
+               "ServiceWorkerVersion::OnNotificationCloseEventFinished",
+               "Request id", request_id);
+  PendingRequest<StatusCallback>* request =
+      notification_close_requests_.Lookup(request_id);
+  if (!request) {
+    NOTREACHED() << "Got unexpected message: " << request_id;
+    return;
+  }
+
+  ServiceWorkerMetrics::RecordEventDuration(
+      request->event_type, base::TimeTicks::Now() - request->start_time);
+
+  scoped_refptr<ServiceWorkerVersion> protect(this);
+  request->callback.Run(SERVICE_WORKER_OK);
+  RemoveCallbackAndStopIfRedundant(&notification_close_requests_, request_id);
+}
+
 void ServiceWorkerVersion::OnOpenWindow(int request_id, GURL url) {
   // Just abort if we are shutting down.
   if (!context_)
     return;
 
   if (!url.is_valid()) {
     DVLOG(1) << "Received unexpected invalid URL from renderer process.";
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&KillEmbeddedWorkerProcess,
                                        embedded_worker_->process_id(),
@@ skipping 516 matching lines @@
     return;
   }
 
   embedded_worker_->StopIfIdle();
 }
 
 bool ServiceWorkerVersion::HasInflightRequests() const {
   return !activate_requests_.IsEmpty() || !install_requests_.IsEmpty() ||
          !fetch_requests_.IsEmpty() ||
          !notification_click_requests_.IsEmpty() || !push_requests_.IsEmpty() ||
+         !notification_close_requests_.IsEmpty() ||
          !custom_requests_.IsEmpty() || !streaming_url_request_jobs_.empty();
 }
 
 void ServiceWorkerVersion::RecordStartWorkerResult(
     ServiceWorkerStatusCode status) {
   base::TimeTicks start_time = start_time_;
   ClearTick(&start_time_);
 
   ServiceWorkerMetrics::RecordStartWorkerStatus(status,
                                                 IsInstalled(prestart_status_));
@@ skipping 77 matching lines @@
       return RunIDMapCallback(&install_requests_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_FETCH:
       return RunIDMapCallback(
           &fetch_requests_, info.id, SERVICE_WORKER_ERROR_TIMEOUT,
           /* The other args are ignored for non-OK status. */
           SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, ServiceWorkerResponse());
     case REQUEST_NOTIFICATION_CLICK:
       return RunIDMapCallback(&notification_click_requests_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
+    case REQUEST_NOTIFICATION_CLOSE:
+      return RunIDMapCallback(&notification_close_requests_, info.id,
+                              SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_PUSH:
       return RunIDMapCallback(&push_requests_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case REQUEST_CUSTOM:
       return RunIDMapCallback(&custom_requests_, info.id,
                               SERVICE_WORKER_ERROR_TIMEOUT);
     case NUM_REQUEST_TYPES:
       break;
   }
   NOTREACHED() << "Got unexpected request type: " << info.type;
@@ skipping 134 matching lines @@
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ || running_status() != RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 }  // namespace content