Start refractoring extension permissions into ExtensionPermissionSet.

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 c992e5d1ee6bf8878c261dc6f885a178abbd5f33..442f1015827c41ff0eb509477cb53a7160fa1e74 100644
--- a/chrome/browser/extensions/extension_prefs.cc
+++ b/chrome/browser/extensions/extension_prefs.cc
@@ -457,18 +457,10 @@ bool ExtensionPrefs::ReadExtensionPrefStringSet(
   return true;
 }
 
-void ExtensionPrefs::AddToExtensionPrefStringSet(
+void ExtensionPrefs::SetExtensionPrefStringSet(
     const std::string& extension_id,
     const std::string& pref_key,
-    const std::set<std::string>& added_value) {
-  std::set<std::string> old_value;
-  std::set<std::string> new_value;
-  ReadExtensionPrefStringSet(extension_id, pref_key, &old_value);
-
-  std::set_union(old_value.begin(), old_value.end(),
-                 added_value.begin(), added_value.end(),
-                 std::inserter(new_value, new_value.begin()));
-
+    const std::set<std::string>& new_value) {
   ListValue* value = new ListValue();
   for (std::set<std::string>::const_iterator iter = new_value.begin();
        iter != new_value.end(); ++iter)
@@ -670,30 +662,38 @@ void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                       Value::CreateBooleanValue(active));
 }
 
-bool ExtensionPrefs::GetGrantedPermissions(
-    const std::string& extension_id,
-    bool* full_access,
-    std::set<std::string>* api_permissions,
-    URLPatternSet* host_extent) {
+ExtensionPermissionSet* ExtensionPrefs::GetGrantedPermissions(
+    const std::string& extension_id, bool* initialized) {
   CHECK(Extension::IdIsValid(extension_id));
 
+  bool full_access;
   const DictionaryValue* ext = GetExtensionPref(extension_id);
-  if (!ext || !ext->GetBoolean(kPrefGrantedPermissionsAll, full_access))
-    return false;
+  if (!ext || !ext->GetBoolean(kPrefGrantedPermissionsAll, &full_access)) {
+    if (initialized != NULL)
+      *initialized = false;
+    return new ExtensionPermissionSet();
+  }
+
+  if (initialized != NULL)
+    *initialized = true;
 
+  std::set<std::string> api_permissions_str;
   ReadExtensionPrefStringSet(
-      extension_id, kPrefGrantedPermissionsAPI, api_permissions);
+      extension_id, kPrefGrantedPermissionsAPI, &api_permissions_str);
+  std::set<ExtensionAPIPermission> api_permissions =
+      ExtensionAPIPermission::GetAllByName(api_permissions_str);
 
-  std::set<std::string> host_permissions;
+  std::set<std::string> host_permissions_str;
+  URLPatternSet host_extent;
   ReadExtensionPrefStringSet(
-      extension_id, kPrefGrantedPermissionsHost, &host_permissions);
+      extension_id, kPrefGrantedPermissionsHost, &host_permissions_str);
   bool allow_file_access = AllowFileAccess(extension_id);
 
   // The granted host permissions contain hosts from the manifest's
   // "permissions" array and from the content script "matches" arrays,
   // so the URLPattern needs to accept valid schemes from both types.
-  for (std::set<std::string>::iterator i = host_permissions.begin();
-       i != host_permissions.end(); ++i) {
+  for (std::set<std::string>::iterator i = host_permissions_str.begin();
+       i != host_permissions_str.end(); ++i) {
     URLPattern pattern(
         Extension::kValidHostPermissionSchemes |
         UserScript::kValidUserScriptSchemes);
@@ -708,34 +708,40 @@ bool ExtensionPrefs::GetGrantedPermissions(
         pattern.set_valid_schemes(
             pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
       }
-      host_extent->AddPattern(pattern);
+      host_extent.AddPattern(pattern);
     }
   }
 
-  return true;
+  return new ExtensionPermissionSet(full_access, api_permissions, host_extent);
 }
 
 void ExtensionPrefs::AddGrantedPermissions(
     const std::string& extension_id,
-    const bool full_access,
-    const std::set<std::string>& api_permissions,
-    const URLPatternSet& host_extent) {
+    const ExtensionPermissionSet& permissions) {
   CHECK(Extension::IdIsValid(extension_id));
 
-  UpdateExtensionPref(extension_id, kPrefGrantedPermissionsAll,
-                      Value::CreateBooleanValue(full_access));
+  scoped_ptr<ExtensionPermissionSet> granted_permissions(
+      GetGrantedPermissions(extension_id, NULL));
 
-  if (!api_permissions.empty()) {
-    AddToExtensionPrefStringSet(
-        extension_id, kPrefGrantedPermissionsAPI, api_permissions);
-  }
+  // The granted permissions are now the union of the already granted
+  // permissions and the newly granted permissions.
+  scoped_ptr<ExtensionPermissionSet> new_perms(
+      ExtensionPermissionSet::CreateUnion(permissions, *granted_permissions));
 
-  if (!host_extent.is_empty()) {
-    std::set<std::string> host_permissions;
-    ExtentToStringSet(host_extent, &host_permissions);
-
-    AddToExtensionPrefStringSet(
-        extension_id, kPrefGrantedPermissionsHost, host_permissions);
+  // Set the full access (native code) bit.
+  UpdateExtensionPref(extension_id, kPrefGrantedPermissionsAll,
+                      Value::CreateBooleanValue(new_perms->native_code()));
+
+  // Set the api permissions.
+  if (!new_perms->apis().empty())
+    SetExtensionPrefStringSet(extension_id, kPrefGrantedPermissionsAPI,
+                              new_perms->GetAPIsAsStrings());
+
+  // Set the host permissions.
+  if (!new_perms->effective_hosts().is_empty()) {
+    std::set<std::string> hosts;
+    ExtentToStringSet(new_perms->effective_hosts(), &hosts);
+    SetExtensionPrefStringSet(extension_id, kPrefGrantedPermissionsHost, hosts);
   }
 }