Push API: Implement and ship PushSubscription.options

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 <vector>
 
 #include "base/bind.h"
@@ skipping 501 matching lines @@
     DCHECK(!ui_core_->is_incognito());
     SendSubscriptionError(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, p256dh, auth));
+        data.render_frame_id, data.request_id, endpoint, data.options, p256dh,
+        auth));
   } else {
     Send(new PushMessagingMsg_SubscribeFromWorkerSuccess(
-        data.request_id, endpoint, p256dh, auth));
+        data.request_id, endpoint, data.options, p256dh, auth));
   }
   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 181 matching lines @@
 // GetSubscription methods on both IO and UI threads, merged in order of use
 // from PushMessagingMessageFilter and Core.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnGetSubscription(
     int request_id,
     int64_t service_worker_registration_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // TODO(johnme): Validate arguments?
   service_worker_context_->GetRegistrationUserData(
-      service_worker_registration_id, {kPushSenderIdServiceWorkerKey},
-      base::Bind(&PushMessagingMessageFilter::DidGetSenderInfo,
+      service_worker_registration_id,
+      {kPushRegistrationIdServiceWorkerKey, kPushSenderIdServiceWorkerKey},
+      base::Bind(&PushMessagingMessageFilter::DidGetSubscription,
                  weak_factory_io_to_io_.GetWeakPtr(), request_id,
                  service_worker_registration_id));
 }
 
-void PushMessagingMessageFilter::DidGetSenderInfo(
-    int request_id,
-    int64_t service_worker_registration_id,
-    const std::vector<std::string>& sender_info,
-    ServiceWorkerStatusCode status) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (status != SERVICE_WORKER_OK || sender_info.size() != 1) {
-    DidGetSubscription(request_id, service_worker_registration_id,
-                       false /* uses_standard_protocol */,
-                       std::vector<std::string>() /* push_subscription_id */,
-                       status);
-    return;
-  }
-
-  const bool uses_standard_protocol = IsApplicationServerKey(sender_info[0]);
-  service_worker_context_->GetRegistrationUserData(
-      service_worker_registration_id, {kPushRegistrationIdServiceWorkerKey},
-      base::Bind(&PushMessagingMessageFilter::DidGetSubscription,
-                 weak_factory_io_to_io_.GetWeakPtr(), request_id,
-                 service_worker_registration_id, uses_standard_protocol));
-}
-
 void PushMessagingMessageFilter::DidGetSubscription(
     int request_id,
     int64_t service_worker_registration_id,
-    bool uses_standard_protocol,
-    const std::vector<std::string>& push_subscription_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();

[Peter Beverloo, 2016/07/08 18:30:11]

nit: move to :770?

[johnme, 2016/07/13 17:51:57]

Done.

 
-      const GURL origin = registration->pattern().GetOrigin();
-      DCHECK_EQ(1u, push_subscription_id.size());
-      const GURL endpoint =
-          CreateEndpoint(uses_standard_protocol, push_subscription_id[0]);
+      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);
+                     weak_factory_io_to_io_.GetWeakPtr(), request_id, 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, callback));
 
       return;
     }
     case SERVICE_WORKER_ERROR_NOT_FOUND: {
@@ skipping 27 matching lines @@
       break;
     }
   }
   Send(new PushMessagingMsg_GetSubscriptionError(request_id, get_status));
   RecordGetRegistrationStatus(get_status);
 }
 
 void PushMessagingMessageFilter::DidGetSubscriptionKeys(
     int request_id,
     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));
 
     RecordGetRegistrationStatus(status);
     return;
   }
 
+  PushSubscriptionOptions options;
+  // We reject subscription requests with userVisibleOnly false, so it must have

[Peter Beverloo, 2016/07/08 18:30:11]

nit: don't use "we" in comments. Probably want to avoid "Chrome" too.

[johnme, 2016/07/13 17:51:57]

Ended up putting Chrome, since I'm relying on an implementation detail of
Chromium, and
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md
says to write Chrome not Chromium in comments.

+  // 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,
-                                                   p256dh, auth));
+                                                   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.
 // -----------------------------------------------------------------------------
 
 void PushMessagingMessageFilter::OnGetPermissionStatus(
     int request_id,
@@ skipping 89 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