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

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 <memory>
 #include <utility>
 
 #include "base/bind_helpers.h"
@@ skipping 118 matching lines @@
 
   // Just treat the server key as a string of bytes and pass it to the push
   // service.
   content_options.sender_info = options.applicationServerKey.latin1();
 
   push_messaging_manager_->Subscribe(
       ChildProcessHost::kInvalidUniqueID, service_worker_registration_id,
       content_options,
       // Safe to use base::Unretained because |push_messaging_manager_ |is owned
       // by |this|.
-      base::Bind(&PushProvider::SubscribeCallback, base::Unretained(this),
+      base::Bind(&PushProvider::DidSubscribe, base::Unretained(this),
                  base::Passed(&callbacks)));
 }
 
-void PushProvider::SubscribeCallback(
+void PushProvider::DidSubscribe(
     std::unique_ptr<blink::WebPushSubscriptionCallbacks> callbacks,
     content::PushRegistrationStatus status,
     const base::Optional<GURL>& endpoint,
     const base::Optional<content::PushSubscriptionOptions>& options,
     const base::Optional<std::vector<uint8_t>>& p256dh,
     const base::Optional<std::vector<uint8_t>>& auth) {
-  if (!callbacks) {
-    return;
-  }
+  DCHECK(callbacks);
 
   if (status == PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE ||
       status == PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE) {
     DCHECK(endpoint);
     DCHECK(options);
     DCHECK(p256dh);
     DCHECK(auth);
 
     callbacks->onSuccess(base::MakeUnique<blink::WebPushSubscription>(
         endpoint.value(), options.value().user_visible_only,
@@ skipping 10 matching lines @@
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
 
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
 
   push_messaging_manager_->Unsubscribe(
       service_worker_registration_id,
       // Safe to use base::Unretained because |push_messaging_manager_ |is owned
       // by |this|.
-      base::Bind(&PushProvider::UnsubscribeCallback, base::Unretained(this),
+      base::Bind(&PushProvider::DidUnsubscribe, base::Unretained(this),
                  base::Passed(&callbacks)));
 }
 
-void PushProvider::UnsubscribeCallback(
+void PushProvider::DidUnsubscribe(
     std::unique_ptr<blink::WebPushUnsubscribeCallbacks> callbacks,
     bool is_success,
     bool did_unsubscribe,
     blink::WebPushError::ErrorType error_type,
     const base::Optional<std::string>& error_message) {
-  if (!callbacks) {
-    return;
-  }
+  DCHECK(callbacks);
 
   if (is_success) {
     callbacks->onSuccess(did_unsubscribe);
   } else {
     callbacks->onError(blink::WebPushError(
         error_type, blink::WebString::fromUTF8(error_message->c_str())));
   }
 }
 
 void PushProvider::getSubscription(
     blink::WebServiceWorkerRegistration* service_worker_registration,
     std::unique_ptr<blink::WebPushSubscriptionCallbacks> callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
 
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
 
   push_messaging_manager_->GetSubscription(
       service_worker_registration_id,
       // Safe to use base::Unretained because |push_messaging_manager_ |is owned
       // by |this|.
-      base::Bind(&PushProvider::GetSubscriptionCallback, base::Unretained(this),
+      base::Bind(&PushProvider::DidGetSubscription, base::Unretained(this),
                  base::Passed(&callbacks)));
 }
 
-void PushProvider::GetSubscriptionCallback(
+void PushProvider::DidGetSubscription(
     std::unique_ptr<blink::WebPushSubscriptionCallbacks> callbacks,
     content::PushGetRegistrationStatus status,
     const base::Optional<GURL>& endpoint,
     const base::Optional<content::PushSubscriptionOptions>& options,
     const base::Optional<std::vector<uint8_t>>& p256dh,
     const base::Optional<std::vector<uint8_t>>& auth) {
-  if (!callbacks)
-    return;
+  DCHECK(callbacks);
 
   if (status == PUSH_GETREGISTRATION_STATUS_SUCCESS) {
     DCHECK(endpoint);
     DCHECK(options);
     DCHECK(p256dh);
     DCHECK(auth);
 
     callbacks->onSuccess(base::MakeUnique<blink::WebPushSubscription>(
         endpoint.value(), options.value().user_visible_only,
         blink::WebString::fromLatin1(options.value().sender_info),
@@ skipping 11 matching lines @@
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
 
   int64_t service_worker_registration_id =
       GetServiceWorkerRegistrationId(service_worker_registration);
 
   push_messaging_manager_->GetPermissionStatus(
       service_worker_registration_id, options.userVisibleOnly,
       // Safe to use base::Unretained because |push_messaging_manager_ |is owned
       // by |this|.
-      base::Bind(&PushProvider::GetPermissionStatusCallback,
-                 base::Unretained(this), base::Passed(&callbacks)));
+      base::Bind(&PushProvider::DidGetPermissionStatus, base::Unretained(this),
+                 base::Passed(&callbacks)));
 }
 
-void PushProvider::GetPermissionStatusCallback(
+void PushProvider::DidGetPermissionStatus(
     std::unique_ptr<blink::WebPushPermissionStatusCallbacks> callbacks,
     bool is_success,
     blink::WebPushPermissionStatus status,
     blink::WebPushError::ErrorType error) {
-  if (!callbacks)
-    return;
+  DCHECK(callbacks);
 
   if (is_success) {
     callbacks->onSuccess(status);
   } else {
     std::string error_message;
     if (error == blink::WebPushError::ErrorTypeNotSupported) {
       error_message =
           "Push subscriptions that don't enable userVisibleOnly are not "
           "supported.";
     }
     callbacks->onError(
         blink::WebPushError(error, blink::WebString::fromUTF8(error_message)));
   }
 }
 
 }  // namespace content