Add an experimental permissions API for extensions.

chrome/browser/extensions/extension_prefs.cc

Index: chrome/browser/extensions/extension_prefs.cc
diff --git a/chrome/browser/extensions/extension_prefs.cc b/chrome/browser/extensions/extension_prefs.cc
index 2cb6efe1af2e0b1105d29c838fd87cb2ac2d0037..bedacfb679f14f599949582bae230f8ec161dc5d 100644
--- a/chrome/browser/extensions/extension_prefs.cc
+++ b/chrome/browser/extensions/extension_prefs.cc
@@ -113,6 +113,11 @@ const char kPrefOldGrantedFullAccess[] = "granted_permissions.full";
 const char kPrefOldGrantedHosts[] = "granted_permissions.host";
 const char kPrefOldGrantedAPIs[] = "granted_permissions.api";
 
+const char kPrefActiveAPIs[] = "active_permissions.api";
+const char kPrefActiveExplicitHosts[] = "active_permissions.explicit_host";
+const char kPrefActiveScriptableHosts[] =
+    "active_permissions.scriptable_host";
+
 // A preference that indicates when an extension was installed.
 const char kPrefInstallTime[] = "install_time";
 
@@ -741,6 +746,74 @@ void ExtensionPrefs::AddGrantedPermissions(
   }
 }
 
+ExtensionPermissionSet* ExtensionPrefs::GetActivePermissions(

[Mihai Parparita -not on Chrome, 2011/07/20 22:03:43]

This seems pretty similar to the granted permission get/set methods. Might be
worth it to have some shared utility functions for converting to/from Value.

[jstritar, 2011/07/22 19:21:55]

I factored these out into {Set,Read}ExtensionPrefPermissionSet. Once the
permissions API supports origins, we can probably share the Unpack/Pack methods
between here and the extension_permissions_api.cc.

+    const std::string& extension_id) {
+  CHECK(Extension::IdIsValid(extension_id));
+
+  const DictionaryValue* ext = GetExtensionPref(extension_id);
+  if (!ext)
+    return NULL;
+
+  // Retrieve the API permissions.
+  ExtensionAPIPermissionSet apis;
+  const ListValue* api_values = NULL;
+  if (ReadExtensionPrefList(extension_id, kPrefActiveAPIs, &api_values)) {
+    ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+    for (size_t i = 0; i < api_values->GetSize(); ++i) {
+      std::string permission_name;
+      if (api_values->GetString(i, &permission_name)) {
+        ExtensionAPIPermission *permission = info->GetByName(permission_name);
+        if (permission)
+          apis.insert(permission->id());
+      }
+    }
+  }
+
+  // Retrieve the explicit host permissions.
+  URLPatternSet explicit_hosts;
+  ReadExtensionPrefURLPatternSet(
+      extension_id, kPrefActiveExplicitHosts,
+      &explicit_hosts, Extension::kValidHostPermissionSchemes);
+
+  // Retrieve the scriptable host permissions.
+  URLPatternSet scriptable_hosts;
+  ReadExtensionPrefURLPatternSet(
+      extension_id, kPrefActiveScriptableHosts,
+      &scriptable_hosts, UserScript::kValidUserScriptSchemes);
+
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+
+void ExtensionPrefs::SetActivePermissions(
+    const std::string& extension_id,
+    const ExtensionPermissionSet* permissions) {
+  // Set the API permissions.
+  ListValue* api_values = new ListValue();
+  ExtensionAPIPermissionSet apis = permissions->apis();
+  ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
+  for (ExtensionAPIPermissionSet::const_iterator i = apis.begin();
+       i != apis.end(); ++i) {
+    ExtensionAPIPermission* perm = info->GetByID(*i);
+    if (perm)
+      api_values->Append(Value::CreateStringValue(perm->name()));
+  }
+  UpdateExtensionPref(extension_id, kPrefActiveAPIs, api_values);
+
+  // Set the explicit host permissions.
+  if (!permissions->explicit_hosts().is_empty()) {
+    SetExtensionPrefURLPatternSet(extension_id,
+                                  kPrefActiveExplicitHosts,
+                                  permissions->explicit_hosts());
+  }
+
+  // Set the scriptable host permissions.
+  if (!permissions->scriptable_hosts().is_empty()) {
+    SetExtensionPrefURLPatternSet(extension_id,
+                                  kPrefActiveScriptableHosts,
+                                  permissions->scriptable_hosts());
+  }
+}
+
 bool ExtensionPrefs::IsIncognitoEnabled(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefIncognitoEnabled);
 }