Convert push_messaging IPC msgs into mojo interfaces

content/browser/push_messaging/push_messaging_manager.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/browser/push_messaging/push_messaging_message_filter.h"
+#include "content/browser/push_messaging/push_messaging_manager.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_storage.h"
-#include "content/common/push_messaging_messages.h"
 #include "content/public/browser/browser_context.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/permission_manager.h"
 #include "content/public/browser/permission_type.h"
 #include "content/public/browser/push_messaging_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/console_message_level.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/push_messaging_status.h"
 #include "third_party/WebKit/public/platform/modules/push_messaging/WebPushPermissionStatus.h"
@@ skipping 68 matching lines @@
                           const std::string& stored_sender_id) {
   if (!sender_info.empty())
     return sender_info;
   if (base::ContainsOnlyChars(stored_sender_id, "0123456789"))
     return stored_sender_id;
   return std::string();
 }
 
 }  // namespace
 
-struct PushMessagingMessageFilter::RegisterData {
+struct PushMessagingManager::RegisterData {
   RegisterData();
   RegisterData(const RegisterData& other) = default;
   bool FromDocument() const;
-  int request_id;
   GURL requesting_origin;
   int64_t service_worker_registration_id;
   PushSubscriptionOptions options;
   // The following member should only be read if FromDocument() is true.
   int render_frame_id;
 };
 
-// Inner core of this message filter which lives on the UI thread.
-class PushMessagingMessageFilter::Core {
+// Inner core of the PushMessagingManager which lives on the UI thread.
+class PushMessagingManager::Core {
  public:
-  Core(const base::WeakPtr<PushMessagingMessageFilter>& io_parent,
+  Core(const base::WeakPtr<PushMessagingManager>& io_parent,
        int render_process_id);
 
   // Public Register methods on UI thread --------------------------------------
 
   // Called via PostTask from IO thread.
-  void RegisterOnUI(const RegisterData& data);
+  void RegisterOnUI(const SubscribeCallback& callback,
+                    const RegisterData& data);
 
   // Public Unregister methods on UI thread ------------------------------------
 
   // Called via PostTask from IO thread.
-  void UnregisterFromService(int request_id,
+  void UnregisterFromService(const UnsubscribeCallback& callback,
                              int64_t service_worker_registration_id,
                              const GURL& requesting_origin,
                              const std::string& sender_id);
 
   // Public GetPermission methods on UI thread ---------------------------------
 
   // Called via PostTask from IO thread.
-  void GetPermissionStatusOnUI(const GURL& requesting_origin,
-                               bool user_visible,
-                               int request_id);
+  void GetPermissionStatusOnUI(const GetPermissionStatusCallback& callback,
+                               const GURL& requesting_origin,
+                               bool user_visible);
 
   // Public helper methods on UI thread ----------------------------------------
 
   // Called via PostTask from IO thread. The |io_thread_callback| callback
   // will be invoked on the IO thread.
   void GetEncryptionInfoOnUI(
       const GURL& origin,
       int64_t service_worker_registration_id,
       const std::string& sender_id,
       const PushMessagingService::EncryptionInfoCallback& io_thread_callback);
 
   // Called (directly) from both the UI and IO threads.
   bool is_incognito() const { return is_incognito_; }
 
   // Returns a push messaging service. May return null.
   PushMessagingService* service();
 
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class base::DeleteHelper<Core>;
 
   ~Core();
 
   // Private Register methods on UI thread -------------------------------------
 
-  void DidRequestPermissionInIncognito(const RegisterData& data,
+  void DidRequestPermissionInIncognito(const SubscribeCallback& callback,
+                                       const RegisterData& data,
                                        blink::mojom::PermissionStatus status);
 
-  void DidRegister(const RegisterData& data,
+  void DidRegister(const SubscribeCallback& callback,
+                   const RegisterData& data,
                    const std::string& push_registration_id,
                    const std::vector<uint8_t>& p256dh,
                    const std::vector<uint8_t>& auth,
                    PushRegistrationStatus status);
 
   // Private Unregister methods on UI thread -----------------------------------
 
-  void DidUnregisterFromService(int request_id,
+  void DidUnregisterFromService(const UnsubscribeCallback& callback,
                                 int64_t service_worker_registration_id,
                                 PushUnregistrationStatus unregistration_status);
 
-  // Private helper methods on UI thread ---------------------------------------
-
-  void Send(IPC::Message* message);
-
-  // Outer part of this message filter which lives on the IO thread.
-  base::WeakPtr<PushMessagingMessageFilter> io_parent_;
+  // Outer part of the PushMessagingManager which lives on the IO thread.
+  base::WeakPtr<PushMessagingManager> io_parent_;
 
   int render_process_id_;
 
   bool is_incognito_;
 
   base::WeakPtrFactory<Core> weak_factory_ui_to_ui_;
 
   DISALLOW_COPY_AND_ASSIGN(Core);
 };
 
-PushMessagingMessageFilter::RegisterData::RegisterData()
-    : request_id(0),
-      service_worker_registration_id(0),
+PushMessagingManager::RegisterData::RegisterData()
+    : service_worker_registration_id(0),
       render_frame_id(ChildProcessHost::kInvalidUniqueID) {}
 
-bool PushMessagingMessageFilter::RegisterData::FromDocument() const {
+bool PushMessagingManager::RegisterData::FromDocument() const {
   return render_frame_id != ChildProcessHost::kInvalidUniqueID;
 }
 
-PushMessagingMessageFilter::Core::Core(
-    const base::WeakPtr<PushMessagingMessageFilter>& io_parent,
+PushMessagingManager::Core::Core(
+    const base::WeakPtr<PushMessagingManager>& io_parent,
     int render_process_id)
     : io_parent_(io_parent),
       render_process_id_(render_process_id),
       weak_factory_ui_to_ui_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderProcessHost* process_host =
       RenderProcessHost::FromID(render_process_id_);  // Can't be null yet.
   is_incognito_ = process_host->GetBrowserContext()->IsOffTheRecord();
 }
 
-PushMessagingMessageFilter::Core::~Core() {}
+PushMessagingManager::Core::~Core() {}
 
-PushMessagingMessageFilter::PushMessagingMessageFilter(
+PushMessagingManager::PushMessagingManager(
     int render_process_id,
     ServiceWorkerContextWrapper* service_worker_context)
-    : BrowserMessageFilter(PushMessagingMsgStart),
-      service_worker_context_(service_worker_context),
+    : service_worker_context_(service_worker_context),
       weak_factory_io_to_io_(this) {
   // Although this class is used only on the IO thread, it is constructed on UI.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Normally, it would be unsafe to obtain a weak pointer from the UI thread,
   // but it's ok in the constructor since we can't be destroyed before our
   // constructor finishes.
   ui_core_.reset(
       new Core(weak_factory_io_to_io_.GetWeakPtr(), render_process_id));
 
   PushMessagingService* service = ui_core_->service();
   service_available_ = !!service;
 
   if (service_available_) {
     default_endpoint_ = service->GetEndpoint(false /* standard_protocol */);
     web_push_protocol_endpoint_ =
         service->GetEndpoint(true /* standard_protocol */);
   }
 }
 
-PushMessagingMessageFilter::~PushMessagingMessageFilter() {}
+PushMessagingManager::~PushMessagingManager() {}
 
-void PushMessagingMessageFilter::OnDestruct() const {
-  BrowserThread::DeleteOnIOThread::Destruct(this);
-}
-
-bool PushMessagingMessageFilter::OnMessageReceived(
-    const IPC::Message& message) {
-  bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(PushMessagingMessageFilter, message)
-    IPC_MESSAGE_HANDLER(PushMessagingHostMsg_Subscribe, OnSubscribe)
-    IPC_MESSAGE_HANDLER(PushMessagingHostMsg_Unsubscribe, OnUnsubscribe)
-    IPC_MESSAGE_HANDLER(PushMessagingHostMsg_GetSubscription, OnGetSubscription)
-    IPC_MESSAGE_HANDLER(PushMessagingHostMsg_GetPermissionStatus,
-                        OnGetPermissionStatus)
-    IPC_MESSAGE_UNHANDLED(handled = false)
-  IPC_END_MESSAGE_MAP()
-  return handled;
+void PushMessagingManager::BindRequest(mojom::PushMessagingRequest request) {
+  bindings_.AddBinding(this, std::move(request));
 }
 
 // Subscribe methods on both IO and UI threads, merged in order of use from
-// PushMessagingMessageFilter and Core.
+// PushMessagingManager and Core.
 // -----------------------------------------------------------------------------
 
-void PushMessagingMessageFilter::OnSubscribe(
-    int render_frame_id,
-    int request_id,
-    int64_t service_worker_registration_id,
-    const PushSubscriptionOptions& options) {
+void PushMessagingManager::Subscribe(int32_t render_frame_id,
+                                     int64_t service_worker_registration_id,
+                                     const PushSubscriptionOptions& options,
+                                     const SubscribeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(mvanouwerkerk): Validate arguments?
   RegisterData data;
 
   // Will be ChildProcessHost::kInvalidUniqueID in requests from Service Worker.
   data.render_frame_id = render_frame_id;
 
-  data.request_id = request_id;
   data.service_worker_registration_id = service_worker_registration_id;
   data.options = options;
 
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
           data.service_worker_registration_id);
   if (!service_worker_registration ||
       !service_worker_registration->active_version()) {
-    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SERVICE_WORKER);
+    SendSubscriptionError(callback, data,
+                          PUSH_REGISTRATION_STATUS_NO_SERVICE_WORKER);
     return;
   }
   data.requesting_origin = service_worker_registration->pattern().GetOrigin();
 
   DCHECK(!(data.options.sender_info.empty() && data.FromDocument()));
 
   service_worker_context_->GetRegistrationUserData(
       data.service_worker_registration_id,
       {kPushRegistrationIdServiceWorkerKey, kPushSenderIdServiceWorkerKey},
-      base::Bind(&PushMessagingMessageFilter::DidCheckForExistingRegistration,
-                 weak_factory_io_to_io_.GetWeakPtr(), data));
+      base::Bind(&PushMessagingManager::DidCheckForExistingRegistration,
+                 weak_factory_io_to_io_.GetWeakPtr(), callback, data));
 }
 
-void PushMessagingMessageFilter::DidCheckForExistingRegistration(
+void PushMessagingManager::DidCheckForExistingRegistration(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::vector<std::string>& push_registration_id_and_sender_id,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status == SERVICE_WORKER_OK) {
     DCHECK_EQ(2u, push_registration_id_and_sender_id.size());
     const auto& push_registration_id = push_registration_id_and_sender_id[0];
     const auto& stored_sender_id = push_registration_id_and_sender_id[1];
     std::string fixed_sender_id =
         FixSenderInfo(data.options.sender_info, stored_sender_id);
     if (fixed_sender_id.empty()) {
-      SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+      SendSubscriptionError(callback, data,
+                            PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
       return;
     }
     if (fixed_sender_id != stored_sender_id) {
-      SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_SENDER_ID_MISMATCH);
+      SendSubscriptionError(callback, data,
+                            PUSH_REGISTRATION_STATUS_SENDER_ID_MISMATCH);
       return;
     }
-    auto callback = base::Bind(
-        &PushMessagingMessageFilter::DidGetEncryptionKeys,
-        weak_factory_io_to_io_.GetWeakPtr(), data, push_registration_id);
+    auto callback_ui = base::Bind(&PushMessagingManager::DidGetEncryptionKeys,
+                                  weak_factory_io_to_io_.GetWeakPtr(), callback,
+                                  data, push_registration_id);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&Core::GetEncryptionInfoOnUI,
                    base::Unretained(ui_core_.get()), data.requesting_origin,
                    data.service_worker_registration_id, fixed_sender_id,
-                   callback));
+                   callback_ui));
     return;
   }
   // TODO(johnme): The spec allows the register algorithm to reject with an
   // AbortError when accessing storage fails. Perhaps we should do that if
   // service_worker_status != SERVICE_WORKER_ERROR_NOT_FOUND instead of
   // attempting to do a fresh registration?
   // https://w3c.github.io/push-api/#widl-PushRegistrationManager-register-Promise-PushRegistration
   if (!data.options.sender_info.empty()) {
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                            base::Bind(&Core::RegisterOnUI,
-                                       base::Unretained(ui_core_.get()), data));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&Core::RegisterOnUI, base::Unretained(ui_core_.get()),
+                   callback, data));
   } else {
     // There is no existing registration and the sender_info passed in was
     // empty, but perhaps there is a stored sender id we can use.
     service_worker_context_->GetRegistrationUserData(
         data.service_worker_registration_id, {kPushSenderIdServiceWorkerKey},
-        base::Bind(&PushMessagingMessageFilter::DidGetSenderIdFromStorage,
-                   weak_factory_io_to_io_.GetWeakPtr(), data));
+        base::Bind(&PushMessagingManager::DidGetSenderIdFromStorage,
+                   weak_factory_io_to_io_.GetWeakPtr(), callback, data));
   }
 }
 
