Implement some follow-ups after mojofiction of Push-messaging.

content/browser/push_messaging/push_messaging_manager.cc

Index: content/browser/push_messaging/push_messaging_manager.cc
diff --git a/content/browser/push_messaging/push_messaging_manager.cc b/content/browser/push_messaging/push_messaging_manager.cc
index f9cacdd4efc5165416f0b698245deaa94e2c7e6b..c096e328fce9ed554fbaed18859b4d41a3096c74 100644
--- a/content/browser/push_messaging/push_messaging_manager.cc
+++ b/content/browser/push_messaging/push_messaging_manager.cc
@@ -115,6 +115,7 @@ struct PushMessagingManager::RegisterData {
   GURL requesting_origin;
   int64_t service_worker_registration_id;
   PushSubscriptionOptions options;
+  SubscribeCallback callback;

[Peter Beverloo, 2017/02/23 13:37:39]

This will be copied, but since the callback's bind state is ref counted that's
fine.

[ke.he, 2017/02/24 03:24:30]

Thanks!

   // The following member should only be read if FromDocument() is true.
   int render_frame_id;
 };
@@ -128,8 +129,7 @@ class PushMessagingManager::Core {
   // Public Register methods on UI thread --------------------------------------
 
   // Called via PostTask from IO thread.
-  void RegisterOnUI(const SubscribeCallback& callback,
-                    const RegisterData& data);
+  void RegisterOnUI(const RegisterData& data);
 
   // Public Unregister methods on UI thread ------------------------------------
 
@@ -170,12 +170,10 @@ class PushMessagingManager::Core {
 
   // Private Register methods on UI thread -------------------------------------
 
-  void DidRequestPermissionInIncognito(const SubscribeCallback& callback,
-                                       const RegisterData& data,
+  void DidRequestPermissionInIncognito(const RegisterData& data,
                                        blink::mojom::PermissionStatus status);
 
-  void DidRegister(const SubscribeCallback& callback,
-                   const RegisterData& data,
+  void DidRegister(const RegisterData& data,
                    const std::string& push_registration_id,
                    const std::vector<uint8_t>& p256dh,
                    const std::vector<uint8_t>& auth,
@@ -266,6 +264,7 @@ void PushMessagingManager::Subscribe(int32_t render_frame_id,
   data.render_frame_id = render_frame_id;
 
   data.service_worker_registration_id = service_worker_registration_id;
+  data.callback = callback;
   data.options = options;
 
   ServiceWorkerRegistration* service_worker_registration =
@@ -273,8 +272,7 @@ void PushMessagingManager::Subscribe(int32_t render_frame_id,
           data.service_worker_registration_id);
   if (!service_worker_registration ||
       !service_worker_registration->active_version()) {
-    SendSubscriptionError(callback, data,
-                          PUSH_REGISTRATION_STATUS_NO_SERVICE_WORKER);
+    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SERVICE_WORKER);
     return;
   }
   data.requesting_origin = service_worker_registration->pattern().GetOrigin();
@@ -285,11 +283,10 @@ void PushMessagingManager::Subscribe(int32_t render_frame_id,
       data.service_worker_registration_id,
       {kPushRegistrationIdServiceWorkerKey, kPushSenderIdServiceWorkerKey},
       base::Bind(&PushMessagingManager::DidCheckForExistingRegistration,
-                 weak_factory_io_to_io_.GetWeakPtr(), callback, data));
+                 weak_factory_io_to_io_.GetWeakPtr(), data));
 }
 
 void PushMessagingManager::DidCheckForExistingRegistration(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::vector<std::string>& push_registration_id_and_sender_id,
     ServiceWorkerStatusCode service_worker_status) {
@@ -301,24 +298,22 @@ void PushMessagingManager::DidCheckForExistingRegistration(
     std::string fixed_sender_id =
         FixSenderInfo(data.options.sender_info, stored_sender_id);
     if (fixed_sender_id.empty()) {
-      SendSubscriptionError(callback, data,
-                            PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+      SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
       return;
     }
     if (fixed_sender_id != stored_sender_id) {
-      SendSubscriptionError(callback, data,
-                            PUSH_REGISTRATION_STATUS_SENDER_ID_MISMATCH);
+      SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_SENDER_ID_MISMATCH);
       return;
     }
-    auto callback_ui = base::Bind(&PushMessagingManager::DidGetEncryptionKeys,
-                                  weak_factory_io_to_io_.GetWeakPtr(), callback,
-                                  data, push_registration_id);
+    auto callback = base::Bind(&PushMessagingManager::DidGetEncryptionKeys,
+                               weak_factory_io_to_io_.GetWeakPtr(), 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_ui));
+                   callback));
     return;
   }
   // TODO(johnme): The spec allows the register algorithm to reject with an
