Support "always allow" for runtime script execution

extensions/browser/extension_prefs.cc

 // 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.
 
 #include "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 130 matching lines @@
 // the user to accept them once recognized. We store the active permission
 // permissions because they may differ from those defined in the manifest.
 const char kPrefActivePermissions[] = "active_permissions";
 const char kPrefGrantedPermissions[] = "granted_permissions";
 
 // The preference names for PermissionSet values.
 const char kPrefAPIs[] = "api";
 const char kPrefManifestPermissions[] = "manifest_permissions";
 const char kPrefExplicitHosts[] = "explicit_host";
 const char kPrefScriptableHosts[] = "scriptable_host";
+const char kPrefPersistedPermissions[] = "persisted_permissions";
 
 // The preference names for the old granted permissions scheme.
 const char kPrefOldGrantedFullAccess[] = "granted_permissions.full";
 const char kPrefOldGrantedHosts[] = "granted_permissions.host";
 const char kPrefOldGrantedAPIs[] = "granted_permissions.api";
 
 // A preference that indicates when an extension was installed.
 const char kPrefInstallTime[] = "install_time";
 
 // A preference which saves the creation flags for extensions.
@@ skipping 962 matching lines @@
   return ReadPrefAsPermissionSet(extension_id, kPrefActivePermissions);
 }
 
 void ExtensionPrefs::SetActivePermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
 
+bool ExtensionPrefs::GetPersistedPermissions(
+    const std::string& extension_id,
+    URLPatternSet* persisted_permissions) {
+  CHECK(Extension::IdIsValid(extension_id));
+  return ReadPrefAsURLPatternSet(extension_id,
+                                 kPrefPersistedPermissions,
+                                 persisted_permissions,
+                                 UserScript::ValidUserScriptSchemes());
+}
+
+void ExtensionPrefs::AddPersistedPermission(const Extension* extension,
+                                            const URLPattern* pattern) {
+  DictionaryPrefUpdate update(prefs_, "extensions.settings");
+  base::DictionaryValue* dict = update.Get();
+  base::DictionaryValue* prefer = NULL;
+  dict->GetDictionary(extension->id(), &prefer);
+
+  base::ListValue* pattern_list = NULL;
+
+  if (!prefer->GetList(kPrefPersistedPermissions, &pattern_list)) {
+    prefer->Set(kPrefPersistedPermissions, new base::ListValue());
+    prefer->GetList(kPrefPersistedPermissions, &pattern_list);
+  }

[gpdavis, 2014/07/15 21:56:38]

If persisted permissions do not exist, we initialize the key to a new ListValue
to hold them.  Then we append the pattern string to this list.

I wasn't sure if it would be better practice to pass a URLPattern into this
method, or a URL, or even the pattern string itself.  What do you think?

[Devlin, 2014/07/15 22:11:01]

Probably an URLPattern.  Url is too specific; Prefs shouldn't have to know how
to parse it.

+
+  pattern_list->Append(new base::StringValue(pattern->GetAsString()));
+}
+
+void ExtensionPrefs::ClearPersistedPermissions(const Extension* extension) {

[gpdavis, 2014/07/15 21:56:38]

This method will allow us to place a "Clear persisted permissions" button in the
extension settings list in order to remove any persisted permissions.

+  DictionaryPrefUpdate update(prefs_, "extensions.settings");
+  base::DictionaryValue* dict = update.Get();
+  base::DictionaryValue* prefer = NULL;
+  dict->GetDictionary(extension->id(), &prefer);
+
+  prefer->Set(kPrefPersistedPermissions, new base::ListValue());
+}
+
 void ExtensionPrefs::SetExtensionRunning(const std::string& extension_id,
     bool is_running) {
   base::Value* value = new base::FundamentalValue(is_running);
   UpdateExtensionPref(extension_id, kPrefRunning, value);
 }
 
 bool ExtensionPrefs::IsExtensionRunning(const std::string& extension_id) {
   const base::DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return false;
@@ skipping 1042 matching lines @@
   extension_pref_value_map_->RegisterExtension(
       extension_id, install_time, is_enabled, is_incognito_enabled);
 
   FOR_EACH_OBSERVER(
       ExtensionPrefsObserver,
       observer_list_,
       OnExtensionRegistered(extension_id, install_time, is_enabled));
 }
 
 }  // namespace extensions