Adds a field trial to control Web API kill switches.

chrome/browser/permissions/permission_context_base.h

 // 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.
 
 #ifndef CHROME_BROWSER_PERMISSIONS_PERMISSION_CONTEXT_BASE_H_
 #define CHROME_BROWSER_PERMISSIONS_PERMISSION_CONTEXT_BASE_H_
 
 #include "base/callback.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/memory/ref_counted.h"
@@ skipping 38 matching lines @@
 // It is mandatory to override IsRestrictedToSecureOrigin.
 // See midi_permission_context.h/cc or push_permission_context.cc/h for some
 // examples.
 
 class PermissionContextBase : public KeyedService {
  public:
   PermissionContextBase(Profile* profile,
                         const ContentSettingsType permission_type);
   ~PermissionContextBase() override;
 
+  // A field trial used to enable the global permissions kill switch.
+  static const char kPermissionsKillSwitchFieldStudy[];

[Bernhard Bauer, 2015/10/21 10:29:03]

Explain that this is public for testing?

[mlamouri (slow - plz ping), 2015/10/21 11:26:06]

Maybe this could move to permission_util?

[kcarattini, 2015/10/26 00:30:59]

Added comment about testing. See my comment about moving to permission util
below.

+
+  // The field trial param to enable the global permissions kill switch.
+  static const char kPermissionsKillSwitchBlockedValue[];
+
   // The renderer is requesting permission to push messages.
   // When the answer to a permission request has been determined, |callback|
   // should be called with the result.
   virtual void RequestPermission(content::WebContents* web_contents,
                                  const PermissionRequestID& id,
                                  const GURL& requesting_frame,
                                  bool user_gesture,
                                  const BrowserPermissionCallback& callback);
 
   // Returns whether the permission has been granted, denied...
   virtual ContentSetting GetPermissionStatus(
       const GURL& requesting_origin,
       const GURL& embedding_origin) const;
 
   // Resets the permission to its default value.
   virtual void ResetPermission(const GURL& requesting_origin,
                                const GURL& embedding_origin);
 
   // Withdraw an existing permission request, no op if the permission request
   // was already cancelled by some other means.
   virtual void CancelPermissionRequest(content::WebContents* web_contents,
                                        const PermissionRequestID& id);
 
+  // Whether the kill switch has been enabled for this permission.
+  // public for permissions that do not use RequestPermission, like
+  // camera and microphone, and for testing.

[Bernhard Bauer, 2015/10/21 10:29:03]

It's a bit weird to put this into PermissionContextBase for permissions that
don't actually use it. Would it make more sense to put it into a class used by
either? Also, on which instance of PermissionContextBase would camera and
microphone call this method anyway?

[mlamouri (slow - plz ping), 2015/10/21 11:26:06]

I wouldn't mind having this moved to permission_util. It would only require to
take a ContentSettingsType.

[kcarattini, 2015/10/21 11:42:47]

Camera and Mic do use PermissionContextBase, they just don't use the
RequestPermission method at the moment. Right now they have a separate
implementation but there is every intention of refactoring it to use more of
PermissionContextBase like the other permissions. In the meantime, there is 
MediaStreamDevicePermissionContext used by MediaPermission that this method
could be called on.

[kcarattini, 2015/10/26 00:30:59]

I can see the reasoning for putting this in PermissionUtil. If we end up wanting
the kill switch for permissions that don't use PermissionContext then it makes
more sense to put it there. However, the discussions about the future of
permissions code are still ongoing and it's unclear to me how it will all turn
out. Since at the moment, the only permissions using the kill switch are in fact
PermissionContext permissions, it makes sense to me to keep it in the
PermissionContextBase class. If we do decide to expand the idea of permission
beyond PermissionContext then there will definitely be some code restructuring
going on and I can move it out then. How does that sound? 

+  bool IsPermissionKillSwitchOn() const;
+
  protected:
   // Decide whether the permission should be granted.
   // Calls PermissionDecided if permission can be decided non-interactively,
   // or NotifyPermissionSet if permission decided by presenting an infobar.
   virtual void DecidePermission(content::WebContents* web_contents,
                                 const PermissionRequestID& id,
                                 const GURL& requesting_origin,
                                 const GURL& embedding_origin,
                                 bool user_gesture,
                                 const BrowserPermissionCallback& callback);
@@ skipping 44 matching lines @@
   scoped_ptr<PermissionQueueController> permission_queue_controller_;
   base::ScopedPtrHashMap<std::string, scoped_ptr<PermissionBubbleRequest>>
       pending_bubbles_;
 
   // Must be the last member, to ensure that it will be
   // destroyed first, which will invalidate weak pointers
   base::WeakPtrFactory<PermissionContextBase> weak_factory_;
 };
 
 #endif  // CHROME_BROWSER_PERMISSIONS_PERMISSION_CONTEXT_BASE_H_