Group the different permission related methods in the content api.

content/public/browser/content_browser_client.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_CONTENT_BROWSER_CLIENT_H_
 #define CONTENT_PUBLIC_BROWSER_CONTENT_BROWSER_CLIENT_H_
 
 #include <map>
 #include <string>
 #include <utility>
@@ skipping 90 matching lines @@
 class SiteInstance;
 class SpeechRecognitionManagerDelegate;
 class VibrationProvider;
 class WebContents;
 class WebContentsViewDelegate;
 struct MainFunctionParams;
 struct Referrer;
 struct ShowDesktopNotificationHostMsgParams;
 struct WebPreferences;
 
+
+// Enum for UMA purposes, make sure you update histograms.xml if you add new

[Bernhard Bauer, 2014/10/20 14:57:24]

This enum is now for more than just UMA.

[Miguel Garcia, 2014/10/21 17:17:12]

Acknowledged.

+// permission actions. Never delete or reorder an entry; only add new entries
+// immediately before PERMISSION_NUM
+enum PermissionType {

[jam, 2014/10/20 20:13:57]

this should go into a separate file in content/public/browser per
http://www.chromium.org/developers/content-module/content-api

[Miguel Garcia, 2014/10/21 17:17:12]

Done.

+  PERMISSION_UNKNOWN = 0,

[jam, 2014/10/20 20:13:57]

why is unknown needed?

[Miguel Garcia, 2014/10/21 17:17:12]

It is not really needed but UMA expects it so I'd rather leave it there.

[Bernhard Bauer, 2014/10/23 08:38:01]

Why does UMA expect it? The only reference I can find is in
chrome/browser/content_settings/permission_context_uma_util.cc as a fallback
value for an unknown content setting, and we could simply not record anything in
that case (which should not be reached anyway, so there's no reason to handle it
in production code).

[Miguel Garcia, 2014/10/23 12:48:11]

Bernhard explained that the one exception to the rule of "do not remove values"
is entries at the beginning of the range so this can safely be removed.

On 2014/10/23 08:38:01, Bernhard Bauer wrote:

+  PERMISSION_MIDI_SYSEX = 1,
+  PERMISSION_PUSH_MESSAGING = 2,
+  PERMISSION_NOTIFICATIONS = 3,
+  PERMISSION_GEOLOCATION = 4,
+  PERMISSION_PROTECTED_MEDIA = 5,
+
+  // Always keep this at the end.
+  PERMISSION_NUM,
+};
+
 // A mapping from the scheme name to the protocol handler that services its
 // content.
 typedef std::map<
   std::string, linked_ptr<net::URLRequestJobFactory::ProtocolHandler> >
     ProtocolHandlerMap;
 
 // A scoped vector of protocol interceptors.
 typedef ScopedVector<net::URLRequestInterceptor>
     URLRequestInterceptorScopedVector;
 
@@ skipping 289 matching lines @@
   virtual void AddCertificate(net::CertificateMimeType cert_type,
                               const void* cert_data,
                               size_t cert_size,
                               int render_process_id,
                               int render_frame_id) {}
 
   // Returns a class to get notifications about media event. The embedder can
   // return NULL if they're not interested.
   virtual MediaObserver* GetMediaObserver();
 
-  // Asks permission to show desktop notifications. |callback| needs to be run
-  // when the user approves the request.
-  virtual void RequestDesktopNotificationPermission(
-      const GURL& source_origin,
-      RenderFrameHost* render_frame_host,
-      const base::Callback<void(blink::WebNotificationPermission)>& callback) {}
-
   // Checks if the given page has permission to show desktop notifications.
   // This is called on the IO thread.
   virtual blink::WebNotificationPermission
       CheckDesktopNotificationPermission(
           const GURL& source_url,
           ResourceContext* context,
           int render_process_id);
 
   // Show a desktop notification. If |cancel_callback| is non-null, it's set to
   // a callback which can be used to cancel the notification.
   virtual void ShowDesktopNotification(
       const ShowDesktopNotificationHostMsgParams& params,
       RenderFrameHost* render_frame_host,
       scoped_ptr<DesktopNotificationDelegate> delegate,
       base::Closure* cancel_callback) {}
 
-  // The renderer is requesting permission to use Geolocation. When the answer
-  // to a permission request has been determined, |result_callback| should be
-  // called with the result. If |cancel_callback| is non-null, it's set to a
-  // callback which can be used to cancel the permission request.
-  virtual void RequestGeolocationPermission(
+  virtual void RequestPermission(
+      PermissionType permission,
       WebContents* web_contents,
       int bridge_id,
       const GURL& requesting_frame,
       bool user_gesture,
-      const base::Callback<void(bool)>& result_callback);
+      const base::Callback<void(bool)>& result_callback) {}
 
-  virtual void CancelGeolocationPermissionRequest(
+
+  virtual void CancelPermissionRequest(
+      PermissionType permission,
       WebContents* web_contents,
       int bridge_id,
-      const GURL& requesting_frame);
+      const GURL& requesting_frame) {}
 
-  // Invoked when the Geolocation API uses its permission.
-  virtual void DidUseGeolocationPermission(WebContents* web_contents,
-                                           const GURL& frame_url,
-                                           const GURL& main_frame_url) {}
+  virtual void RegisterPermissionUsage(PermissionType permission,
+                                       WebContents* web_contents,
+                                       const GURL& frame_url,
+                                       const GURL& main_frame_url) {}
 
-  // Requests a permission to use system exclusive messages in MIDI events.
-  // |result_callback| will be invoked when the request is resolved. If
-  // |cancel_callback| is non-null, it's set to a callback which can be used to
-  // cancel the permission request.
-  virtual void RequestMidiSysExPermission(
-      WebContents* web_contents,
-      int bridge_id,
-      const GURL& requesting_frame,
-      bool user_gesture,
-      base::Callback<void(bool)> result_callback,
-      base::Closure* cancel_callback);
-
-  // Request permission to access protected media identifier. |result_callback
-  // will tell whether it's permitted. If |cancel_callback| is non-null, it's
-  // set to a callback which can be used to cancel the permission request.
-  virtual void RequestProtectedMediaIdentifierPermission(
-      WebContents* web_contents,
-      const GURL& origin,
-      base::Callback<void(bool)> result_callback,
-      base::Closure* cancel_callback);
 
   // Returns true if the given page is allowed to open a window of the given
   // type. If true is returned, |no_javascript_access| will indicate whether
   // the window that is created should be scriptable/in the same process.
   // This is called on the IO thread.
   virtual bool CanCreateWindow(const GURL& opener_url,
                                const GURL& opener_top_level_frame_url,
                                const GURL& source_origin,
                                WindowContainerType container_type,
                                const GURL& target_url,
@@ skipping 158 matching lines @@
 // camera. Note that this does not query the user. |type| must be
 // MEDIA_DEVICE_AUDIO_CAPTURE or MEDIA_DEVICE_VIDEO_CAPTURE.
 virtual bool CheckMediaAccessPermission(BrowserContext* browser_context,
                                         const GURL& security_origin,
                                         MediaStreamType type);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_CONTENT_BROWSER_CLIENT_H_