-void PushMessagingMessageFilter::DidGetEncryptionKeys(
+void PushMessagingManager::DidGetEncryptionKeys(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     bool success,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!success) {
-    SendSubscriptionError(
-        data, PUSH_REGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE);
+    SendSubscriptionError(callback, data,
+                          PUSH_REGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE);
     return;
   }
 
-  SendSubscriptionSuccess(data, PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
+  SendSubscriptionSuccess(callback, data,
+                          PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
                           push_registration_id, p256dh, auth);
 }
 
-void PushMessagingMessageFilter::DidGetSenderIdFromStorage(
+void PushMessagingManager::DidGetSenderIdFromStorage(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::vector<std::string>& stored_sender_id,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status != SERVICE_WORKER_OK) {
-    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+    SendSubscriptionError(callback, data,
+                          PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
     return;
   }
   DCHECK_EQ(1u, stored_sender_id.size());
   // We should only be here because no sender info was supplied to subscribe().
   DCHECK(data.options.sender_info.empty());
   std::string fixed_sender_id =
       FixSenderInfo(data.options.sender_info, stored_sender_id[0]);
   if (fixed_sender_id.empty()) {
-    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+    SendSubscriptionError(callback, data,
+                          PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
     return;
   }
   RegisterData mutated_data = data;
   mutated_data.options.sender_info = fixed_sender_id;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Core::RegisterOnUI, base::Unretained(ui_core_.get()),
-                 mutated_data));
+                 callback, mutated_data));
 }
 
