Introduce the PushSubscription.curve25519dh attribute (2/3)

content/browser/push_messaging/push_messaging_message_filter.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 <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 46 matching lines @@
                             PUSH_UNREGISTRATION_STATUS_LAST + 1);
 }
 
 void RecordGetRegistrationStatus(PushGetRegistrationStatus status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UMA_HISTOGRAM_ENUMERATION("PushMessaging.GetRegistrationStatus",
                             status,
                             PUSH_GETREGISTRATION_STATUS_LAST + 1);
 }
 
+// Curries the |success| and |curve25519dh| parameters over to |callback| and
+// posts a task to invoke |callback| on the IO thread.
+void ForwardPublicEncryptionKeysToIOThreadProxy(

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

It's a bit unusual that Core::GetPublicEncryptionKeyOnUI gets called on UI
thread, but runs its callback on IO thread.

I've looked at the two callbacks (DidGetEncryptionKeys &
DidGetRegistrationKeys), and it seems both of them could actually be implemented
on the UI thread almost as easily (you can replace Send with the Core::Send
proxy; SendRegister{Success,Error} can be PostTask'd to; finally
RecordGetRegistrationStatus is safe enough to call from UI thread - just change
the DCHECK_CURRENTLY_ON).

Then you could remove ForwardPublicEncryptionKeysToIOThreadProxy. Alternatively,
if you prefer to keep the current threading, then document it clearly (rename
Core::GetPublicEncryptionKeyOnUI's callback parameter to io_thread_callback, and
add a comment in the method declaration).

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

All the Record*Status have DCHECKS to be on the IO thread, so
DidGetRegistrationKeys would become messier w/ another PostTask.

I've updated the argument names and comment.

+    const PushMessagingService::PublicKeyCallback& callback,
+    bool success,
+    const std::vector<uint8_t>& curve25519dh) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                          base::Bind(callback, success, curve25519dh));
+}
+
 // Concatenates the subscription id with the endpoint base to create a new
 // GURL object containing the endpoint unique to the subscription.
 GURL CreatePushEndpoint(const GURL& push_endpoint_base,
                         const std::string& push_subscription_id) {
   return GURL(push_endpoint_base.spec() + "/" + push_subscription_id);
 }
 
 }  // namespace
 
 struct PushMessagingMessageFilter::RegisterData {
@@ skipping 13 matching lines @@
 class PushMessagingMessageFilter::Core {
  public:
   Core(const base::WeakPtr<PushMessagingMessageFilter>& io_parent,
        int render_process_id);
 
   // Public Register methods on UI thread --------------------------------------
 
   // Called via PostTask from IO thread.
   void RegisterOnUI(const RegisterData& data, const std::string& sender_id);
 
+  // Called via PostTask from IO thread.
+  void GetPublicEncryptionKeyOnUI(

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

Please move this to the "Public helper methods on UI thread" section, since it's
used both for the Register flow and the GetRegistration flow.

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

Done.

+      const GURL& origin,
+      int64_t service_worker_registration_id,
+      const PushMessagingService::PublicKeyCallback& callback);
+
   // Public Unregister methods on UI thread ------------------------------------
 
   // Called via PostTask from IO thread.
   void UnregisterFromService(int request_id,
                              int64_t service_worker_registration_id,
                              const GURL& requesting_origin,
                              const std::string& sender_id);
 
   // Public GetPermission methods on UI thread ---------------------------------
 
@@ skipping 13 matching lines @@
  private:
   friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
   friend class base::DeleteHelper<Core>;
 
   ~Core();
 
   // Private Register methods on UI thread -------------------------------------
 
   void DidRegister(const RegisterData& data,
                    const std::string& push_registration_id,
+                   const std::vector<uint8_t>& curve25519dh,
                    PushRegistrationStatus status);
 
   // Private Unregister methods on UI thread -----------------------------------
 
   void DidUnregisterFromService(int request_id,
                                 int64_t service_worker_registration_id,
                                 PushUnregistrationStatus unregistration_status);
 
   // Private helper methods on UI thread ---------------------------------------
 
@@ skipping 162 matching lines @@
                  weak_factory_io_to_io_.GetWeakPtr(), data, sender_id));
 }
 
 void PushMessagingMessageFilter::DidCheckForExistingRegistration(
     const RegisterData& data,
     const std::string& sender_id,
     const std::string& push_registration_id,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status == SERVICE_WORKER_OK) {
-    SendRegisterSuccess(data, PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
-                        push_registration_id);
+    auto callback =
+        base::Bind(&PushMessagingMessageFilter::DidGetEncryptionKeys,
+                   weak_factory_io_to_io_.GetWeakPtr(), data,
+                   push_registration_id);
+
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&Core::GetPublicEncryptionKeyOnUI,
+                   base::Unretained(ui_core_.get()), data.requesting_origin,
+                   data.service_worker_registration_id, callback));
     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.FromDocument()) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&Core::RegisterOnUI, base::Unretained(ui_core_.get()),
                    data, sender_id));
   } else {
     service_worker_context_->GetRegistrationUserData(
         data.service_worker_registration_id,
         kPushSenderIdServiceWorkerKey,
         base::Bind(&PushMessagingMessageFilter::DidGetSenderIdFromStorage,
                    weak_factory_io_to_io_.GetWeakPtr(), data));
   }
 }
 