@@ -327,22 +322,20 @@ void PushMessagingManager::DidCheckForExistingRegistration(
   // 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()),
-                   callback, data));
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&Core::RegisterOnUI,
+                                       base::Unretained(ui_core_.get()), 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(&PushMessagingManager::DidGetSenderIdFromStorage,
-                   weak_factory_io_to_io_.GetWeakPtr(), callback, data));
+                   weak_factory_io_to_io_.GetWeakPtr(), data));
   }
 }
 
 void PushMessagingManager::DidGetEncryptionKeys(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     bool success,
@@ -350,25 +343,22 @@ void PushMessagingManager::DidGetEncryptionKeys(
     const std::vector<uint8_t>& auth) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!success) {
-    SendSubscriptionError(callback, data,
+    SendSubscriptionError(data,
                           PUSH_REGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE);
     return;
   }
 
-  SendSubscriptionSuccess(callback, data,
-                          PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
+  SendSubscriptionSuccess(data, PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
                           push_registration_id, p256dh, auth);
 }
 
 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(callback, data,
-                          PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
     return;
   }
   DCHECK_EQ(1u, stored_sender_id.size());
@@ -377,8 +367,7 @@ void PushMessagingManager::DidGetSenderIdFromStorage(
   std::string fixed_sender_id =
       FixSenderInfo(data.options.sender_info, stored_sender_id[0]);
   if (fixed_sender_id.empty()) {
-    SendSubscriptionError(callback, data,
-                          PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
     return;
   }
   RegisterData mutated_data = data;
@@ -386,11 +375,10 @@ void PushMessagingManager::DidGetSenderIdFromStorage(
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Core::RegisterOnUI, base::Unretained(ui_core_.get()),
-                 callback, mutated_data));
+                 mutated_data));
 }
 
 void PushMessagingManager::Core::RegisterOnUI(
-    const SubscribeCallback& callback,
     const PushMessagingManager::RegisterData& data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PushMessagingService* push_service = service();
@@ -402,8 +390,7 @@ void PushMessagingManager::Core::RegisterOnUI(
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
-                     callback, data,
-                     PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE));
+                     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.
@@ -412,7 +399,7 @@ void PushMessagingManager::Core::RegisterOnUI(
         BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
             base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
-                       callback, data,
+                       data,
                        PUSH_REGISTRATION_STATUS_INCOGNITO_PERMISSION_DENIED));
       } else {
         RenderFrameHost* render_frame_host =
@@ -432,8 +419,7 @@ void PushMessagingManager::Core::RegisterOnUI(
                   data.requesting_origin, false /* user_gesture */,
                   base::Bind(&PushMessagingManager::Core::
                                  DidRequestPermissionInIncognito,
-                             weak_factory_ui_to_ui_.GetWeakPtr(), callback,
-                             data));
+                             weak_factory_ui_to_ui_.GetWeakPtr(), data));
         }
       }
     }
