Add an experimental permissions API for extensions.

chrome/browser/extensions/extension_prefs.cc

 // Copyright (c) 2011 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 "chrome/browser/extensions/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_pref_store.h"
@@ skipping 95 matching lines @@
 const char kPrefGrantedAPIs[] = "granted_permissions.api";
 const char kPrefGrantedExplicitHosts[] = "granted_permissions.explicit_host";
 const char kPrefGrantedScriptableHosts[] =
     "granted_permissions.scriptable_host";
 
 // 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";
 
+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";
 
 // A preference that indicates whether the extension was installed from the
 // Chrome Web Store.
 const char kPrefFromWebStore[] = "from_webstore";
 
 // A preference that contains any extension-controlled preferences.
 const char kPrefPreferences[] = "preferences";
 
@@ skipping 608 matching lines @@
   }
 
   // Set the scriptable host permissions.
   if (!new_perms->scriptable_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   kPrefGrantedScriptableHosts,
                                   new_perms->scriptable_hosts());
   }
 }
 
+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);
 }
 
 void ExtensionPrefs::SetIsIncognitoEnabled(const std::string& extension_id,
                                            bool enabled) {
   UpdateExtensionPref(extension_id, kPrefIncognitoEnabled,
                       Value::CreateBooleanValue(enabled));
 }
 
@@ skipping 856 matching lines @@
   prefs->RegisterListPref(prefs::kExtensionInstallAllowList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallDenyList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionInstallForceList,
                           PrefService::UNSYNCABLE_PREF);
   prefs->RegisterStringPref(kWebStoreLogin,
                             std::string() /* default_value */,
                             PrefService::UNSYNCABLE_PREF);
 }