Unregister with push service and SW database when permission is lost.

chrome/browser/services/gcm/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/services/gcm/push_messaging_service_impl.h"
 
 #include <bitset>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
 #include "chrome/browser/notifications/platform_notification_service_impl.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/services/gcm/gcm_profile_service.h"
 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
 #include "chrome/browser/services/gcm/push_messaging_application_id.h"
 #include "chrome/browser/services/gcm/push_messaging_constants.h"
 #include "chrome/browser/services/gcm/push_messaging_permission_context.h"
 #include "chrome/browser/services/gcm/push_messaging_permission_context_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/permission_request_id.h"
 #include "components/gcm_driver/gcm_driver.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/service_worker_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/platform_notification_data.h"
 #include "content/public/common/push_messaging_status.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 72 matching lines @@
 }
 
 PushMessagingServiceImpl::PushMessagingServiceImpl(
     GCMProfileService* gcm_profile_service,
     Profile* profile)
     : gcm_profile_service_(gcm_profile_service),
       profile_(profile),
       push_registration_count_(0),
       pending_push_registration_count_(0),
       weak_factory_(this) {
+  // In some tests, we might end up with |profile_| being null at this point.
+  // When that is the case |profile_| will be set in SetProfileForTesting(), at
+  // which point the service will start to observe HostContentSettingsMap.
+  if (profile_)
+    profile_->GetHostContentSettingsMap()->AddObserver(this);
 }
 
 PushMessagingServiceImpl::~PushMessagingServiceImpl() {
   // TODO(johnme): If it's possible for this to be destroyed before GCMDriver,
   // then we should call RemoveAppHandler.
+  profile_->GetHostContentSettingsMap()->RemoveObserver(this);
 }
 
 void PushMessagingServiceImpl::IncreasePushRegistrationCount(int add,
                                                              bool is_pending) {
   DCHECK(add > 0);
   if (push_registration_count_ + pending_push_registration_count_ == 0) {
     gcm_profile_service_->driver()->AddAppHandler(
         kPushMessagingApplicationIdPrefix, this);
   }
   if (is_pending) {
@@ skipping 79 matching lines @@
       profile_,
       application_id.origin(),
       application_id.service_worker_registration_id(),
       data,
       base::Bind(&PushMessagingServiceImpl::DeliverMessageCallback,
                  weak_factory_.GetWeakPtr(),
                  application_id.app_id_guid(), application_id.origin(),
                  application_id.service_worker_registration_id(), message));
 }
 
+void PushMessagingServiceImpl::OnContentSettingChanged(
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern,
+    ContentSettingsType content_type,
+    std::string resource_identifier) {
+  if (content_type != CONTENT_SETTINGS_TYPE_PUSH_MESSAGING &&
+      content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS) {
+    return;
+  }
+
+  for (const auto& id : PushMessagingApplicationId::GetAll(profile_)) {
+    // If |primary_pattern| is not valid, we should always check for a
+    // 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(id.origin()))
+      continue;
+
+    if (HasPermission(id.origin()))
+      continue;
+
+    // Unregister the PushMessagingApplicationId with the push service.
+    Unregister(id.app_id_guid(), true /* retry */, UnregisterCallback());
+
+    // Clear the associated service worker push registration id.
+    PushMessagingService::ClearPushRegistrationID(
+        profile_, id.origin(), id.service_worker_registration_id());
+  }
+}
+
 void PushMessagingServiceImpl::SetProfileForTesting(Profile* profile) {
   profile_ = profile;
+  profile_->GetHostContentSettingsMap()->AddObserver(this);
 }
 
 void PushMessagingServiceImpl::DeliverMessageCallback(
     const std::string& app_id_guid,
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     const GCMClient::IncomingMessage& message,
     content::PushDeliveryStatus status) {
   // TODO(mvanouwerkerk): UMA logging.
   // TODO(mvanouwerkerk): Show a warning in the developer console of the
@@ skipping 368 matching lines @@
 void PushMessagingServiceImpl::Unregister(
     const GURL& requesting_origin,
     int64 service_worker_registration_id,
     bool retry_on_failure,
     const content::PushMessagingService::UnregisterCallback& callback) {
   DCHECK(gcm_profile_service_->driver());
 
   PushMessagingApplicationId application_id = PushMessagingApplicationId::Get(
       profile_, requesting_origin, service_worker_registration_id);
   if (!application_id.IsValid()) {
-    callback.Run(
-        content::PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED);
+    if (!callback.is_null()) {
+      callback.Run(
+          content::PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED);
+    }
     return;
   }
 
   Unregister(application_id.app_id_guid(), retry_on_failure, callback);
 }
 
 void PushMessagingServiceImpl::Unregister(
     const std::string& app_id_guid,
     bool retry_on_failure,
     const content::PushMessagingService::UnregisterCallback& callback) {
@@ skipping 18 matching lines @@
 }
 
 void PushMessagingServiceImpl::DidUnregister(
     const std::string& app_id_guid,
     bool retry_on_failure,
     const content::PushMessagingService::UnregisterCallback& callback,
     GCMClient::Result result) {
   if (result == GCMClient::SUCCESS) {
     PushMessagingApplicationId application_id =
         PushMessagingApplicationId::Get(profile_, app_id_guid);
-    if (application_id.IsValid())
-      application_id.DeleteFromDisk(profile_);
+    if (!application_id.IsValid()) {
+      if (!callback.is_null()) {
+        callback.Run(
+            content::PUSH_UNREGISTRATION_STATUS_SUCCESS_WAS_NOT_REGISTERED);
+      }
+      return;
+    }
+
+    application_id.DeleteFromDisk(profile_);
     DecreasePushRegistrationCount(1, false /* was_pending */);
   }
 
   // Internal calls pass a null callback.
   if (!callback.is_null()) {
     switch (result) {
     case GCMClient::SUCCESS:
       callback.Run(content::PUSH_UNREGISTRATION_STATUS_SUCCESS_UNREGISTER);
       break;
     case GCMClient::NETWORK_ERROR:
@@ skipping 22 matching lines @@
 bool PushMessagingServiceImpl::HasPermission(const GURL& origin) {
   gcm::PushMessagingPermissionContext* permission_context =
       gcm::PushMessagingPermissionContextFactory::GetForProfile(profile_);
   DCHECK(permission_context);
 
   return permission_context->GetPermissionStatus(origin, origin) ==
       CONTENT_SETTING_ALLOW;
 }
 
 }  // namespace gcm