Add an experimental permissions API for extensions.

chrome/common/extensions/extension_permission_set.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/common/extensions/extension_permission_set.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/memory/singleton.h"
@@ skipping 229 matching lines @@
   RegisterHostedAppPermission(
       ExtensionAPIPermission::kGeolocation, "geolocation",
       IDS_EXTENSION_PROMPT_WARNING_GEOLOCATION,
       ExtensionPermissionMessage::kGeolocation);
   RegisterHostedAppPermission(
       ExtensionAPIPermission::kNotification, "notifications", 0,
       ExtensionPermissionMessage::kNone);
   RegisterHostedAppPermission(
       ExtensionAPIPermission::kUnlimitedStorage, "unlimitedStorage", 0,
       ExtensionPermissionMessage::kNone);
+  RegisterHostedAppPermission(
+      ExtensionAPIPermission::kPermissions, "permissions", 0,
+      ExtensionPermissionMessage::kNone);
 
   // Hosted app and private permissions.
   RegisterPermission(
       ExtensionAPIPermission::kChromeAuthPrivate, "chromeAuthPrivate", 0,
       ExtensionPermissionMessage::kNone,
       true, true, false, false);
   RegisterPermission(
       ExtensionAPIPermission::kWebstorePrivate, "webstorePrivate", 0,
       ExtensionPermissionMessage::kNone,
       true, true, false, false);
@@ skipping 166 matching lines @@
   : apis_(apis),
     scriptable_hosts_(scriptable_hosts) {
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitEffectiveHosts();
 }
 
 ExtensionPermissionSet::~ExtensionPermissionSet() {
 }
 
 // static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateDifference(
+    const ExtensionPermissionSet* set1,
+    const ExtensionPermissionSet* set2) {
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
+  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
+
+  ExtensionAPIPermissionSet apis;
+  std::set_difference(set1_safe->apis().begin(), set1_safe->apis().end(),
+                      set2_safe->apis().begin(), set2_safe->apis().end(),
+                      std::insert_iterator<ExtensionAPIPermissionSet>(
+                          apis, apis.begin()));
+
+  URLPatternSet explicit_hosts;
+  URLPatternSet::CreateDifference(set1_safe->explicit_hosts(),
+                                  set2_safe->explicit_hosts(),
+                                  &explicit_hosts);
+
+  URLPatternSet scriptable_hosts;
+  URLPatternSet::CreateDifference(set1_safe->scriptable_hosts(),
+                                  set2_safe->scriptable_hosts(),
+                                  &scriptable_hosts);
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+
+// static
+ExtensionPermissionSet* ExtensionPermissionSet::CreateIntersection(
+    const ExtensionPermissionSet* set1,
+    const ExtensionPermissionSet* set2) {
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
+  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
+
+  ExtensionAPIPermissionSet apis;
+  std::set_intersection(set1_safe->apis().begin(), set1_safe->apis().end(),
+                        set2_safe->apis().begin(), set2_safe->apis().end(),
+                        std::insert_iterator<ExtensionAPIPermissionSet>(
+                            apis, apis.begin()));
+  URLPatternSet explicit_hosts;
+  URLPatternSet::CreateIntersection(set1_safe->explicit_hosts(),
+                                    set2_safe->explicit_hosts(),
+                                    &explicit_hosts);
+
+  URLPatternSet scriptable_hosts;
+  URLPatternSet::CreateIntersection(set1_safe->scriptable_hosts(),
+                                    set2_safe->scriptable_hosts(),
+                                    &scriptable_hosts);
+  return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
+}
+// static
 ExtensionPermissionSet* ExtensionPermissionSet::CreateUnion(
     const ExtensionPermissionSet* set1,
     const ExtensionPermissionSet* set2) {
-  ExtensionPermissionSet empty;
-  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? &empty : set1;
-  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? &empty : set2;
+  scoped_refptr<ExtensionPermissionSet> empty = new ExtensionPermissionSet();
+  const ExtensionPermissionSet* set1_safe = (set1 == NULL) ? empty : set1;
+  const ExtensionPermissionSet* set2_safe = (set2 == NULL) ? empty : set2;
 
   ExtensionAPIPermissionSet apis;
   std::set_union(set1_safe->apis().begin(), set1_safe->apis().end(),
                  set2_safe->apis().begin(), set2_safe->apis().end(),
                  std::insert_iterator<ExtensionAPIPermissionSet>(
                      apis, apis.begin()));
 
   URLPatternSet explicit_hosts;
-  URLPatternSet scriptable_hosts;
   URLPatternSet::CreateUnion(set1_safe->explicit_hosts(),
                              set2_safe->explicit_hosts(),
                              &explicit_hosts);
+
+  URLPatternSet scriptable_hosts;
   URLPatternSet::CreateUnion(set1_safe->scriptable_hosts(),
                              set2_safe->scriptable_hosts(),
                              &scriptable_hosts);
 
   return new ExtensionPermissionSet(apis, explicit_hosts, scriptable_hosts);
 }
 
+bool ExtensionPermissionSet::operator==(
+    const ExtensionPermissionSet& rhs) const {
+  return apis_ == rhs.apis_ &&
+      scriptable_hosts_ == rhs.scriptable_hosts_ &&
+      explicit_hosts_ == rhs.explicit_hosts_;
+}
+
+bool ExtensionPermissionSet::Contains(const ExtensionPermissionSet& set) const {
+  // Every set includes the empty set.
+  if (set.IsEmpty())
+    return true;
+
+  if (!std::includes(apis_.begin(), apis_.end(),
+                     set.apis().begin(), set.apis().end()))
+    return false;
+
+  if (!explicit_hosts().Contains(set.explicit_hosts()))
+    return false;
+
+  if (!scriptable_hosts().Contains(set.scriptable_hosts()))
+    return false;
+
+  return true;
+}
+
 std::set<std::string> ExtensionPermissionSet::GetAPIsAsStrings() const {
   ExtensionPermissionsInfo* info = ExtensionPermissionsInfo::GetInstance();
   std::set<std::string> apis_str;
   for (ExtensionAPIPermissionSet::const_iterator i = apis_.begin();
        i != apis_.end(); ++i) {
     ExtensionAPIPermission* permission = info->GetByID(*i);
     if (permission)
       apis_str.insert(permission->name());
   }
   return apis_str;
@@ skipping 311 matching lines @@
   std::set<std::string> new_hosts_set = GetDistinctHosts(new_list, false);
   std::set<std::string> old_hosts_set = GetDistinctHosts(old_list, false);
   std::set<std::string> new_hosts_only;
 
   std::set_difference(new_hosts_set.begin(), new_hosts_set.end(),
                       old_hosts_set.begin(), old_hosts_set.end(),
                       std::inserter(new_hosts_only, new_hosts_only.begin()));
 
   return !new_hosts_only.empty();
 }