-void PushMessagingMessageFilter::Core::RegisterOnUI(
-    const PushMessagingMessageFilter::RegisterData& data) {
+void PushMessagingManager::Core::RegisterOnUI(
+    const SubscribeCallback& callback,
+    const PushMessagingManager::RegisterData& data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PushMessagingService* push_service = service();
   if (!push_service) {
     if (!is_incognito()) {
       // This might happen if InstanceIDProfileService::IsInstanceIDEnabled
       // returns false because the Instance ID kill switch was enabled.
       // TODO(johnme): Might be better not to expose the API in this case.
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
-          base::Bind(&PushMessagingMessageFilter::SendSubscriptionError,
-                     io_parent_,
-                     data, PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE));
+          base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
+                     callback, data,
+                     PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE));
     } else {
       // Prevent websites from detecting incognito mode, by emulating what would
       // have happened if we had a PushMessagingService available.
       if (!data.FromDocument() || !data.options.user_visible_only) {
         // Throw a permission denied error under the same circumstances.
         BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
-            base::Bind(&PushMessagingMessageFilter::SendSubscriptionError,
-                       io_parent_, data,
+            base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
+                       callback, data,
                        PUSH_REGISTRATION_STATUS_INCOGNITO_PERMISSION_DENIED));
       } else {
         RenderFrameHost* render_frame_host =
             RenderFrameHost::FromID(render_process_id_, data.render_frame_id);
         WebContents* web_contents =
             WebContents::FromRenderFrameHost(render_frame_host);
         if (web_contents) {
           web_contents->GetMainFrame()->AddMessageToConsole(
               CONSOLE_MESSAGE_LEVEL_ERROR, kIncognitoPushUnsupportedMessage);
           // Request push messaging permission (which will fail, since
           // notifications aren't supported in incognito), so the website can't
           // detect whether incognito is active.
           web_contents->GetBrowserContext()
               ->GetPermissionManager()
               ->RequestPermission(
                   PermissionType::PUSH_MESSAGING, render_frame_host,
                   data.requesting_origin, false /* user_gesture */,
-                  base::Bind(&PushMessagingMessageFilter::Core::
+                  base::Bind(&PushMessagingManager::Core::
                                  DidRequestPermissionInIncognito,
-                             weak_factory_ui_to_ui_.GetWeakPtr(), data));
+                             weak_factory_ui_to_ui_.GetWeakPtr(), callback,
+                             data));
         }
       }
     }
     return;
   }
 
   if (data.FromDocument()) {
     push_service->SubscribeFromDocument(
         data.requesting_origin, data.service_worker_registration_id,
         render_process_id_, data.render_frame_id, data.options,
         base::Bind(&Core::DidRegister, weak_factory_ui_to_ui_.GetWeakPtr(),
-                   data));
+                   callback, data));
   } else {
     push_service->SubscribeFromWorker(
         data.requesting_origin, data.service_worker_registration_id,
-        data.options, base::Bind(&Core::DidRegister,
-                                 weak_factory_ui_to_ui_.GetWeakPtr(), data));
+        data.options,
+        base::Bind(&Core::DidRegister, weak_factory_ui_to_ui_.GetWeakPtr(),
+                   callback, data));
   }
 }
 
