Group the different permission related methods in the content api.

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/prefs/scoped_user_pref_update.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 124 matching lines @@
 }
 
 DesktopNotificationService::~DesktopNotificationService() {
 }
 
 void DesktopNotificationService::RequestNotificationPermission(
     content::WebContents* web_contents,
     const PermissionRequestID& request_id,
     const GURL& requesting_origin,
     bool user_gesture,
-    const NotificationPermissionCallback& callback) {
+    const base::Callback<void(bool)>& result_callback) {
   DCHECK(BrowserThread::CurrentlyOn(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->GetRenderViewHost())) {
-    callback.Run(blink::WebNotificationPermissionAllowed);
+    result_callback.Run(true);
     return;
   }
 #endif
 
-  RequestPermission(
-      web_contents,
-      request_id,
-      requesting_origin,
-      user_gesture,
-      base::Bind(&DesktopNotificationService::OnNotificationPermissionRequested,
-                 weak_factory_.GetWeakPtr(),
-                 callback));
+  RequestPermission(web_contents,
+                    request_id,
+                    requesting_origin,
+                    user_gesture,
+                    result_callback);

[Peter Beverloo, 2014/10/24 14:37:28]

Please remove the WeakPtrFactory from the DesktopNotificationService now that
we're no longer using it.

[Miguel Garcia, 2014/10/24 16:05:32]

Done.

 }
 
 void DesktopNotificationService::ShowDesktopNotification(
     const content::ShowDesktopNotificationHostMsgParams& params,
     content::RenderFrameHost* render_frame_host,
     scoped_ptr<content::DesktopNotificationDelegate> delegate,
     base::Closure* cancel_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   const GURL& origin = params.origin;
   NotificationObjectProxy* proxy = new NotificationObjectProxy(delegate.Pass());
@@ skipping 155 matching lines @@
     const GURL& embedder_origin,
     bool allowed) {
   if (allowed) {
     DesktopNotificationProfileUtil::GrantPermission(
         profile_, requesting_origin);
   } else {
     DesktopNotificationProfileUtil::DenyPermission(profile_, requesting_origin);
   }
 }
 
-void DesktopNotificationService::OnNotificationPermissionRequested(
-    const NotificationPermissionCallback& callback, bool allowed) {
-  blink::WebNotificationPermission permission = allowed ?
-      blink::WebNotificationPermissionAllowed :
-      blink::WebNotificationPermissionDenied;
-
-  callback.Run(permission);
-}
-
 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::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
 }