Enable permission warnings from ManifestHandlers.

extensions/common/permissions/api_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/api_permission_set.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
@@ skipping 91 matching lines @@
         return false;
     }
   }
 
   return CreateAPIPermission(base_name, NULL, source,
                              api_permissions, error, NULL);
 }
 
 }  // namespace
 
+template <typename T>
+class SetOperations {
+ public:
+  typedef typename T::const_iterator const_iterator;
+
+  static T& Assign(T& lhs, const T& rhs) {
+    const_iterator it = rhs.begin();
+    const const_iterator end = rhs.end();
+    while (it != end) {
+      lhs.insert(it->Clone());
+      ++it;
+    }
+    return lhs;
+  }
+
+  static bool Equal(const T& lhs, const T& rhs) {
+    const_iterator it = lhs.begin();
+    const_iterator rhs_it = rhs.begin();
+    const_iterator it_end = lhs.end();
+    const_iterator rhs_it_end = rhs.end();
+
+    while (it != it_end && rhs_it != rhs_it_end) {
+      if (!it->Equal(*rhs_it))
+        return false;
+      ++it;
+      ++rhs_it;
+    }
+    return it == it_end && rhs_it == rhs_it_end;
+  }
+
+  static bool Contains(const T& lhs, const T& rhs) {
+    const_iterator it1 = lhs.begin();
+    const_iterator it2 = rhs.begin();
+    const_iterator end1 = lhs.end();
+    const_iterator end2 = rhs.end();
+
+    while (it1 != end1 && it2 != end2) {
+      if (it1->id() > it2->id()) {
+        return false;
+      } else if (it1->id() < it2->id()) {
+        ++it1;
+      } else {
+          if (!it1->Contains(*it2))
+            return false;
+        ++it1;
+        ++it2;
+      }
+    }
+
+    return it2 == end2;
+  }
+
+  template <typename U>
+  static void Difference(const T& set1, const T& set2, T* set3) {
+    CHECK(set3);
+    set3->clear();
+
+    const_iterator it1 = set1.begin();
+    const_iterator it2 = set2.begin();
+    const const_iterator end1 = set1.end();
+    const const_iterator end2 = set2.end();
+
+    while (it1 != end1 && it2 != end2) {
+      if (it1->id() < it2->id()) {
+        set3->insert(it1->Clone());
+        ++it1;
+      } else if (it1->id() > it2->id()) {
+        ++it2;
+      } else {
+        U* p = it1->Diff(*it2);
+        if (p)
+          set3->insert(p);
+        ++it1;
+        ++it2;
+      }
+    }
+
+    while (it1 != end1) {
+      set3->insert(it1->Clone());
+      ++it1;
+    }
+  }
+
+  template<typename U>
+  static void Intersection(const T& set1, const T& set2, T* set3) {
+    DCHECK(set3);
+    set3->clear();
+
+    const_iterator it1 = set1.begin();
+    const_iterator it2 = set2.begin();
+    const const_iterator end1 = set1.end();
+    const const_iterator end2 = set2.end();
+
+    while (it1 != end1 && it2 != end2) {
+      if (it1->id() < it2->id()) {
+        ++it1;
+      } else if (it1->id() > it2->id()) {
+        ++it2;
+      } else {
+        U* p = it1->Intersect(*it2);
+        if (p)
+          set3->insert(p);
+        ++it1;
+        ++it2;
+      }
+    }
+  }
+
+  template<typename U>
+  static void Union(const T& set1, const T& set2, T* set3) {
+    DCHECK(set3);
+    set3->clear();
+
+    const_iterator it1 = set1.begin();
+    const_iterator it2 = set2.begin();
+    const const_iterator end1 = set1.end();
+    const const_iterator end2 = set2.end();
+
+    while (true) {
+      if (it1 == end1) {
+        while (it2 != end2) {
+          set3->insert(it2->Clone());
+          ++it2;
+        }
+        break;
+      }
+      if (it2 == end2) {
+        while (it1 != end1) {
+          set3->insert(it1->Clone());
+          ++it1;
+        }
+        break;
+      }
+      if (it1->id() < it2->id()) {
+        set3->insert(it1->Clone());
+        ++it1;
+      } else if (it1->id() > it2->id()) {
+        set3->insert(it2->Clone());
+        ++it2;
+      } else {
+        set3->insert(it1->Union(*it2));
+        ++it1;
+        ++it2;
+      }
+    }
+  }
+};
+
+
 APIPermissionSet::APIPermissionSet() {
 }
 
 APIPermissionSet::APIPermissionSet(const APIPermissionSet& set) {
   this->operator=(set);
 }
 
 APIPermissionSet::~APIPermissionSet() {
 }
 
 APIPermissionSet::const_iterator::const_iterator(
     const APIPermissionMap::const_iterator& it)
   : it_(it) {
 }
 
 APIPermissionSet::const_iterator::const_iterator(
     const const_iterator& ids_it)
   : it_(ids_it.it_) {
 }
 
 APIPermissionSet& APIPermissionSet::operator=(const APIPermissionSet& rhs) {
-  const_iterator it = rhs.begin();
-  const const_iterator end = rhs.end();
-  while (it != end) {
-    insert(it->Clone());
-    ++it;
-  }
-  return *this;
+  return SetOperations<APIPermissionSet>::Assign(*this, rhs);
 }
 
 bool APIPermissionSet::operator==(const APIPermissionSet& rhs) const {
-  const_iterator it = begin();
-  const_iterator rhs_it = rhs.begin();
-  const_iterator it_end = end();
-  const_iterator rhs_it_end = rhs.end();
-
-  while (it != it_end && rhs_it != rhs_it_end) {
-    if (!it->Equal(*rhs_it))
-      return false;
-    ++it;
-    ++rhs_it;
-  }
-  return it == it_end && rhs_it == rhs_it_end;
+  return SetOperations<APIPermissionSet>::Equal(*this, rhs);
 }
 
 void APIPermissionSet::insert(APIPermission::ID id) {
   const APIPermissionInfo* permission_info =
       PermissionsInfo::GetInstance()->GetByID(id);
   insert(permission_info->CreateAPIPermission());
 }
 
 void APIPermissionSet::insert(APIPermission* permission) {
   map_[permission->id()].reset(permission);
 }
 
 bool APIPermissionSet::Contains(const APIPermissionSet& rhs) const {
-  APIPermissionSet::const_iterator it1 = begin();
-  APIPermissionSet::const_iterator it2 = rhs.begin();
-  APIPermissionSet::const_iterator end1 = end();
-  APIPermissionSet::const_iterator end2 = rhs.end();
-
-  while (it1 != end1 && it2 != end2) {
-    if (it1->id() > it2->id()) {
-      return false;
-    } else if (it1->id() < it2->id()) {
-      ++it1;
-    } else {
-        if (!it1->Contains(*it2))
-          return false;
-      ++it1;
-      ++it2;
-    }
-  }
-
-  return it2 == end2;
+  return SetOperations<APIPermissionSet>::Contains(*this, rhs);
 }
 
 void APIPermissionSet::Difference(
     const APIPermissionSet& set1,
     const APIPermissionSet& set2,
     APIPermissionSet* set3) {
-  CHECK(set3);
-  set3->clear();
-
-  APIPermissionSet::const_iterator it1 = set1.begin();
-  APIPermissionSet::const_iterator it2 = set2.begin();
-  const APIPermissionSet::const_iterator end1 = set1.end();
-  const APIPermissionSet::const_iterator end2 = set2.end();
-
-  while (it1 != end1 && it2 != end2) {
-    if (it1->id() < it2->id()) {
-      set3->insert(it1->Clone());
-      ++it1;
-    } else if (it1->id() > it2->id()) {
-      ++it2;
-    } else {
-      APIPermission* p = it1->Diff(*it2);
-      if (p)
-        set3->insert(p);
-      ++it1;
-      ++it2;
-    }
-  }
-
-  while (it1 != end1) {
-    set3->insert(it1->Clone());
-    ++it1;
-  }
+  SetOperations<APIPermissionSet>::Difference<APIPermission>(set1, set2, set3);
 }
 
 void APIPermissionSet::Intersection(
     const APIPermissionSet& set1,
     const APIPermissionSet& set2,
     APIPermissionSet* set3) {
-  DCHECK(set3);
-  set3->clear();
-
-  APIPermissionSet::const_iterator it1 = set1.begin();
-  APIPermissionSet::const_iterator it2 = set2.begin();
-  const APIPermissionSet::const_iterator end1 = set1.end();
-  const APIPermissionSet::const_iterator end2 = set2.end();
-
-  while (it1 != end1 && it2 != end2) {
-    if (it1->id() < it2->id()) {
-      ++it1;
-    } else if (it1->id() > it2->id()) {
-      ++it2;
-    } else {
-      APIPermission* p = it1->Intersect(*it2);
-      if (p)
-        set3->insert(p);
-      ++it1;
-      ++it2;
-    }
-  }
+  SetOperations<APIPermissionSet>::Intersection<APIPermission>(
+      set1, set2, set3);
 }
 
 void APIPermissionSet::Union(
     const APIPermissionSet& set1,
     const APIPermissionSet& set2,
     APIPermissionSet* set3) {
-  DCHECK(set3);
-  set3->clear();
-
-  APIPermissionSet::const_iterator it1 = set1.begin();
-  APIPermissionSet::const_iterator it2 = set2.begin();
-  const APIPermissionSet::const_iterator end1 = set1.end();
-  const APIPermissionSet::const_iterator end2 = set2.end();
-
-  while (true) {
-    if (it1 == end1) {
-      while (it2 != end2) {
-        set3->insert(it2->Clone());
-        ++it2;
-      }
-      break;
-    }
-    if (it2 == end2) {
-      while (it1 != end1) {
-        set3->insert(it1->Clone());
-        ++it1;
-      }
-      break;
-    }
-    if (it1->id() < it2->id()) {
-      set3->insert(it1->Clone());
-      ++it1;
-    } else if (it1->id() > it2->id()) {
-      set3->insert(it2->Clone());
-      ++it2;
-    } else {
-      set3->insert(it1->Union(*it2));
-      ++it1;
-      ++it2;
-    }
-  }
+  SetOperations<APIPermissionSet>::Union<APIPermission>(set1, set2, set3);
 }
 
 // static
 bool APIPermissionSet::ParseFromJSON(
     const base::ListValue* permissions,
     APIPermissionSet::ParseSource source,
     APIPermissionSet* api_permissions,
     string16* error,
     std::vector<std::string>* unhandled_permissions) {
   for (size_t i = 0; i < permissions->GetSize(); ++i) {
@@ skipping 35 matching lines @@
 void APIPermissionSet::AddImpliedPermissions() {
   // The fileSystem.write and fileSystem.directory permissions imply
   // fileSystem.writeDirectory.
   // TODO(sammc): Remove this. See http://crbug.com/284849.
   if (ContainsKey(map_, APIPermission::kFileSystemWrite) &&
       ContainsKey(map_, APIPermission::kFileSystemDirectory)) {
     insert(APIPermission::kFileSystemWriteDirectory);
   }
 }
 
+ManifestPermissionSet::ManifestPermissionSet() {
+}
+
+ManifestPermissionSet::ManifestPermissionSet(
+    const ManifestPermissionSet& set) {
+  this->operator=(set);
+}
+
+ManifestPermissionSet::~ManifestPermissionSet() {
+}
+
+ManifestPermissionSet::const_iterator::const_iterator(
+    const ManifestPermissionMap::const_iterator& it)
+  : it_(it) {
+}
+
+ManifestPermissionSet::const_iterator::const_iterator(
+    const const_iterator& ids_it)
+  : it_(ids_it.it_) {
+}
+
+ManifestPermissionSet& ManifestPermissionSet::operator=(
+    const ManifestPermissionSet& rhs) {
+  return SetOperations<ManifestPermissionSet>::Assign(*this, rhs);
+}
+
+bool ManifestPermissionSet::operator==(const ManifestPermissionSet& rhs)
+    const {
+  return SetOperations<ManifestPermissionSet>::Equal(*this, rhs);
+}
+
+void ManifestPermissionSet::insert(ManifestPermission* permission) {
+  map_[permission->name()].reset(permission);
+}
+
+bool ManifestPermissionSet::Contains(const ManifestPermissionSet& rhs)
+    const {
+  return SetOperations<ManifestPermissionSet>::Contains(*this, rhs);
+}
+
+void ManifestPermissionSet::Difference(
+    const ManifestPermissionSet& set1,
+    const ManifestPermissionSet& set2,
+    ManifestPermissionSet* set3) {
+  SetOperations<ManifestPermissionSet>::Difference<ManifestPermission>(
+      set1, set2, set3);
+}
+
+void ManifestPermissionSet::Intersection(
+    const ManifestPermissionSet& set1,
+    const ManifestPermissionSet& set2,
+    ManifestPermissionSet* set3) {
+  SetOperations<ManifestPermissionSet>::Intersection<ManifestPermission>(
+      set1, set2, set3);
+}
+
+void ManifestPermissionSet::Union(
+    const ManifestPermissionSet& set1,
+    const ManifestPermissionSet& set2,
+    ManifestPermissionSet* set3) {
+  SetOperations<ManifestPermissionSet>::Union<ManifestPermission>(
+      set1, set2, set3);
+}
+
 }  // namespace extensions