-void PushMessagingMessageFilter::Core::DidRequestPermissionInIncognito(
+void PushMessagingManager::Core::DidRequestPermissionInIncognito(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     blink::mojom::PermissionStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   // Notification permission should always be denied in incognito.
   DCHECK_EQ(blink::mojom::PermissionStatus::DENIED, status);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&PushMessagingMessageFilter::SendSubscriptionError, io_parent_,
-                 data, PUSH_REGISTRATION_STATUS_INCOGNITO_PERMISSION_DENIED));
+      base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
+                 callback, data,
+                 PUSH_REGISTRATION_STATUS_INCOGNITO_PERMISSION_DENIED));
 }
 
-void PushMessagingMessageFilter::Core::DidRegister(
+void PushMessagingManager::Core::DidRegister(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth,
     PushRegistrationStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (status == PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&PushMessagingMessageFilter::PersistRegistrationOnIO,
-                   io_parent_, data, push_registration_id, p256dh, auth));
+        base::Bind(&PushMessagingManager::PersistRegistrationOnIO, io_parent_,
+                   callback, data, push_registration_id, p256dh, auth));
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&PushMessagingMessageFilter::SendSubscriptionError,
-                   io_parent_, data, status));
+        base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
+                   callback, data, status));
   }
 }
 
