Introduce the PushSubscription.curve25519dh attribute (2/3)

chrome/browser/push_messaging/push_messaging_service_impl.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 "chrome/browser/push_messaging/push_messaging_service_impl.h"
 
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind.h"
@@ skipping 314 matching lines @@
     int renderer_id,
     int render_frame_id,
     bool user_visible,
     const content::PushMessagingService::RegisterCallback& callback) {
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::Generate(requesting_origin,
                                            service_worker_registration_id);
 
   if (push_subscription_count_ + pending_push_subscription_count_ >=
       kMaxRegistrations) {
-    SubscribeEnd(callback, std::string(),
-                 content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
+    SubscribeEndWithError(callback,
+                          content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
     return;
   }
 
   content::RenderFrameHost* render_frame_host =
       content::RenderFrameHost::FromID(renderer_id, render_frame_id);
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(render_frame_host);
   if (!web_contents)
     return;
 
   // TODO(miguelg) need to send this over IPC when bubble support is
   // implemented.
   int request_id = -1;
 
   const PermissionRequestID id(
       renderer_id, render_frame_id, request_id, GURL());
 
   PushMessagingPermissionContext* permission_context =
       PushMessagingPermissionContextFactory::GetForProfile(profile_);
   DCHECK(permission_context);
 
   if (!user_visible) {
     web_contents->GetMainFrame()->AddMessageToConsole(
         content::CONSOLE_MESSAGE_LEVEL_ERROR,
         kSilentPushUnsupportedMessage);
 
-    SubscribeEnd(callback,
-                 std::string(),
-                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
+    SubscribeEndWithError(callback,
+                          content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   // TODO(miguelg): Consider the value of |user_visible| when making the
   // permission request.
   // TODO(mlamouri): Move requesting Push permission over to using Mojo, and
   // re-introduce the ability of |user_gesture| when bubbles require this.
   // https://crbug.com/423770.
   permission_context->RequestPermission(
       web_contents, id, requesting_origin, true /* user_gesture */,
       base::Bind(&PushMessagingServiceImpl::DidRequestPermission,
                  weak_factory_.GetWeakPtr(), app_identifier, sender_id,
                  callback));
 }
 
 void PushMessagingServiceImpl::SubscribeFromWorker(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const std::string& sender_id,
     bool user_visible,
     const content::PushMessagingService::RegisterCallback& register_callback) {
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::Generate(requesting_origin,
                                            service_worker_registration_id);
 
   if (profile_->GetPrefs()->GetInteger(
           prefs::kPushMessagingRegistrationCount) >= kMaxRegistrations) {
-    SubscribeEnd(register_callback, std::string(),
-                 content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
+    SubscribeEndWithError(register_callback,
+                          content::PUSH_REGISTRATION_STATUS_LIMIT_REACHED);
     return;
   }
 
   // TODO(peter): Consider |user_visible| when getting the permission status
   // for registering from a worker.
 
   GURL embedding_origin = requesting_origin;
   blink::WebPushPermissionStatus permission_status =
       PushMessagingServiceImpl::GetPermissionStatus(requesting_origin,
                                                     embedding_origin,
                                                     user_visible);
   if (permission_status != blink::WebPushPermissionStatusGranted) {
-    SubscribeEnd(register_callback, std::string(),
-                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
+    SubscribeEndWithError(register_callback,
+                          content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   IncreasePushSubscriptionCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
   GetGCMDriver()->Register(app_identifier.app_id(), sender_ids,
                            base::Bind(&PushMessagingServiceImpl::DidSubscribe,
                                       weak_factory_.GetWeakPtr(),
                                       app_identifier, register_callback));
 }
 
+void PushMessagingServiceImpl::GetPublicEncryptionKey(

[johnme, 2015/07/09 16:02:53]

Nit: Please move this to a new section of the .cc file called
"GetPublicEncryptionKey method", just above "// Unsubscribe methods" (rather
than in the middle of the subscribe methods - GetPermissionStatus is only here
by historical accident).

[Peter Beverloo, 2015/07/09 18:54:17]

Done.

+    const GURL& origin,
+    int64_t service_worker_registration_id,
+    const PushMessagingService::PublicKeyCallback& callback) {
+  // TODO(peter): Get the public key from the GCM Driver. Right now we have to
+  // return success=true here, otherwise subscriptions would fail.
+  callback.Run(true /* success */, std::vector<uint8_t>());
+}
+
 blink::WebPushPermissionStatus PushMessagingServiceImpl::GetPermissionStatus(
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     bool user_visible) {
   // TODO(peter): Consider |user_visible| when checking Push permission.
 
   PushMessagingPermissionContext* permission_context =
       PushMessagingPermissionContextFactory::GetForProfile(profile_);
   return ToPushPermission(permission_context->GetPermissionStatus(
       requesting_origin, embedding_origin));
 }
 
 bool PushMessagingServiceImpl::SupportNonVisibleMessages() {
   return false;
 }
 
 void PushMessagingServiceImpl::SubscribeEnd(
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& subscription_id,
+    const std::vector<uint8_t>& curve25519dh,
     content::PushRegistrationStatus status) {
-  callback.Run(subscription_id, status);
+  callback.Run(subscription_id, curve25519dh, status);
+}
+
+void PushMessagingServiceImpl::SubscribeEndWithError(
+    const content::PushMessagingService::RegisterCallback& callback,
+    content::PushRegistrationStatus status) {
+  SubscribeEnd(callback, std::string() /* subscription_id */,
+               std::vector<uint8_t>() /* curve25519dh */, status);
 }
 
 void PushMessagingServiceImpl::DidSubscribe(
     const PushMessagingAppIdentifier& app_identifier,
     const content::PushMessagingService::RegisterCallback& callback,
     const std::string& subscription_id,
     gcm::GCMClient::Result result) {
   content::PushRegistrationStatus status =
       content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
   switch (result) {
     case gcm::GCMClient::SUCCESS:
       status = content::PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE;
       app_identifier.PersistToPrefs(profile_);
       IncreasePushSubscriptionCount(1, false /* is_pending */);
       break;
     case gcm::GCMClient::INVALID_PARAMETER:
     case gcm::GCMClient::GCM_DISABLED:
     case gcm::GCMClient::ASYNC_OPERATION_PENDING:
     case gcm::GCMClient::SERVER_ERROR:
     case gcm::GCMClient::UNKNOWN_ERROR:
       status = content::PUSH_REGISTRATION_STATUS_SERVICE_ERROR;
       break;
     case gcm::GCMClient::NETWORK_ERROR:
     case gcm::GCMClient::TTL_EXCEEDED:
       status = content::PUSH_REGISTRATION_STATUS_NETWORK_ERROR;
       break;
   }
-  SubscribeEnd(callback, subscription_id, status);
+
+  // TODO(peter): Hook up getting the keys from the GCM Driver.
+  std::vector<uint8_t> curve25519dh;
+
+  SubscribeEnd(callback, subscription_id, curve25519dh, status);

[johnme, 2015/07/09 16:02:53]

Nit: it feels slightly inconsistent that you still use SubscribeEnd for the
error cases here, now that there is SubscribeEndWithError. But I don't feel
strongly.

[Peter Beverloo, 2015/07/09 18:54:16]

The alternative would be to return from the gcm::GCMClient::SUCCESS case and
duplicate the DecreasePushSubscriptionCount call. I'd rather keep that logic
isolated.

I did move the curve25519dh definition and the TODO to clarify this.

   DecreasePushSubscriptionCount(1, true /* was_pending */);
 }
 
 void PushMessagingServiceImpl::DidRequestPermission(
     const PushMessagingAppIdentifier& app_identifier,
     const std::string& sender_id,
     const content::PushMessagingService::RegisterCallback& register_callback,
     ContentSetting content_setting) {
   if (content_setting != CONTENT_SETTING_ALLOW) {
-    SubscribeEnd(register_callback,
-                 std::string(),
-                 content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
+    SubscribeEndWithError(register_callback,
+                          content::PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
     return;
   }
 
   IncreasePushSubscriptionCount(1, true /* is_pending */);
   std::vector<std::string> sender_ids(1, sender_id);
   GetGCMDriver()->Register(app_identifier.app_id(), sender_ids,
                            base::Bind(&PushMessagingServiceImpl::DidSubscribe,
                                       weak_factory_.GetWeakPtr(),
                                       app_identifier, register_callback));
 }
@@ skipping 176 matching lines @@
       CONTENT_SETTING_ALLOW;
 }
 
 gcm::GCMDriver* PushMessagingServiceImpl::GetGCMDriver() const {
   gcm::GCMProfileService* gcm_profile_service =
       gcm::GCMProfileServiceFactory::GetForProfile(profile_);
   CHECK(gcm_profile_service);
   CHECK(gcm_profile_service->driver());
   return gcm_profile_service->driver();
 }