Revert "Use the same codepath for NOTIFICATIONS and PUSH_MESSAGING permissions"

chrome/browser/push_messaging/push_messaging_permission_context.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_permission_context.h"
+
+#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/browser/permissions/permission_manager.h"
+#include "chrome/browser/permissions/permission_request_id.h"
+#include "chrome/browser/permissions/permission_uma_util.h"
+#include "chrome/browser/profiles/profile.h"
+#include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/permission_type.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_contents_delegate.h"
+#include "content/public/common/origin_util.h"
+
+PushMessagingPermissionContext::PushMessagingPermissionContext(Profile* profile)
+    : PermissionContextBase(profile,
+                            content::PermissionType::PUSH_MESSAGING,
+                            CONTENT_SETTINGS_TYPE_PUSH_MESSAGING),
+      profile_(profile),
+      weak_factory_ui_thread_(this) {}
+
+PushMessagingPermissionContext::~PushMessagingPermissionContext() {}
+
+ContentSetting PushMessagingPermissionContext::GetPermissionStatus(
+    const GURL& requesting_origin,
+    const GURL& embedding_origin) const {
+  // It's possible for this to return CONTENT_SETTING_BLOCK in cases where
+  // HostContentSettingsMap::GetContentSetting returns CONTENT_SETTING_ALLOW.
+  // TODO(johnme): This is likely to break assumptions made elsewhere, so we
+  // should try to remove this quirk.
+#if defined(ENABLE_NOTIFICATIONS)
+  if (requesting_origin != embedding_origin)
+    return CONTENT_SETTING_BLOCK;
+
+  ContentSetting push_content_setting =
+      PermissionContextBase::GetPermissionStatus(requesting_origin,
+                                                 embedding_origin);
+
+  blink::mojom::PermissionStatus notifications_permission =
+      PermissionManager::Get(profile_)->GetPermissionStatus(
+          content::PermissionType::NOTIFICATIONS, requesting_origin,
+          embedding_origin);
+
+  if (notifications_permission == blink::mojom::PermissionStatus::DENIED ||
+      push_content_setting == CONTENT_SETTING_BLOCK) {
+    return CONTENT_SETTING_BLOCK;
+  }
+  if (notifications_permission == blink::mojom::PermissionStatus::ASK)
+    return CONTENT_SETTING_ASK;
+
+  DCHECK(push_content_setting == CONTENT_SETTING_ALLOW ||
+         push_content_setting == CONTENT_SETTING_ASK);
+
+  // If the notifications permission has already been granted,
+  // and the push permission isn't explicitly blocked, then grant
+  // allow permission.
+  return CONTENT_SETTING_ALLOW;
+#else
+  return CONTENT_SETTING_BLOCK;
+#endif
+}
+
+// Unlike other permissions, push is decided by the following algorithm
+//  - You need to request it from a top level domain
+//  - You need to have notification permission granted.
+//  - You need to not have push permission explicitly blocked.
+//  - If those 3 things are true it is granted without prompting.
+// This is done to avoid double prompting for notifications and push.
+void PushMessagingPermissionContext::DecidePermission(
+    content::WebContents* web_contents,
+    const PermissionRequestID& id,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin,
+    bool user_gesture,
+    const BrowserPermissionCallback& callback) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+#if defined(ENABLE_NOTIFICATIONS)
+  if (requesting_origin != embedding_origin) {
+    NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
+                        false /* persist */, CONTENT_SETTING_BLOCK);
+    return;
+  }
+
+  PermissionManager::Get(profile_)->RequestPermission(
+      content::PermissionType::NOTIFICATIONS, web_contents->GetMainFrame(),
+      requesting_origin, user_gesture,
+      base::Bind(&PushMessagingPermissionContext::DecidePushPermission,
+                 weak_factory_ui_thread_.GetWeakPtr(), id, requesting_origin,
+                 embedding_origin, callback));
+#else
+  NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
+                      false /* persist */, CONTENT_SETTING_BLOCK);
+#endif
+}
+
+bool PushMessagingPermissionContext::IsRestrictedToSecureOrigins() const {
+  return true;
+}
+
+void PushMessagingPermissionContext::DecidePushPermission(
+    const PermissionRequestID& id,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin,
+    const BrowserPermissionCallback& callback,
+    blink::mojom::PermissionStatus notification_status) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  DCHECK_NE(notification_status, blink::mojom::PermissionStatus::ASK);
+
+  ContentSetting push_content_setting =
+      HostContentSettingsMapFactory::GetForProfile(profile_)
+          ->GetContentSettingAndMaybeUpdateLastUsage(
+              requesting_origin, embedding_origin, content_settings_type(),
+              std::string());
+
+  if (push_content_setting == CONTENT_SETTING_BLOCK) {
+    DVLOG(1) << "Push permission was explicitly blocked.";
+    PermissionUmaUtil::PermissionDenied(permission_type(), requesting_origin,
+                                        profile_);
+    NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
+                        true /* persist */, CONTENT_SETTING_BLOCK);
+    return;
+  }
+
+  if (notification_status == blink::mojom::PermissionStatus::DENIED) {
+    DVLOG(1) << "Notification permission has not been granted.";
+    NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
+                        false /* persist */, CONTENT_SETTING_BLOCK);
+    return;
+  }
+
+  PermissionUmaUtil::PermissionGranted(permission_type(), requesting_origin,
+                                       profile_);
+  NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
+                      true /* persist */, CONTENT_SETTING_ALLOW);
+}