-void PushMessagingMessageFilter::PersistRegistrationOnIO(
+void PushMessagingManager::PersistRegistrationOnIO(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   service_worker_context_->StoreRegistrationUserData(
       data.service_worker_registration_id, data.requesting_origin,
       {{kPushRegistrationIdServiceWorkerKey, push_registration_id},
        {kPushSenderIdServiceWorkerKey, data.options.sender_info}},
-      base::Bind(&PushMessagingMessageFilter::DidPersistRegistrationOnIO,
-                 weak_factory_io_to_io_.GetWeakPtr(), data,
+      base::Bind(&PushMessagingManager::DidPersistRegistrationOnIO,
+                 weak_factory_io_to_io_.GetWeakPtr(), callback, data,
                  push_registration_id, p256dh, auth));
 }
 
-void PushMessagingMessageFilter::DidPersistRegistrationOnIO(
+void PushMessagingManager::DidPersistRegistrationOnIO(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status == SERVICE_WORKER_OK) {
-    SendSubscriptionSuccess(data,
+    SendSubscriptionSuccess(callback, data,
                             PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE,
                             push_registration_id, p256dh, auth);
   } else {
     // TODO(johnme): Unregister, so PushMessagingServiceImpl can decrease count.
-    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_STORAGE_ERROR);
+    SendSubscriptionError(callback, data,
+                          PUSH_REGISTRATION_STATUS_STORAGE_ERROR);
   }
 }
 
-void PushMessagingMessageFilter::SendSubscriptionError(
-    const RegisterData& data, PushRegistrationStatus status) {
+void PushMessagingManager::SendSubscriptionError(
+    const SubscribeCallback& callback,
+    const RegisterData& data,
+    PushRegistrationStatus status) {
   // Only called from IO thread, but would be safe to call from UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (data.FromDocument()) {
-    Send(new PushMessagingMsg_SubscribeFromDocumentError(
-        data.render_frame_id, data.request_id, status));
-  } else {
-    Send(
-        new PushMessagingMsg_SubscribeFromWorkerError(data.request_id, status));
-  }
+  callback.Run(status, base::nullopt /* endpoint */,
+               base::nullopt /* options */, base::nullopt /* p256dh */,
+               base::nullopt /* auth */);
   RecordRegistrationStatus(status);
 }
 
-void PushMessagingMessageFilter::SendSubscriptionSuccess(
+void PushMessagingManager::SendSubscriptionSuccess(
+    const SubscribeCallback& callback,
     const RegisterData& data,
     PushRegistrationStatus status,
     const std::string& push_subscription_id,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth) {
   // Only called from IO thread, but would be safe to call from UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!service_available_) {
     // This shouldn't be possible in incognito mode, since we've already checked
     // that we have an existing registration. Hence it's ok to throw an error.
     DCHECK(!ui_core_->is_incognito());
-    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE);
+    SendSubscriptionError(callback, data,
+                          PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE);
     return;
   }
 
   const GURL endpoint = CreateEndpoint(
       IsApplicationServerKey(data.options.sender_info), push_subscription_id);
 
-  if (data.FromDocument()) {
-    Send(new PushMessagingMsg_SubscribeFromDocumentSuccess(
-        data.render_frame_id, data.request_id, endpoint, data.options, p256dh,
-        auth));
-  } else {
-    Send(new PushMessagingMsg_SubscribeFromWorkerSuccess(
-        data.request_id, endpoint, data.options, p256dh, auth));
-  }
+  callback.Run(status, endpoint, data.options, p256dh, auth);
+
   RecordRegistrationStatus(status);
 }
 
 // Unsubscribe methods on both IO and UI threads, merged in order of use from
-// PushMessagingMessageFilter and Core.
+// PushMessagingManager and Core.
 // -----------------------------------------------------------------------------
 
-void PushMessagingMessageFilter::OnUnsubscribe(
-    int request_id, int64_t service_worker_registration_id) {
+void PushMessagingManager::Unsubscribe(int64_t service_worker_registration_id,
+                                       const UnsubscribeCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
-    DidUnregister(request_id, PUSH_UNREGISTRATION_STATUS_NO_SERVICE_WORKER);
+    DidUnregister(callback, PUSH_UNREGISTRATION_STATUS_NO_SERVICE_WORKER);
     return;
   }
 
   service_worker_context_->GetRegistrationUserData(
       service_worker_registration_id, {kPushSenderIdServiceWorkerKey},
-      base::Bind(&PushMessagingMessageFilter::UnsubscribeHavingGottenSenderId,
-                 weak_factory_io_to_io_.GetWeakPtr(), request_id,
+      base::Bind(&PushMessagingManager::UnsubscribeHavingGottenSenderId,
+                 weak_factory_io_to_io_.GetWeakPtr(), callback,
                  service_worker_registration_id,
                  service_worker_registration->pattern().GetOrigin()));
 }
 
-void PushMessagingMessageFilter::UnsubscribeHavingGottenSenderId(
-    int request_id,
+void PushMessagingManager::UnsubscribeHavingGottenSenderId(
+    const UnsubscribeCallback& callback,
     int64_t service_worker_registration_id,
     const GURL& requesting_origin,
     const std::vector<std::string>& sender_ids,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   std::string sender_id;
   if (service_worker_status == SERVICE_WORKER_OK) {
     DCHECK_EQ(1u, sender_ids.size());
     sender_id = sender_ids[0];
   }
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Core::UnregisterFromService, base::Unretained(ui_core_.get()),
-                 request_id, service_worker_registration_id, requesting_origin,
+                 callback, service_worker_registration_id, requesting_origin,
                  sender_id));
 }
 
-void PushMessagingMessageFilter::Core::UnregisterFromService(
-    int request_id,
+void PushMessagingManager::Core::UnregisterFromService(
+    const UnsubscribeCallback& callback,
     int64_t service_worker_registration_id,
     const GURL& requesting_origin,
     const std::string& sender_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PushMessagingService* push_service = service();
   if (!push_service) {
     // This shouldn't be possible in incognito mode, since we've already checked
     // that we have an existing registration. Hence it's ok to throw an error.
     DCHECK(!is_incognito());
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
-        base::Bind(&PushMessagingMessageFilter::DidUnregister, io_parent_,
-                   request_id,
+        base::Bind(&PushMessagingManager::DidUnregister, io_parent_, callback,
                    PUSH_UNREGISTRATION_STATUS_SERVICE_NOT_AVAILABLE));
     return;
   }
 
   push_service->Unsubscribe(
       requesting_origin, service_worker_registration_id, sender_id,
       base::Bind(&Core::DidUnregisterFromService,
-                 weak_factory_ui_to_ui_.GetWeakPtr(), request_id,
+                 weak_factory_ui_to_ui_.GetWeakPtr(), callback,
                  service_worker_registration_id));
 }
 
-void PushMessagingMessageFilter::Core::DidUnregisterFromService(
-    int request_id,
+void PushMessagingManager::Core::DidUnregisterFromService(
+    const UnsubscribeCallback& callback,
     int64_t service_worker_registration_id,
     PushUnregistrationStatus unregistration_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&PushMessagingMessageFilter::DidUnregister, io_parent_,
-                 request_id, unregistration_status));
+      base::Bind(&PushMessagingManager::DidUnregister, io_parent_, callback,
+                 unregistration_status));
 }
 