+void PushMessagingMessageFilter::Core::GetPublicEncryptionKeyOnUI(

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

Similarly, please move this to the "Helper methods on both IO and UI threads,
merged from PushMessagingMessageFilter and Core." section at the bottom of this
file.

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

Done.

+    const GURL& origin,
+    int64_t service_worker_registration_id,
+    const PushMessagingService::PublicKeyCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  PushMessagingService* push_service = service();
+  if (push_service) {
+    push_service->GetPublicEncryptionKey(
+        origin, service_worker_registration_id,
+        base::Bind(&ForwardPublicEncryptionKeysToIOThreadProxy, callback));
+    return;
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(callback, false /* success */, std::vector<uint8_t>()));
+}
+
+void PushMessagingMessageFilter::DidGetEncryptionKeys(
+    const RegisterData& data,
+    const std::string& push_registration_id,
+    bool success,
+    const std::vector<uint8_t>& curve25519dh) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (!success) {
+    SendRegisterError(data, PUSH_REGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE);
+    return;
+  }
+
+  SendRegisterSuccess(data, PUSH_REGISTRATION_STATUS_SUCCESS_FROM_CACHE,
+                      push_registration_id, curve25519dh);
+}
+
 void PushMessagingMessageFilter::DidGetSenderIdFromStorage(
     const RegisterData& data,
     const std::string& sender_id,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status != SERVICE_WORKER_OK) {
     SendRegisterError(data, PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
     return;
   }
   BrowserThread::PostTask(
@@ skipping 54 matching lines @@
         data.requesting_origin, data.service_worker_registration_id, sender_id,
         data.user_visible,
         base::Bind(&Core::DidRegister, weak_factory_ui_to_ui_.GetWeakPtr(),
                    data));
   }
 }
 
 void PushMessagingMessageFilter::Core::DidRegister(
     const RegisterData& data,
     const std::string& push_registration_id,
+    const std::vector<uint8_t>& curve25519dh,
     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));
+                   io_parent_, data, push_registration_id, curve25519dh));
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PushMessagingMessageFilter::SendRegisterError, io_parent_,
                    data, status));
   }
 }
 
 void PushMessagingMessageFilter::PersistRegistrationOnIO(
     const RegisterData& data,
-    const std::string& push_registration_id) {
+    const std::string& push_registration_id,
+    const std::vector<uint8_t>& curve25519dh) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   service_worker_context_->StoreRegistrationUserData(
       data.service_worker_registration_id,
       data.requesting_origin,
       kPushRegistrationIdServiceWorkerKey,
       push_registration_id,
       base::Bind(&PushMessagingMessageFilter::DidPersistRegistrationOnIO,
                  weak_factory_io_to_io_.GetWeakPtr(),
-                 data, push_registration_id));
+                 data, push_registration_id, curve25519dh));
 }
 
 void PushMessagingMessageFilter::DidPersistRegistrationOnIO(
     const RegisterData& data,
     const std::string& push_registration_id,
+    const std::vector<uint8_t>& curve25519dh,
     ServiceWorkerStatusCode service_worker_status) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (service_worker_status == SERVICE_WORKER_OK) {
     SendRegisterSuccess(data,
                         PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE,
-                        push_registration_id);
+                        push_registration_id, curve25519dh);
   } else {
     // TODO(johnme): Unregister, so PushMessagingServiceImpl can decrease count.
     SendRegisterError(data, PUSH_REGISTRATION_STATUS_STORAGE_ERROR);
   }
 }
 
 void PushMessagingMessageFilter::SendRegisterError(
     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));
   }
   RecordRegistrationStatus(status);
 }
 
 void PushMessagingMessageFilter::SendRegisterSuccess(
     const RegisterData& data,
     PushRegistrationStatus status,
-    const std::string& push_registration_id) {
+    const std::string& push_registration_id,
+    const std::vector<uint8_t>& curve25519dh) {
   // Only called from IO thread, but would be safe to call from UI thread.
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (push_endpoint_base_.is_empty()) {
     // 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());
     SendRegisterError(data, PUSH_REGISTRATION_STATUS_SERVICE_NOT_AVAILABLE);
     return;
   }
   if (data.FromDocument()) {
     Send(new PushMessagingMsg_SubscribeFromDocumentSuccess(
         data.render_frame_id,
         data.request_id,
-        CreatePushEndpoint(push_endpoint_base_, push_registration_id)));
+        CreatePushEndpoint(push_endpoint_base_, push_registration_id),
+        curve25519dh));
   } else {
     Send(new PushMessagingMsg_SubscribeFromWorkerSuccess(
         data.request_id,
-        CreatePushEndpoint(push_endpoint_base_, push_registration_id)));
+        CreatePushEndpoint(push_endpoint_base_, push_registration_id),
+        curve25519dh));
   }
   RecordRegistrationStatus(status);
 }
 
 // Unsubscribe methods on both IO and UI threads, merged in order of use from
 // PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnUnsubscribe(
     int request_id, int64_t service_worker_registration_id) {
@@ skipping 203 matching lines @@
   }
   RecordUnregistrationStatus(unregistration_status);
 }
 
 // GetRegistration methods on both IO and UI threads, merged in order of use
 // from PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnGetRegistration(
     int request_id,