@@ -445,18 +431,17 @@ void PushMessagingManager::Core::RegisterOnUI(
         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(),
-                   callback, data));
+                   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(),
-                   callback, data));
+                   data));
   }
 }
 
 void PushMessagingManager::Core::DidRequestPermissionInIncognito(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     blink::mojom::PermissionStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ -464,13 +449,11 @@ void PushMessagingManager::Core::DidRequestPermissionInIncognito(
   DCHECK_EQ(blink::mojom::PermissionStatus::DENIED, status);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
-      base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
-                 callback, data,
+      base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_, data,
                  PUSH_REGISTRATION_STATUS_INCOGNITO_PERMISSION_DENIED));
 }
 
 void PushMessagingManager::Core::DidRegister(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     const std::vector<uint8_t>& p256dh,
@@ -481,17 +464,16 @@ void PushMessagingManager::Core::DidRegister(
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PushMessagingManager::PersistRegistrationOnIO, io_parent_,
-                   callback, data, push_registration_id, p256dh, auth));
+                   data, push_registration_id, p256dh, auth));
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PushMessagingManager::SendSubscriptionError, io_parent_,
-                   callback, data, status));
+                   data, status));
   }
 }
 
 void PushMessagingManager::PersistRegistrationOnIO(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     const std::vector<uint8_t>& p256dh,
@@ -502,12 +484,11 @@ void PushMessagingManager::PersistRegistrationOnIO(
       {{kPushRegistrationIdServiceWorkerKey, push_registration_id},
        {kPushSenderIdServiceWorkerKey, data.options.sender_info}},
       base::Bind(&PushMessagingManager::DidPersistRegistrationOnIO,
-                 weak_factory_io_to_io_.GetWeakPtr(), callback, data,
+                 weak_factory_io_to_io_.GetWeakPtr(), data,
                  push_registration_id, p256dh, auth));
 }
 
 void PushMessagingManager::DidPersistRegistrationOnIO(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     const std::string& push_registration_id,
     const std::vector<uint8_t>& p256dh,
@@ -515,30 +496,28 @@ void PushMessagingManager::DidPersistRegistrationOnIO(
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status == SERVICE_WORKER_OK) {
-    SendSubscriptionSuccess(callback, data,
+    SendSubscriptionSuccess(data,
                             PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE,
                             push_registration_id, p256dh, auth);
   } else {
     // TODO(johnme): Unregister, so PushMessagingServiceImpl can decrease count.
-    SendSubscriptionError(callback, data,
-                          PUSH_REGISTRATION_STATUS_STORAGE_ERROR);
+    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_STORAGE_ERROR);
   }
 }
 
 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);
-  callback.Run(status, base::nullopt /* endpoint */,
-               base::nullopt /* options */, base::nullopt /* p256dh */,
-               base::nullopt /* auth */);
+  DCHECK(data.callback);

[Peter Beverloo, 2017/02/23 13:37:39]

nit: I wouldn't add this DCHECK, it's really uncommon to DCHECK that a callback
is non-null. I think we can rely on it? (The Run() method will also check this.)

[ke.he, 2017/02/24 03:24:30]

Done. (and elsewhere)

+  data.callback.Run(status, base::nullopt /* endpoint */,
+                    base::nullopt /* options */, base::nullopt /* p256dh */,
+                    base::nullopt /* auth */);
   RecordRegistrationStatus(status);
 }
 
 void PushMessagingManager::SendSubscriptionSuccess(
-    const SubscribeCallback& callback,
     const RegisterData& data,
     PushRegistrationStatus status,
     const std::string& push_subscription_id,
@@ -550,15 +529,15 @@ void PushMessagingManager::SendSubscriptionSuccess(
     // 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(callback, data,
-                          PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE);
+    SendSubscriptionError(data, PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE);
     return;
   }
 
   const GURL endpoint = CreateEndpoint(
       IsApplicationServerKey(data.options.sender_info), push_subscription_id);
 
-  callback.Run(status, endpoint, data.options, p256dh, auth);
+  DCHECK(data.callback);
+  data.callback.Run(status, endpoint, data.options, p256dh, auth);
 
   RecordRegistrationStatus(status);
 }