-void PushMessagingMessageFilter::DidUnregister(
-    int request_id,
+void PushMessagingManager::DidUnregister(
+    const UnsubscribeCallback& callback,
     PushUnregistrationStatus unregistration_status) {
   // Only called from IO thread, but would be safe to call from UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   switch (unregistration_status) {
     case PUSH_UNREGISTRATION_STATUS_SUCCESS_UNREGISTERED:
     case PUSH_UNREGISTRATION_STATUS_PENDING_NETWORK_ERROR:
     case PUSH_UNREGISTRATION_STATUS_PENDING_SERVICE_ERROR:
-      Send(new PushMessagingMsg_UnsubscribeSuccess(request_id, true));
+      callback.Run(true /* success */, true /* did_unsubscribe */,
+                   blink::WebPushError::ErrorTypeUnknown,
+                   base::nullopt /* error_message */);
       break;
     case PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED:
-      Send(new PushMessagingMsg_UnsubscribeSuccess(request_id, false));
+      callback.Run(true /* success */, false /* did_unsubscribe */,
+                   blink::WebPushError::ErrorTypeUnknown,
+                   base::nullopt /* error_message */);
       break;
     case PUSH_UNREGISTRATION_STATUS_NO_SERVICE_WORKER:
     case PUSH_UNREGISTRATION_STATUS_SERVICE_NOT_AVAILABLE:
     case PUSH_UNREGISTRATION_STATUS_STORAGE_ERROR:
-      Send(new PushMessagingMsg_UnsubscribeError(
-          request_id, blink::WebPushError::ErrorTypeAbort,
-          PushUnregistrationStatusToString(unregistration_status)));
+      callback.Run(
+          false /* error */, false, blink::WebPushError::ErrorTypeAbort,
+          std::string(PushUnregistrationStatusToString(unregistration_status)));
       break;
     case PUSH_UNREGISTRATION_STATUS_NETWORK_ERROR:
       NOTREACHED();
       break;
   }
   RecordUnregistrationStatus(unregistration_status);
 }
 
 // GetSubscription methods on both IO and UI threads, merged in order of use
-// from PushMessagingMessageFilter and Core.
+// from PushMessagingManager and Core.
 // -----------------------------------------------------------------------------
 
