Push API: Validate storage before returning cached subscriptions

content/shell/browser/layout_test/layout_test_push_messaging_service.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/shell/browser/layout_test/layout_test_push_messaging_service.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "content/public/browser/permission_type.h"
@@ skipping 57 matching lines @@
   return GURL(standard_protocol ? "https://example.com/StandardizedEndpoint/"
                                 : "https://example.com/LayoutTestEndpoint/");
 }
 
 void LayoutTestPushMessagingService::SubscribeFromDocument(
     const GURL& requesting_origin,
     int64_t service_worker_registration_id,
     int renderer_id,
     int render_frame_id,
     const PushSubscriptionOptions& options,
-    const PushMessagingService::RegisterCallback& callback) {
+    const RegisterCallback& callback) {
   SubscribeFromWorker(requesting_origin, service_worker_registration_id,
                       options, callback);
 }
 
 void LayoutTestPushMessagingService::SubscribeFromWorker(
     const GURL& requesting_origin,
     int64_t service_worker_registration_id,
     const PushSubscriptionOptions& options,
-    const PushMessagingService::RegisterCallback& callback) {
+    const RegisterCallback& callback) {
   if (GetPermissionStatus(requesting_origin, options.user_visible_only) ==
       blink::WebPushPermissionStatusGranted) {
     std::vector<uint8_t> p256dh(
         kTestP256Key, kTestP256Key + arraysize(kTestP256Key));
     std::vector<uint8_t> auth(
         kAuthentication, kAuthentication + arraysize(kAuthentication));
 
     subscribed_service_worker_registration_ = service_worker_registration_id;
     callback.Run("layoutTestRegistrationId", p256dh, auth,
                  PUSH_REGISTRATION_STATUS_SUCCESS_FROM_PUSH_SERVICE);
   } else {
     callback.Run("registration_id", std::vector<uint8_t>() /* p256dh */,
                  std::vector<uint8_t>() /* auth */,
                  PUSH_REGISTRATION_STATUS_PERMISSION_DENIED);
   }
 }
 
-void LayoutTestPushMessagingService::GetEncryptionInfo(
+void LayoutTestPushMessagingService::GetSubscriptionInfo(
     const GURL& origin,
     int64_t service_worker_registration_id,
     const std::string& sender_id,
-    const EncryptionInfoCallback& callback) {
+    const std::string& subscription_id,
+    const SubscriptionInfoCallback& callback) {
   std::vector<uint8_t> p256dh(
         kTestP256Key, kTestP256Key + arraysize(kTestP256Key));
   std::vector<uint8_t> auth(
         kAuthentication, kAuthentication + arraysize(kAuthentication));
 
-  callback.Run(true /* success */, p256dh, auth);
+  callback.Run(true /* is_valid */, p256dh, auth);
 }
 
 blink::WebPushPermissionStatus
 LayoutTestPushMessagingService::GetPermissionStatus(const GURL& origin,
                                                     bool user_visible) {
   return ToWebPushPermissionStatus(LayoutTestContentBrowserClient::Get()
       ->browser_context()
       ->GetPermissionManager()
       ->GetPermissionStatus(PermissionType::PUSH_MESSAGING, origin, origin));
 }
 
 bool LayoutTestPushMessagingService::SupportNonVisibleMessages() {
   return false;
 }
 
 void LayoutTestPushMessagingService::Unsubscribe(
+    PushUnregistrationReason reason,
     const GURL& requesting_origin,
     int64_t service_worker_registration_id,
     const std::string& sender_id,
     const UnregisterCallback& callback) {
   ClearPushSubscriptionId(
       LayoutTestContentBrowserClient::Get()->browser_context(),
       requesting_origin, service_worker_registration_id,
       base::Bind(callback,
                  service_worker_registration_id ==
                          subscribed_service_worker_registration_
@@ skipping 10 matching lines @@
     const GURL& origin,
     int64_t service_worker_registration_id) {
   if (service_worker_registration_id ==
       subscribed_service_worker_registration_) {
     subscribed_service_worker_registration_ =
         kInvalidServiceWorkerRegistrationId;
   }
 }
 
 }  // namespace content