Enable permission warnings from ManifestHandlers.

extensions/common/permissions/api_permission_set.cc

Index: extensions/common/permissions/api_permission_set.cc
diff --git a/extensions/common/permissions/api_permission_set.cc b/extensions/common/permissions/api_permission_set.cc
index ebaf8d8bca40f11383501590c8be1bbeec4ed218..6efb2fee30276cf26ac788a43b9d6beadae63afd 100644
--- a/extensions/common/permissions/api_permission_set.cc
+++ b/extensions/common/permissions/api_permission_set.cc
@@ -109,6 +109,155 @@ bool ParseChildPermissions(const std::string& base_name,
 
 }  // 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() {
 }
 
@@ -130,28 +279,11 @@ APIPermissionSet::const_iterator::const_iterator(
 }
 
 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) {
@@ -165,126 +297,29 @@ void APIPermissionSet::insert(APIPermission* 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
@@ -340,4 +375,68 @@ void APIPermissionSet::AddImpliedPermissions() {
   }
 }
 
+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