-void PushMessagingMessageFilter::OnGetSubscription(
-    int request_id,
-    int64_t service_worker_registration_id) {
+void PushMessagingManager::GetSubscription(
+    int64_t service_worker_registration_id,
+    const GetSubscriptionCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(johnme): Validate arguments?
   service_worker_context_->GetRegistrationUserData(
       service_worker_registration_id,
       {kPushRegistrationIdServiceWorkerKey, kPushSenderIdServiceWorkerKey},
-      base::Bind(&PushMessagingMessageFilter::DidGetSubscription,
-                 weak_factory_io_to_io_.GetWeakPtr(), request_id,
+      base::Bind(&PushMessagingManager::DidGetSubscription,
+                 weak_factory_io_to_io_.GetWeakPtr(), callback,
                  service_worker_registration_id));
 }
 
-void PushMessagingMessageFilter::DidGetSubscription(
-    int request_id,
+void PushMessagingManager::DidGetSubscription(
+    const GetSubscriptionCallback& callback,
     int64_t service_worker_registration_id,
     const std::vector<std::string>& push_subscription_id_and_sender_info,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   PushGetRegistrationStatus get_status =
       PUSH_GETREGISTRATION_STATUS_STORAGE_ERROR;
   switch (service_worker_status) {
     case SERVICE_WORKER_OK: {
       DCHECK_EQ(2u, push_subscription_id_and_sender_info.size());
 
       if (!service_available_) {
         // Return not found in incognito mode, so websites can't detect it.
         get_status =
             ui_core_->is_incognito()
                 ? PUSH_GETREGISTRATION_STATUS_INCOGNITO_REGISTRATION_NOT_FOUND
                 : PUSH_GETREGISTRATION_STATUS_SERVICE_NOT_AVAILABLE;
         break;
       }
 
       ServiceWorkerRegistration* registration =
           service_worker_context_->GetLiveRegistration(
               service_worker_registration_id);
       const GURL origin = registration->pattern().GetOrigin();
 
       const bool uses_standard_protocol =
           IsApplicationServerKey(push_subscription_id_and_sender_info[1]);
       const GURL endpoint = CreateEndpoint(
           uses_standard_protocol, push_subscription_id_and_sender_info[0]);
 
-      auto callback =
-          base::Bind(&PushMessagingMessageFilter::DidGetSubscriptionKeys,
-                     weak_factory_io_to_io_.GetWeakPtr(), request_id, endpoint,
+      auto callback_ui =
+          base::Bind(&PushMessagingManager::DidGetSubscriptionKeys,
+                     weak_factory_io_to_io_.GetWeakPtr(), callback, endpoint,
                      push_subscription_id_and_sender_info[1]);
 
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&Core::GetEncryptionInfoOnUI,
                      base::Unretained(ui_core_.get()), origin,
                      service_worker_registration_id,
-                     push_subscription_id_and_sender_info[1], callback));
+                     push_subscription_id_and_sender_info[1], callback_ui));
 
       return;
     }
     case SERVICE_WORKER_ERROR_NOT_FOUND: {
       get_status = PUSH_GETREGISTRATION_STATUS_REGISTRATION_NOT_FOUND;
       break;
     }
     case SERVICE_WORKER_ERROR_FAILED: {
       get_status = PUSH_GETREGISTRATION_STATUS_STORAGE_ERROR;
       break;
@@ skipping 14 matching lines @@
     case SERVICE_WORKER_ERROR_DISK_CACHE:
     case SERVICE_WORKER_ERROR_REDUNDANT:
     case SERVICE_WORKER_ERROR_DISALLOWED:
     case SERVICE_WORKER_ERROR_MAX_VALUE: {
       NOTREACHED() << "Got unexpected error code: " << service_worker_status
                    << " " << ServiceWorkerStatusToString(service_worker_status);
       get_status = PUSH_GETREGISTRATION_STATUS_STORAGE_ERROR;
       break;
     }
   }
-  Send(new PushMessagingMsg_GetSubscriptionError(request_id, get_status));
+  callback.Run(get_status, base::nullopt /* endpoint */,
+               base::nullopt /* options */, base::nullopt /* p256dh */,
+               base::nullopt /* auth */);
   RecordGetRegistrationStatus(get_status);
 }
 
-void PushMessagingMessageFilter::DidGetSubscriptionKeys(
-    int request_id,
+void PushMessagingManager::DidGetSubscriptionKeys(
+    const GetSubscriptionCallback& callback,
     const GURL& endpoint,
     const std::string& sender_info,
     bool success,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!success) {
     PushGetRegistrationStatus status =
         PUSH_GETREGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE;
 
-    Send(new PushMessagingMsg_GetSubscriptionError(request_id, status));
+    callback.Run(status, base::nullopt /* endpoint */,
+                 base::nullopt /* options */, base::nullopt /* p256dh */,
+                 base::nullopt /* auth */);
 
     RecordGetRegistrationStatus(status);
     return;
   }
 
   PushSubscriptionOptions options;
   // Chrome rejects subscription requests with userVisibleOnly false, so it must
   // have been true. TODO(harkness): If Chrome starts accepting silent push
   // subscriptions with userVisibleOnly false, the bool will need to be stored.
   options.user_visible_only = true;
   options.sender_info = sender_info;
 
-  Send(new PushMessagingMsg_GetSubscriptionSuccess(request_id, endpoint,
-                                                   options, p256dh, auth));
+  callback.Run(PUSH_GETREGISTRATION_STATUS_SUCCESS, endpoint, options, p256dh,
+               auth);
 
   RecordGetRegistrationStatus(PUSH_GETREGISTRATION_STATUS_SUCCESS);
 }
 
 // GetPermission methods on both IO and UI threads, merged in order of use from
-// PushMessagingMessageFilter and Core.
+// PushMessagingManager and Core.
 // -----------------------------------------------------------------------------
 
-void PushMessagingMessageFilter::OnGetPermissionStatus(
-    int request_id,
+void PushMessagingManager::GetPermissionStatus(
     int64_t service_worker_registration_id,
-    bool user_visible) {
+    bool user_visible,
+    const GetPermissionStatusCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistration* service_worker_registration =
       service_worker_context_->GetLiveRegistration(
           service_worker_registration_id);
   if (!service_worker_registration) {
-    Send(new PushMessagingMsg_GetPermissionStatusError(
-        request_id, blink::WebPushError::ErrorTypeAbort));
+    callback.Run(false /* error */, blink::WebPushPermissionStatusDenied,
+                 blink::WebPushError::ErrorTypeAbort);
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Core::GetPermissionStatusOnUI,
-                 base::Unretained(ui_core_.get()),
+                 base::Unretained(ui_core_.get()), callback,
                  service_worker_registration->pattern().GetOrigin(),
-                 user_visible, request_id));
+                 user_visible));
 }
 
