Simplify permission-related code for Web Notifications.

chrome/browser/notifications/desktop_notification_service.cc

 // Copyright (c) 2012 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/notifications/desktop_notification_service.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/notifications/desktop_notification_profile_util.h"
 #include "chrome/browser/notifications/notification.h"
 #include "chrome/browser/notifications/notification_object_proxy.h"
 #include "chrome/browser/notifications/notification_ui_manager.h"
-#include "chrome/browser/permissions/permission_request_id.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/message_center/notifier_settings.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/browser/extensions/api/notifications/notifications_api.h"
@@ skipping 15 matching lines @@
 // DesktopNotificationService -------------------------------------------------
 
 // static
 void DesktopNotificationService::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterListPref(prefs::kMessageCenterDisabledExtensionIds);
   registry->RegisterListPref(prefs::kMessageCenterDisabledSystemComponentIds);
 }
 
 DesktopNotificationService::DesktopNotificationService(Profile* profile)
-    : PermissionContextBase(profile, CONTENT_SETTINGS_TYPE_NOTIFICATIONS),
-      profile_(profile)
+    : profile_(profile)
 #if defined(ENABLE_EXTENSIONS)
       ,
       extension_registry_observer_(this)
 #endif
 {
   OnStringListPrefChanged(
       prefs::kMessageCenterDisabledExtensionIds, &disabled_extension_ids_);
   OnStringListPrefChanged(
       prefs::kMessageCenterDisabledSystemComponentIds,
       &disabled_system_component_ids_);
@@ skipping 15 matching lines @@
           base::Unretained(&disabled_system_component_ids_)));
 #if defined(ENABLE_EXTENSIONS)
   extension_registry_observer_.Add(
       extensions::ExtensionRegistry::Get(profile_));
 #endif
 }
 
 DesktopNotificationService::~DesktopNotificationService() {
 }
 
-void DesktopNotificationService::RequestNotificationPermission(
-    content::WebContents* web_contents,
-    const PermissionRequestID& request_id,
-    const GURL& requesting_origin,
-    bool user_gesture,
-    const BrowserPermissionCallback& result_callback) {
-  DCHECK_CURRENTLY_ON(BrowserThread::UI);
-
-#if defined(ENABLE_EXTENSIONS)
-  extensions::InfoMap* extension_info_map =
-      extensions::ExtensionSystem::Get(profile_)->info_map();
-  const extensions::Extension* extension = NULL;
-  if (extension_info_map) {
-    extensions::ExtensionSet extensions;
-    extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
-        requesting_origin,
-        request_id.render_process_id(),
-        extensions::APIPermission::kNotifications,
-        &extensions);
-    for (extensions::ExtensionSet::const_iterator iter = extensions.begin();
-         iter != extensions.end(); ++iter) {
-      if (IsNotifierEnabled(NotifierId(
-              NotifierId::APPLICATION, (*iter)->id()))) {
-        extension = iter->get();
-        break;
-      }
-    }
-  }
-  if (IsExtensionWithPermissionOrSuggestInConsole(
-          extensions::APIPermission::kNotifications, extension,
-          web_contents->GetMainFrame())) {
-    result_callback.Run(CONTENT_SETTING_ALLOW);
-    return;
-  }
-#endif
-
-  // Track whether the requesting and embedding origins are different when
-  // permission to display Web Notifications is being requested.
-  UMA_HISTOGRAM_BOOLEAN("Notifications.DifferentRequestingEmbeddingOrigins",
-                        requesting_origin.GetOrigin() !=
-                            web_contents->GetLastCommittedURL().GetOrigin());
-
-  RequestPermission(web_contents,
-                    request_id,
-                    requesting_origin,
-                    user_gesture,
-                    result_callback);
-}
-
 bool DesktopNotificationService::IsNotifierEnabled(
     const NotifierId& notifier_id) const {
   switch (notifier_id.type) {
     case NotifierId::APPLICATION:
       return disabled_extension_ids_.find(notifier_id.id) ==
           disabled_extension_ids_.end();
     case NotifierId::WEB_PAGE:
       return DesktopNotificationProfileUtil::GetContentSetting(
           profile_, notifier_id.url) == CONTENT_SETTING_ALLOW;
     case NotifierId::SYSTEM_COMPONENT:
@@ skipping 76 matching lines @@
     return;
 
   // The settings for ephemeral apps will be persisted across cache evictions.
   if (extensions::util::IsEphemeralApp(extension->id(), profile_))
     return;
 
   SetNotifierEnabled(notifier_id, true);
 }
 #endif
 
-// Unlike other permission types, granting a notification for a given origin
-// will not take into account the |embedder_origin|, it will only be based
-// on the requesting iframe origin.
-// TODO(mukai) Consider why notifications behave differently than
-// other permissions. crbug.com/416894
-void DesktopNotificationService::UpdateContentSetting(
-    const GURL& requesting_origin,
-    const GURL& embedder_origin,
-    ContentSetting content_setting) {
-  DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
-         content_setting == CONTENT_SETTING_BLOCK);
-
-  if (content_setting == CONTENT_SETTING_ALLOW) {
-    DesktopNotificationProfileUtil::GrantPermission(
-        profile_, requesting_origin);
-  } else {
-    DesktopNotificationProfileUtil::DenyPermission(profile_, requesting_origin);
-  }
-}
-
-bool DesktopNotificationService::IsRestrictedToSecureOrigins() const {
-  return false;
-}
-
 void DesktopNotificationService::FirePermissionLevelChangedEvent(
     const NotifierId& notifier_id, bool enabled) {
 #if defined(ENABLE_EXTENSIONS)
   DCHECK_EQ(NotifierId::APPLICATION, notifier_id.type);
   extensions::api::notifications::PermissionLevel permission =
       enabled ? extensions::api::notifications::PERMISSION_LEVEL_GRANTED
               : extensions::api::notifications::PERMISSION_LEVEL_DENIED;
   scoped_ptr<base::ListValue> args(new base::ListValue());
   args->Append(new base::StringValue(
       extensions::api::notifications::ToString(permission)));
   scoped_ptr<extensions::Event> event(new extensions::Event(
       extensions::events::UNKNOWN,
       extensions::api::notifications::OnPermissionLevelChanged::kEventName,
       args.Pass()));
   extensions::EventRouter::Get(profile_)
       ->DispatchEventToExtension(notifier_id.id, event.Pass());
 
   // Tell the IO thread that this extension's permission for notifications
   // has changed.
   extensions::InfoMap* extension_info_map =
       extensions::ExtensionSystem::Get(profile_)->info_map();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&extensions::InfoMap::SetNotificationsDisabled,
                  extension_info_map, notifier_id.id, !enabled));
 #endif
 }