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 124 matching lines @@
 // A preference specifying if the user dragged the app on the NTP.
 const char kPrefUserDraggedApp[] = "user_dragged_app_ntp";
 
 // Preferences that hold which permissions the user has granted the extension.
 // We explicitly keep track of these so that extensions can contain unknown
 // permissions, for backwards compatibility reasons, and we can still prompt
 // 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";
+const char kPrefPersistedPermissions[] = "persisted_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";
 
 // The preference names for the old granted permissions scheme.
 const char kPrefOldGrantedFullAccess[] = "granted_permissions.full";
 const char kPrefOldGrantedHosts[] = "granted_permissions.host";
@@ skipping 971 matching lines @@
   return ReadPrefAsPermissionSet(extension_id, kPrefActivePermissions);
 }
 
 void ExtensionPrefs::SetActivePermissions(
     const std::string& extension_id,
     const PermissionSet* permissions) {
   SetExtensionPrefPermissionSet(
       extension_id, kPrefActivePermissions, permissions);
 }
 
+PermissionSet* ExtensionPrefs::GetPersistedPermissions(
+    const std::string& extension_id) {
+  CHECK(Extension::IdIsValid(extension_id));
+  return ReadPrefAsPermissionSet(extension_id, kPrefPersistedPermissions);
+}
+
+void ExtensionPrefs::AddPersistedPermission(const std::string& extension_id,
+                                            const PermissionSet* permissions) {
+  scoped_refptr<PermissionSet> old_permissions(
+      GetPersistedPermissions(extension_id));
+  SetExtensionPrefPermissionSet(
+      extension_id,
+      kPrefPersistedPermissions,
+      PermissionSet::CreateUnion(old_permissions.get(), permissions));
+}
+
+void ExtensionPrefs::ClearPersistedPermissions(
+    const std::string& extension_id) {
+  SetExtensionPrefPermissionSet(
+      extension_id, kPrefPersistedPermissions, new PermissionSet());
+}
+
 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 1061 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