-void PushMessagingMessageFilter::Core::GetPermissionStatusOnUI(
-    const GURL& requesting_origin, bool user_visible, int request_id) {
+void PushMessagingManager::Core::GetPermissionStatusOnUI(
+    const GetPermissionStatusCallback& callback,
+    const GURL& requesting_origin,
+    bool user_visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   blink::WebPushPermissionStatus permission_status;
   PushMessagingService* push_service = service();
   if (push_service) {
     if (!user_visible && !push_service->SupportNonVisibleMessages()) {
-      Send(new PushMessagingMsg_GetPermissionStatusError(
-          request_id, blink::WebPushError::ErrorTypeNotSupported));
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(callback, false /* error */,
+                     blink::WebPushPermissionStatusDenied,
+                     blink::WebPushError::ErrorTypeNotSupported));
       return;
     }
     permission_status =
         push_service->GetPermissionStatus(requesting_origin, user_visible);
   } else if (is_incognito()) {
     // Return prompt, so the website can't detect incognito mode.
     permission_status = blink::WebPushPermissionStatusPrompt;
   } else {
-    Send(new PushMessagingMsg_GetPermissionStatusError(
-        request_id, blink::WebPushError::ErrorTypeAbort));
+    BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                            base::Bind(callback, false /* error */,
+                                       blink::WebPushPermissionStatusDenied,
+                                       blink::WebPushError::ErrorTypeAbort));
     return;
   }
-  Send(new PushMessagingMsg_GetPermissionStatusSuccess(request_id,
-                                                       permission_status));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(callback, true /* success */, permission_status,
+                 blink::WebPushError::ErrorTypeUnknown));
 }
 
 // Helper methods on both IO and UI threads, merged from
-// PushMessagingMessageFilter and Core.
+// PushMessagingManager and Core.
 // -----------------------------------------------------------------------------
 
-void PushMessagingMessageFilter::Core::GetEncryptionInfoOnUI(
+void PushMessagingManager::Core::GetEncryptionInfoOnUI(
     const GURL& origin,
     int64_t service_worker_registration_id,
     const std::string& sender_id,
     const PushMessagingService::EncryptionInfoCallback& io_thread_callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PushMessagingService* push_service = service();
   if (push_service) {
     push_service->GetEncryptionInfo(
         origin, service_worker_registration_id, sender_id,
         base::Bind(&ForwardEncryptionInfoToIOThreadProxy, io_thread_callback));
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(io_thread_callback, false /* success */,
                                      std::vector<uint8_t>() /* p256dh */,
                                      std::vector<uint8_t>() /* auth */));
 }
 
-void PushMessagingMessageFilter::Core::Send(IPC::Message* message) {
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&PushMessagingMessageFilter::SendIPC, io_parent_,
-                 base::Passed(base::WrapUnique(message))));
-}
-
-void PushMessagingMessageFilter::SendIPC(
-    std::unique_ptr<IPC::Message> message) {
-  Send(message.release());
-}
-
-GURL PushMessagingMessageFilter::CreateEndpoint(
+GURL PushMessagingManager::CreateEndpoint(
     bool standard_protocol,
     const std::string& subscription_id) const {
   const GURL& base =
       standard_protocol ? web_push_protocol_endpoint_ : default_endpoint_;
 
   return GURL(base.spec() + subscription_id);
 }
 
-PushMessagingService* PushMessagingMessageFilter::Core::service() {
+PushMessagingService* PushMessagingManager::Core::service() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   RenderProcessHost* process_host =
       RenderProcessHost::FromID(render_process_id_);
   return process_host
              ? process_host->GetBrowserContext()->GetPushMessagingService()
              : nullptr;
 }
 
 }  // namespace content