Implement WebPushProvider.unregister() in Chromium.

content/child/push_messaging/push_provider.cc

 // Copyright 2014 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/child/push_messaging/push_provider.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_local.h"
@@ skipping 33 matching lines @@
   g_push_provider_tls.Pointer()->Set(this);
 }
 
 PushProvider::~PushProvider() {
   STLDeleteContainerPairSecondPointers(registration_callbacks_.begin(),
                                        registration_callbacks_.end());
   registration_callbacks_.clear();
   STLDeleteContainerPairSecondPointers(permission_status_callbacks_.begin(),
                                        permission_status_callbacks_.end());
   permission_status_callbacks_.clear();
+  STLDeleteContainerPairSecondPointers(unregister_callbacks_.begin(),
+                                       unregister_callbacks_.end());
+  unregister_callbacks_.clear();
   g_push_provider_tls.Pointer()->Set(nullptr);
 }
 
 PushProvider* PushProvider::ThreadSpecificInstance(
     ThreadSafeSender* thread_safe_sender,
     PushDispatcher* push_dispatcher) {
   if (g_push_provider_tls.Pointer()->Get())
     return g_push_provider_tls.Pointer()->Get();
 
   PushProvider* provider =
@@ skipping 26 matching lines @@
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
   int request_id = push_dispatcher_->GenerateRequestId(CurrentWorkerId());
   permission_status_callbacks_[request_id] = callbacks;
   int64 service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
   thread_safe_sender_->Send(new PushMessagingHostMsg_GetPermissionStatus(
       request_id, service_worker_registration_id));
 }
 
+void PushProvider::unregister(
+    blink::WebServiceWorkerRegistration* service_worker_registration,
+    blink::WebPushUnregisterCallbacks* callback) {
+  DCHECK(service_worker_registration);
+  DCHECK(callback);
+
+  int request_id = push_dispatcher_->GenerateRequestId(CurrentWorkerId());
+  unregister_callbacks_[request_id] = callback;
+
+  int64 service_worker_registration_id =
+      GetServiceWorkerRegistrationId(service_worker_registration);
+  thread_safe_sender_->Send(new PushMessagingHostMsg_Unregister(
+      request_id, service_worker_registration_id));
+}
+
 bool PushProvider::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PushProvider, message)
     IPC_MESSAGE_HANDLER(PushMessagingMsg_RegisterFromWorkerSuccess,
                         OnRegisterFromWorkerSuccess);
     IPC_MESSAGE_HANDLER(PushMessagingMsg_RegisterFromWorkerError,
                         OnRegisterFromWorkerError);
     IPC_MESSAGE_HANDLER(PushMessagingMsg_GetPermissionStatusSuccess,
                         OnGetPermissionStatusSuccess);
     IPC_MESSAGE_HANDLER(PushMessagingMsg_GetPermissionStatusError,
                         OnGetPermissionStatusError);
+    IPC_MESSAGE_HANDLER(PushMessagingMsg_UnregisterResponse,
+                        OnUnregisterResponse);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
 
 void PushProvider::OnRegisterFromWorkerSuccess(
     int request_id,
     const GURL& endpoint,
     const std::string& registration_id) {
@@ skipping 43 matching lines @@
   const auto& it = permission_status_callbacks_.find(request_id);
   if (it == permission_status_callbacks_.end())
     return;
 
   scoped_ptr<blink::WebPushPermissionStatusCallbacks> callbacks(it->second);
   permission_status_callbacks_.erase(it);
 
   callbacks->onError();
 }
 
+void PushProvider::OnUnregisterResponse(int request_id, bool unregistered) {
+  const auto& it = unregister_callbacks_.find(request_id);
+  if (it == unregister_callbacks_.end())
+    return;
+
+  scoped_ptr<blink::WebPushUnregisterCallbacks> callback(it->second);
+  unregister_callbacks_.erase(it);
+
+  callback->onSuccess(&unregistered);
+}
+
 }  // namespace content