Reduce the impact of the push/notification kill switches

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/base64url.h"
@@ skipping 259 matching lines @@
   PushMessagingAppIdentifier app_identifier =
       PushMessagingAppIdentifier::FindByAppId(profile_, app_id);
   // Drop message and unregister if app_id was unknown (maybe recently deleted).
   if (app_identifier.is_null()) {
     DeliverMessageCallback(app_id, GURL::EmptyGURL(),
                            -1 /* kInvalidServiceWorkerRegistrationId */,
                            message, message_handled_closure,
                            content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID);
     return;
   }
-  // Drop message and unregister if |origin| has lost push permission.
-  if (!IsPermissionSet(app_identifier.origin())) {
+
+  // Drop message and unregister if |origin| has lost push permission. However,
+  // we should only drop the subscription if the permission was in fact denied
+  // rather than suspended, for example through the kill switch.
+  PermissionResult permission_result =
+      PermissionManager::Get(profile_)->GetPermissionStatus(
+          CONTENT_SETTINGS_TYPE_PUSH_MESSAGING, app_identifier.origin(),
+          app_identifier.origin());
+
+  if (permission_result.content_setting != CONTENT_SETTING_ALLOW) {
+    content::PushDeliveryStatus status =
+        content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED;
+
+    switch (permission_result.source) {
+      case PermissionStatusSource::KILL_SWITCH:
+        status = content::PUSH_DELIVERY_STATUS_PERMISSION_SUSPENDED;
+        break;
+      case PermissionStatusSource::UNSPECIFIED:
+      case PermissionStatusSource::SAFE_BROWSING_BLACKLIST:
+      case PermissionStatusSource::MULTIPLE_DISMISSALS:
+      case PermissionStatusSource::MULTIPLE_IGNORES:
+        status = content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED;
+        break;
+    }
+
     DeliverMessageCallback(app_id, app_identifier.origin(),
                            app_identifier.service_worker_registration_id(),
-                           message, message_handled_closure,
-                           content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED);
+                           message, message_handled_closure, status);
     return;
   }
 
   rappor::SampleDomainAndRegistryFromGURL(
       g_browser_process->rappor_service(),
       "PushMessaging.MessageReceived.Origin", app_identifier.origin());
 
   // The payload of a push message can be valid with content, valid with empty
   // content, or null. Only set the payload data if it is non-null.
   content::PushEventPayload payload;
@@ skipping 66 matching lines @@
       // Do nothing, and hope the error is transient.
       break;
     case content::PUSH_DELIVERY_STATUS_UNKNOWN_APP_ID:
       unsubscribe_reason =
           content::PUSH_UNREGISTRATION_REASON_DELIVERY_UNKNOWN_APP_ID;
       break;
     case content::PUSH_DELIVERY_STATUS_PERMISSION_DENIED:
       unsubscribe_reason =
           content::PUSH_UNREGISTRATION_REASON_DELIVERY_PERMISSION_DENIED;
       break;
+    case content::PUSH_DELIVERY_STATUS_PERMISSION_SUSPENDED:
+      // Do nothing, the kill switch might be withdrawn at some point.
+      break;
     case content::PUSH_DELIVERY_STATUS_NO_SERVICE_WORKER:
       unsubscribe_reason =
           content::PUSH_UNREGISTRATION_REASON_DELIVERY_NO_SERVICE_WORKER;
       break;
   }
 
   if (unsubscribe_reason != content::PUSH_UNREGISTRATION_REASON_UNKNOWN) {
     PushMessagingAppIdentifier app_identifier =
         PushMessagingAppIdentifier::FindByAppId(profile_, app_id);
     UnsubscribeInternal(
@@ skipping 514 matching lines @@
     // permission change because it can happen for example when the entire
     // Push or Notifications permissions are cleared.
     // Otherwise, the permission should be checked if the pattern matches the
     // origin.
     if (primary_pattern.IsValid() &&
         !primary_pattern.Matches(app_identifier.origin())) {
       barrier_closure.Run();
       continue;
     }
 
-    if (IsPermissionSet(app_identifier.origin())) {
+    if (GetPermissionStatus(app_identifier.origin(), true /* user_visible */) ==
+        blink::kWebPushPermissionStatusGranted) {
       barrier_closure.Run();
       continue;
     }
 
     bool need_sender_id = false;
 #if defined(OS_ANDROID)
     need_sender_id =
         !PushMessagingAppIdentifier::UseInstanceID(app_identifier.app_id());
 #endif
     if (need_sender_id) {
@@ skipping 85 matching lines @@
   if (sender_info.size() != 65 || sender_info[0] != 0x04)
     return sender_info;
 
   std::string encoded_sender_info;
   base::Base64UrlEncode(sender_info, base::Base64UrlEncodePolicy::OMIT_PADDING,
                         &encoded_sender_info);
 
   return encoded_sender_info;
 }
 
-// Assumes user_visible always since this is just meant to check
-// if the permission was previously granted and not revoked.
-bool PushMessagingServiceImpl::IsPermissionSet(const GURL& origin) {
-  return GetPermissionStatus(origin, true /* user_visible */) ==
-         blink::kWebPushPermissionStatusGranted;
-}
-
 void PushMessagingServiceImpl::GetEncryptionInfoForAppId(
     const std::string& app_id,
     const std::string& sender_id,
     gcm::GCMEncryptionProvider::EncryptionInfoCallback callback) {
   if (PushMessagingAppIdentifier::UseInstanceID(app_id)) {
     GetInstanceIDDriver()->GetInstanceID(app_id)->GetEncryptionInfo(
         NormalizeSenderInfo(sender_id), callback);
   } else {
     GetGCMDriver()->GetEncryptionInfo(app_id, callback);
   }
 }
 
 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();
 }
 
 instance_id::InstanceIDDriver* PushMessagingServiceImpl::GetInstanceIDDriver()
     const {
   instance_id::InstanceIDProfileService* instance_id_profile_service =
       instance_id::InstanceIDProfileServiceFactory::GetForProfile(profile_);
   CHECK(instance_id_profile_service);
   CHECK(instance_id_profile_service->driver());
   return instance_id_profile_service->driver();
 }