Group the different permission related methods in the content api.

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 90 matching lines @@
 #include "components/signin/core/common/profile_management_switches.h"
 #include "components/translate/core/common/translate_switches.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/browser_main_parts.h"
 #include "content/public/browser/browser_ppapi_host.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/browser_url_handler.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/desktop_notification_delegate.h"
+#include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/child_process_host.h"
 #include "content/public/common/content_descriptors.h"
 #include "content/public/common/show_desktop_notification_params.h"
 #include "content/public/common/url_utils.h"
@@ skipping 1688 matching lines @@
     int render_process_id,
     int render_frame_id) {
   chrome::SSLAddCertificate(cert_type, cert_data, cert_size,
                             render_process_id, render_frame_id);
 }
 
 content::MediaObserver* ChromeContentBrowserClient::GetMediaObserver() {
   return MediaCaptureDevicesDispatcher::GetInstance();
 }
 
-void ChromeContentBrowserClient::RequestDesktopNotificationPermission(
-    const GURL& source_origin,
-    content::RenderFrameHost* render_frame_host,
-    const base::Callback<void(blink::WebNotificationPermission)>& callback) {
-#if defined(ENABLE_NOTIFICATIONS)
-  // Skip showing the infobar if the request comes from an extension, and that
-  // extension has the 'notify' permission. (If the extension does not have the
-  // permission, the user will still be prompted.)
-  Profile* profile = Profile::FromBrowserContext(
-      render_frame_host->GetSiteInstance()->GetBrowserContext());
-  DesktopNotificationService* notification_service =
-      DesktopNotificationServiceFactory::GetForProfile(profile);
-  WebContents* web_contents = WebContents::FromRenderFrameHost(
-      render_frame_host);
-  int render_process_id = render_frame_host->GetProcess()->GetID();
-  const PermissionRequestID request_id(render_process_id,
-      web_contents->GetRoutingID(),
-      -1 /* bridge id */,
-      GURL());
-
-  notification_service->RequestNotificationPermission(
-      web_contents,
-      request_id,
-      source_origin,
-      // TODO(peter): plumb user_gesture over IPC
-      true,
-      callback);
-
-#else
-  NOTIMPLEMENTED();
-#endif
-}
-
 blink::WebNotificationPermission
 ChromeContentBrowserClient::CheckDesktopNotificationPermission(
     const GURL& source_origin,
     content::ResourceContext* context,
     int render_process_id) {
 #if defined(ENABLE_NOTIFICATIONS)
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
 #if defined(ENABLE_EXTENSIONS)
@@ skipping 48 matching lines @@
   service->ShowDesktopNotification(
       params, render_frame_host, delegate.Pass(), cancel_callback);
 
   profile->GetHostContentSettingsMap()->UpdateLastUsage(
       params.origin, params.origin, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
-void ChromeContentBrowserClient::RequestGeolocationPermission(
+void ChromeContentBrowserClient::RequestPermission(
+    content::PermissionType permission,
     content::WebContents* web_contents,
     int bridge_id,
     const GURL& requesting_frame,
     bool user_gesture,
     const base::Callback<void(bool)>& result_callback) {
   int render_process_id = web_contents->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
 
   const PermissionRequestID request_id(render_process_id,
                                        render_view_id,
                                        bridge_id,
                                        requesting_frame);
-  GeolocationPermissionContextFactory::GetForProfile(
-      Profile::FromBrowserContext(web_contents->GetBrowserContext()))->
-          RequestPermission(web_contents, request_id,
-                            requesting_frame.GetOrigin(), user_gesture,
-                            result_callback);
+
+  switch (permission) {
+    case content::PERMISSION_MIDI_SYSEX:
+      MidiPermissionContextFactory::GetForProfile(profile)
+          ->RequestPermission(web_contents,
+                              request_id,
+                              requesting_frame,
+                              user_gesture,
+                              result_callback);
+      break;
+#if defined(ENABLE_NOTIFICATIONS)
+    case content::PERMISSION_NOTIFICATIONS:
+      DesktopNotificationServiceFactory::GetForProfile(profile)
+          ->RequestNotificationPermission(web_contents,
+                                          request_id,
+                                          requesting_frame,
+                                          user_gesture,
+                                          result_callback);
+      break;
+#else
+      NOTIMPLEMENTED();
+#endif
+    case content::PERMISSION_GEOLOCATION:
+      GeolocationPermissionContextFactory::GetForProfile(profile)
+          ->RequestPermission(web_contents,
+                              request_id,
+                              requesting_frame.GetOrigin(),
+                              user_gesture,
+                              result_callback);
+      break;
+#if defined(OS_ANDROID)
+    case content::PERMISSION_PROTECTED_MEDIA:
+      ProtectedMediaIdentifierPermissionContextFactory::GetForProfile(profile)
+          ->RequestProtectedMediaIdentifierPermission(
+              web_contents, requesting_frame, result_callback);
+      break;
+#endif
+    default:
+      LOG(WARNING) << "Permission not available " << permission;
+  }
 }
 
-void ChromeContentBrowserClient::CancelGeolocationPermissionRequest(
+void ChromeContentBrowserClient::CancelPermissionRequest(
+    content::PermissionType permission,
     content::WebContents* web_contents,
     int bridge_id,
     const GURL& requesting_frame) {
   int render_process_id = web_contents->GetRenderProcessHost()->GetID();
   int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
 
   const PermissionRequestID request_id(render_process_id,
                                        render_view_id,
                                        bridge_id,
                                        requesting_frame);
-  GeolocationPermissionContextFactory::GetForProfile(
-        Profile::FromBrowserContext(web_contents->GetBrowserContext()))->
-            CancelPermissionRequest(web_contents, request_id);
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  switch (permission) {
+    case content::PERMISSION_MIDI_SYSEX:
+      MidiPermissionContextFactory::GetForProfile(profile)
+          ->CancelPermissionRequest(web_contents, request_id);
+      break;
+#if defined(ENABLE_NOTIFICATIONS)
+    case content::PERMISSION_NOTIFICATIONS:
+      DesktopNotificationServiceFactory::GetForProfile(profile)
+          ->CancelPermissionRequest(web_contents, request_id);
+#else
+      NOTIMPLEMENTED();
+      break;
+#endif
+    case content::PERMISSION_GEOLOCATION:
+      GeolocationPermissionContextFactory::GetForProfile(profile)
+          ->CancelPermissionRequest(web_contents, request_id);
+      break;
+#if defined(OS_ANDROID)
+    case content::PERMISSION_PROTECTED_MEDIA:
+      ProtectedMediaIdentifierPermissionContextFactory::GetForProfile(profile)
+          ->CancelProtectedMediaIdentifierPermissionRequests(
+              render_process_id, render_view_id, requesting_frame);
+      break;
+#endif
+    default:
+      LOG(WARNING) << "Permission not available " << permission;
+  }
 }
 
-void ChromeContentBrowserClient::RequestMidiSysExPermission(
-    content::WebContents* web_contents,
-    int bridge_id,
-    const GURL& requesting_frame,
-    bool user_gesture,
-    base::Callback<void(bool)> result_callback,
-    base::Closure* cancel_callback) {
-  MidiPermissionContext* context =
-      MidiPermissionContextFactory::GetForProfile(
-          Profile::FromBrowserContext(web_contents->GetBrowserContext()));
-  int renderer_id = web_contents->GetRenderProcessHost()->GetID();
-  int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
-  const PermissionRequestID id(renderer_id, render_view_id, bridge_id, GURL());
-
-  context->RequestPermission(web_contents, id, requesting_frame,
-                             user_gesture, result_callback);
+// Helper method to translate from Permissions to ContentSettings
+static ContentSettingsType PermissionToContentSetting(
+    content::PermissionType permission) {
+  switch (permission) {
+    case content::PERMISSION_MIDI_SYSEX:
+      return CONTENT_SETTINGS_TYPE_MIDI_SYSEX;
+    case content::PERMISSION_NOTIFICATIONS:
+      return CONTENT_SETTINGS_TYPE_NOTIFICATIONS;
+    case content::PERMISSION_GEOLOCATION:
+      return CONTENT_SETTINGS_TYPE_GEOLOCATION;
+#if defined(OS_ANDROID)
+    case content::PERMISSION_PROTECTED_MEDIA:
+      return CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER;
+#endif
+    default:
+      NOTREACHED() << "Unknown content setting for permission " << permission;
+      return CONTENT_SETTINGS_TYPE_DEFAULT;
+  }
 }
 
-void ChromeContentBrowserClient::DidUseGeolocationPermission(
+void ChromeContentBrowserClient::RegisterPermissionUsage(
+    content::PermissionType permission,
     content::WebContents* web_contents,
     const GURL& frame_url,
     const GURL& main_frame_url) {
   Profile::FromBrowserContext(web_contents->GetBrowserContext())
       ->GetHostContentSettingsMap()
       ->UpdateLastUsage(
-          frame_url, main_frame_url, CONTENT_SETTINGS_TYPE_GEOLOCATION);
-}
-
-void ChromeContentBrowserClient::RequestProtectedMediaIdentifierPermission(
-    content::WebContents* web_contents,
-    const GURL& origin,
-    base::Callback<void(bool)> result_callback,
-    base::Closure* cancel_callback) {
-#if defined(OS_ANDROID)
-  ProtectedMediaIdentifierPermissionContext* context =
-      ProtectedMediaIdentifierPermissionContextFactory::GetForProfile(
-          Profile::FromBrowserContext(web_contents->GetBrowserContext()));
-  context->RequestProtectedMediaIdentifierPermission(web_contents,
-                                                     origin,
-                                                     result_callback,
-                                                     cancel_callback);
-#else
-  NOTIMPLEMENTED();
-  result_callback.Run(false);
-#endif  // defined(OS_ANDROID)
+          frame_url, main_frame_url, PermissionToContentSetting(permission));
 }
 
 bool ChromeContentBrowserClient::CanCreateWindow(
     const GURL& opener_url,
     const GURL& opener_top_level_frame_url,
     const GURL& source_origin,
     WindowContainerType container_type,
     const GURL& target_url,
     const content::Referrer& referrer,
     WindowOpenDisposition disposition,
@@ skipping 599 matching lines @@
       switches::kDisableWebRtcEncryption,
     };
     to_command_line->CopySwitchesFrom(from_command_line,
                                       kWebRtcDevSwitchNames,
                                       arraysize(kWebRtcDevSwitchNames));
   }
 }
 #endif  // defined(ENABLE_WEBRTC)
 
 }  // namespace chrome