+    const GURL& origin,
     int64_t service_worker_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(johnme): Validate arguments?
   service_worker_context_->GetRegistrationUserData(
       service_worker_registration_id,
       kPushRegistrationIdServiceWorkerKey,
       base::Bind(&PushMessagingMessageFilter::DidGetRegistration,
-                 weak_factory_io_to_io_.GetWeakPtr(), request_id));
+                 weak_factory_io_to_io_.GetWeakPtr(), request_id, origin,
+                 service_worker_registration_id));
 }
 
 void PushMessagingMessageFilter::DidGetRegistration(
     int request_id,
+    const GURL& origin,
+    int64_t service_worker_registration_id,
     const std::string& push_registration_id,
     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:
+    case SERVICE_WORKER_OK: {
       if (push_endpoint_base_.is_empty()) {
         // 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;
       }
 
-      Send(new PushMessagingMsg_GetRegistrationSuccess(
-          request_id,
-          CreatePushEndpoint(push_endpoint_base_, push_registration_id)));
-      RecordGetRegistrationStatus(PUSH_GETREGISTRATION_STATUS_SUCCESS);
+      const GURL endpoint =
+          CreatePushEndpoint(push_endpoint_base_, push_registration_id);
+
+      auto callback =
+          base::Bind(&PushMessagingMessageFilter::DidGetRegistrationKeys,
+                     weak_factory_io_to_io_.GetWeakPtr(), request_id, endpoint);
+
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&Core::GetPublicEncryptionKeyOnUI,
+                     base::Unretained(ui_core_.get()), origin,
+                     service_worker_registration_id, callback));
+
       return;
-    case SERVICE_WORKER_ERROR_NOT_FOUND:
+    }
+    case SERVICE_WORKER_ERROR_NOT_FOUND: {
       get_status = PUSH_GETREGISTRATION_STATUS_REGISTRATION_NOT_FOUND;
       break;
-    case SERVICE_WORKER_ERROR_FAILED:
+    }
+    case SERVICE_WORKER_ERROR_FAILED: {
       get_status = PUSH_GETREGISTRATION_STATUS_STORAGE_ERROR;
       break;
+    }
     case SERVICE_WORKER_ERROR_ABORT:
     case SERVICE_WORKER_ERROR_START_WORKER_FAILED:
     case SERVICE_WORKER_ERROR_PROCESS_NOT_FOUND:
     case SERVICE_WORKER_ERROR_EXISTS:
     case SERVICE_WORKER_ERROR_INSTALL_WORKER_FAILED:
     case SERVICE_WORKER_ERROR_ACTIVATE_WORKER_FAILED:
     case SERVICE_WORKER_ERROR_IPC_FAILED:
     case SERVICE_WORKER_ERROR_NETWORK:
     case SERVICE_WORKER_ERROR_SECURITY:
     case SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED:
     case SERVICE_WORKER_ERROR_STATE:
     case SERVICE_WORKER_ERROR_TIMEOUT:
     case SERVICE_WORKER_ERROR_SCRIPT_EVALUATE_FAILED:
     case SERVICE_WORKER_ERROR_DISK_CACHE:
     case SERVICE_WORKER_ERROR_REDUNDANT:
-    case SERVICE_WORKER_ERROR_MAX_VALUE:
+    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_GetRegistrationError(request_id, get_status));
   RecordGetRegistrationStatus(get_status);
 }
 
+void PushMessagingMessageFilter::DidGetRegistrationKeys(

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

Please add a DCHECK_CURRENTLY_ON.

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

Done.

+    int request_id,
+    const GURL& endpoint,
+    bool success,
+    const std::vector<uint8_t>& curve25519dh) {
+  if (!success) {
+    PushGetRegistrationStatus status =
+        PUSH_GETREGISTRATION_STATUS_PUBLIC_KEY_UNAVAILABLE;
+
+    Send(new PushMessagingMsg_GetRegistrationError(request_id, status));
+
+    RecordGetRegistrationStatus(status);
+    return;
+  }
+
+  Send(new PushMessagingMsg_GetRegistrationSuccess(request_id, endpoint,
+                                                   curve25519dh));
+
+  RecordGetRegistrationStatus(PUSH_GETREGISTRATION_STATUS_SUCCESS);
+}
+
 // GetPermission methods on both IO and UI threads, merged in order of use from
 // PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnGetPermissionStatus(
     int request_id,
     int64_t service_worker_registration_id,
     bool user_visible) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   ServiceWorkerRegistration* service_worker_registration =
@@ skipping 58 matching lines @@
 PushMessagingService* PushMessagingMessageFilter::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