Support "always allow" for runtime script execution

extensions/browser/extension_prefs.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 EXTENSIONS_BROWSER_EXTENSION_PREFS_H_
 #define EXTENSIONS_BROWSER_EXTENSION_PREFS_H_
 
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 382 matching lines @@
 
   // Gets the active permission set for the specified extension. This may
   // differ from the permissions in the manifest due to the optional
   // permissions API. This passes ownership of the set to the caller.
   PermissionSet* GetActivePermissions(const std::string& extension_id);
 
   // Sets the active |permissions| for the extension with |extension_id|.
   void SetActivePermissions(const std::string& extension_id,
                             const PermissionSet* permissions);
 
+  // Returns the persisted permission set for the extension with
+  // |extension_id|, and NULL if no preferences were found.  This passes
+  // ownership of the returned set to the caller.
+  PermissionSet* GetPersistedPermissions(const std::string& extension_id);

[not at google - send to devlin, 2014/08/01 18:15:12]

I'm not sure whether this needs to be a whole separate thing. Can you use
|AddGrantedPermissions| instead? that's what the optional permissions stuff uses
and it seems sufficiently generic.

i also don't see Add or Clear ever called.

[gpdavis, 2014/08/01 20:06:06]

But permissions from the manifest are added directly to granted_permissions. 
How are we to discriminate between permissions that have been allowed to persist
by the user, and permissions that were pulled directly from the manifest?  (If
this is confusing, I can try and clarify).

Clear and Add are called here:

https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ext...

I called both for testing purposes, since there's currently no way to clear them
other than to reinstall the extension entirely.

[not at google - send to devlin, 2014/08/04 23:53:13]

Ah - so there is a concept of "active permissions". this is currently the
"required permissions" (pulled directly from the manifest) + "optional
permissions" *that have been granted*. I'm imagining this "always allow"
functionality to be basically adding to the active permissions, except from a
3rd source - withheld permissions.

+
+  // Adds |permissions| to |extension|'s persisted permissions for script
+  // injection requests.
+  void AddPersistedPermission(const std::string& extension_id,
+                              const PermissionSet* permissions);
+
+  // Clears |extension|'s persisted permissions for script injection requests.
+  void ClearPersistedPermissions(const std::string& extension_id);
+
   // Records whether or not this extension is currently running.
   void SetExtensionRunning(const std::string& extension_id, bool is_running);
 
   // Returns whether or not this extension is marked as running. This is used to
   // restart apps across browser restarts.
   bool IsExtensionRunning(const std::string& extension_id);
 
   // Set/Get whether or not the app is active. Used to force a launch of apps
   // that don't handle onRestarted() on a restart. We can only safely do that if
   // the app was active when it was last running.
@@ skipping 304 matching lines @@
   bool extensions_disabled_;
 
   ObserverList<ExtensionPrefsObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrefs);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_PREFS_H_