Partial implementation of subscription restrictions.

content/renderer/push_messaging/push_messaging_dispatcher.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/renderer/push_messaging/push_messaging_dispatcher.h"
 
+#include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/common/push_messaging_messages.h"
+#include "content/public/common/content_switches.h"
 #include "content/renderer/manifest/manifest_manager.h"
 #include "content/renderer/render_frame_impl.h"
 #include "ipc/ipc_message.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/modules/push_messaging/WebPushError.h"
 #include "third_party/WebKit/public/platform/modules/push_messaging/WebPushSubscription.h"
 #include "third_party/WebKit/public/platform/modules/push_messaging/WebPushSubscriptionOptions.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerRegistration.h"
 #include "third_party/WebKit/public/web/WebConsoleMessage.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ skipping 17 matching lines @@
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void PushMessagingDispatcher::subscribe(
     blink::WebServiceWorkerRegistration* service_worker_registration,
     const blink::WebPushSubscriptionOptions& options,
     blink::WebPushSubscriptionCallbacks* callbacks) {
   DCHECK(service_worker_registration);
   DCHECK(callbacks);
+  // TODO(harkness) If the command line flag for push subscriptions is enabled
+  // and the client provided a public key, don't load the manifest.
   RenderFrameImpl::FromRoutingID(routing_id())
       ->manifest_manager()
       ->GetManifest(base::Bind(
           &PushMessagingDispatcher::DoSubscribe, base::Unretained(this),
           service_worker_registration, options, callbacks));
 }
 
 void PushMessagingDispatcher::DoSubscribe(
     blink::WebServiceWorkerRegistration* service_worker_registration,
     const blink::WebPushSubscriptionOptions& options,
     blink::WebPushSubscriptionCallbacks* callbacks,
     const Manifest& manifest) {
   int request_id = subscription_callbacks_.Add(callbacks);
   int64_t service_worker_registration_id =
       static_cast<WebServiceWorkerRegistrationImpl*>(
           service_worker_registration)
           ->registration_id();
 
-  if (manifest.IsEmpty()) {
-    OnSubscribeFromDocumentError(
-        request_id, PUSH_REGISTRATION_STATUS_MANIFEST_EMPTY_OR_MISSING);
-    return;
-  }
+  ContentPushSubscriptionOptions content_options;
+  content_options.user_visible_only = options.userVisibleOnly;
 
-  std::string sender_id =
-      manifest.gcm_sender_id.is_null()
-          ? std::string()
-          : base::UTF16ToUTF8(manifest.gcm_sender_id.string());
-  if (sender_id.empty()) {
-    OnSubscribeFromDocumentError(request_id,
-                                 PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
-    return;
+  // If SubscriptionRestrictions aren't enabled or a public key isn't provided
+  // by the client, fall back to the old sender_id specification.
+  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kEnableExperimentalWebPlatformFeatures) ||

[Peter Beverloo, 2016/02/17 16:15:36]

No need to check for the command line flag— we can rely on Blink passing us an
empty applicationServerKey if the feature is disabled.

(When it does give us that value, we either have a bug in the bindings
generator, or the renderer has been compromised. I don't think we have to be
overly defensive for the first case, and in the latter case all bets are off
anyway.)

[harkness, 2016/02/18 10:45:15]

Done.

+      options.applicationServerKey.isEmpty()) {
+    if (manifest.IsEmpty()) {
+      OnSubscribeFromDocumentError(
+          request_id, PUSH_REGISTRATION_STATUS_MANIFEST_EMPTY_OR_MISSING);
+      return;
+    }
+
+    content_options.using_public_key = false;
+    content_options.sender_info =
+        manifest.gcm_sender_id.is_null()
+            ? std::string()
+            : base::UTF16ToUTF8(manifest.gcm_sender_id.string());
+    if (content_options.sender_info.empty()) {
+      OnSubscribeFromDocumentError(request_id,
+                                   PUSH_REGISTRATION_STATUS_NO_SENDER_ID);
+      return;
+    }
+  } else {
+    content_options.using_public_key = true;
+    content_options.sender_info = options.applicationServerKey.utf8();
+
+    // TODO(harkness) Need to check that appServicePublicKey has a valid
+    // format and reject with InvalidAccessError if invalid.
   }
 
   Send(new PushMessagingHostMsg_SubscribeFromDocument(
-      routing_id(), request_id,
-      manifest.gcm_sender_id.is_null()
-          ? std::string()
-          : base::UTF16ToUTF8(manifest.gcm_sender_id.string()),
-      options.userVisibleOnly, service_worker_registration_id));
+      routing_id(), request_id, content_options,
+      service_worker_registration_id));
 }
 
 void PushMessagingDispatcher::OnSubscribeFromDocumentSuccess(
     int32_t request_id,
     const GURL& endpoint,
     const std::vector<uint8_t>& p256dh,
     const std::vector<uint8_t>& auth) {
   blink::WebPushSubscriptionCallbacks* callbacks =
       subscription_callbacks_.Lookup(request_id);
   DCHECK(callbacks);
@@ skipping 17 matching lines @@
           : blink::WebPushError::ErrorTypeAbort;
 
   callbacks->onError(blink::WebPushError(
       error_type,
       blink::WebString::fromUTF8(PushRegistrationStatusToString(status))));
 
   subscription_callbacks_.Remove(request_id);
 }
 
 }  // namespace content