Enable permission warnings from ManifestHandlers.

extensions/common/permissions/permission_set.cc

 // Copyright 2013 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/common/permissions/permission_set.h"
 
 #include <algorithm>
 #include <iterator>
 #include <string>
 
@@ skipping 20 matching lines @@
 namespace extensions {
 
 //
 // PermissionSet
 //
 
 PermissionSet::PermissionSet() {}
 
 PermissionSet::PermissionSet(
     const APIPermissionSet& apis,
+    const ManifestPermissionSet& manifest_permissions,
     const URLPatternSet& explicit_hosts,
     const URLPatternSet& scriptable_hosts)
     : apis_(apis),
+      manifest_permissions_(manifest_permissions),
       scriptable_hosts_(scriptable_hosts) {
   AddPatternsAndRemovePaths(explicit_hosts, &explicit_hosts_);
   InitImplicitPermissions();
   InitEffectiveHosts();
 }
 
 // static
 PermissionSet* PermissionSet::CreateDifference(
     const PermissionSet* set1,
     const PermissionSet* set2) {
   scoped_refptr<PermissionSet> empty = new PermissionSet();
   const PermissionSet* set1_safe = (set1 == NULL) ? empty.get() : set1;
   const PermissionSet* set2_safe = (set2 == NULL) ? empty.get() : set2;
 
   APIPermissionSet apis;
   APIPermissionSet::Difference(set1_safe->apis(), set2_safe->apis(), &apis);
 
+  ManifestPermissionSet manifest_permissions;
+  ManifestPermissionSet::Difference(set1_safe->manifest_permissions(),
+                                    set2_safe->manifest_permissions(),
+                                    &manifest_permissions);
+
   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 PermissionSet(apis, explicit_hosts, scriptable_hosts);
+  return new PermissionSet(apis, manifest_permissions,
+                           explicit_hosts, scriptable_hosts);
 }
 
 // static
 PermissionSet* PermissionSet::CreateIntersection(
     const PermissionSet* set1,
     const PermissionSet* set2) {
   scoped_refptr<PermissionSet> empty = new PermissionSet();
   const PermissionSet* set1_safe = (set1 == NULL) ? empty.get() : set1;
   const PermissionSet* set2_safe = (set2 == NULL) ? empty.get() : set2;
 
   APIPermissionSet apis;
   APIPermissionSet::Intersection(set1_safe->apis(), set2_safe->apis(), &apis);
 
+  ManifestPermissionSet manifest_permissions;
+  ManifestPermissionSet::Intersection(set1_safe->manifest_permissions(),
+                                      set2_safe->manifest_permissions(),
+                                      &manifest_permissions);
+
   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 PermissionSet(apis, explicit_hosts, scriptable_hosts);
+  return new PermissionSet(apis, manifest_permissions,
+                           explicit_hosts, scriptable_hosts);
 }
 
 // static
 PermissionSet* PermissionSet::CreateUnion(
     const PermissionSet* set1,
     const PermissionSet* set2) {
   scoped_refptr<PermissionSet> empty = new PermissionSet();
   const PermissionSet* set1_safe = (set1 == NULL) ? empty.get() : set1;
   const PermissionSet* set2_safe = (set2 == NULL) ? empty.get() : set2;
 
   APIPermissionSet apis;
   APIPermissionSet::Union(set1_safe->apis(), set2_safe->apis(), &apis);
 
+  ManifestPermissionSet manifest_permissions;
+  ManifestPermissionSet::Union(set1_safe->manifest_permissions(),
+                               set2_safe->manifest_permissions(),
+                               &manifest_permissions);
+
   URLPatternSet explicit_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 PermissionSet(apis, explicit_hosts, scriptable_hosts);
+  return new PermissionSet(apis, manifest_permissions,
+                           explicit_hosts, scriptable_hosts);
 }
 
 bool PermissionSet::operator==(
     const PermissionSet& rhs) const {
   return apis_ == rhs.apis_ &&
+      manifest_permissions_ == rhs.manifest_permissions_ &&
       scriptable_hosts_ == rhs.scriptable_hosts_ &&
       explicit_hosts_ == rhs.explicit_hosts_;
 }
 
 bool PermissionSet::Contains(const PermissionSet& set) const {
   return apis_.Contains(set.apis()) &&
+         manifest_permissions_.Contains(set.manifest_permissions()) &&
          explicit_hosts().Contains(set.explicit_hosts()) &&
          scriptable_hosts().Contains(set.scriptable_hosts());
 }
 
 std::set<std::string> PermissionSet::GetAPIsAsStrings() const {
   std::set<std::string> apis_str;
   for (APIPermissionSet::const_iterator i = apis_.begin();
        i != apis_.end(); ++i) {
     apis_str.insert(i->name());
   }
   return apis_str;
 }
 
 bool PermissionSet::IsEmpty() const {
   // Not default if any host permissions are present.
   if (!(explicit_hosts().is_empty() && scriptable_hosts().is_empty()))
     return false;
 
   // Or if it has no api permissions.
-  return apis().empty();
+  return apis().empty() && manifest_permissions().empty();
 }
 
 bool PermissionSet::HasAPIPermission(
     APIPermission::ID id) const {
   return apis().find(id) != apis().end();
 }
 
 bool PermissionSet::HasAPIPermission(const std::string& permission_name) const {
   const APIPermissionInfo* permission =
       PermissionsInfo::GetInstance()->GetByName(permission_name);
@@ skipping 81 matching lines @@
 }
 
 void PermissionSet::InitEffectiveHosts() {
   effective_hosts_.ClearPatterns();
 
   URLPatternSet::CreateUnion(
       explicit_hosts(), scriptable_hosts(), &effective_hosts_);
 }
 
 }  // namespace extensions