chrome/common/extensions/permissions/api_permission_set.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_
   6 #define CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_
   7
   8 #include <iterator>
   9 #include <map>
  10
  11 #include "base/memory/linked_ptr.h"
  12 #include "chrome/common/extensions/permissions/api_permission.h"
  13
  14 namespace base {
  15 class ListValue;
  16 }  // namespace base
  17
  18 namespace extensions {
  19
  20 class Extension;
  21
  22 typedef std::map<APIPermission::ID,
  23   linked_ptr<APIPermission> > APIPermissionMap;
  24
  25 class APIPermissionSet {
  26  public:
  27   class const_iterator :
  28     public std::iterator<std::input_iterator_tag, const APIPermission*> {
  29    public:
  30     const_iterator(const APIPermissionMap::const_iterator& it);
  31     const_iterator(const const_iterator& ids_it);
  32
  33     const_iterator& operator++() {
  34       ++it_;
  35       return *this;
  36     }
  37
  38     const_iterator operator++(int) {
  39       const_iterator tmp(it_++);
  40       return tmp;
  41     }
  42
  43     bool operator==(const const_iterator& rhs) const {
  44       return it_ == rhs.it_;
  45     }
  46
  47     bool operator!=(const const_iterator& rhs) const {
  48       return it_ != rhs.it_;
  49     }
  50
  51     const APIPermission* operator*() const {
  52       return it_->second.get();
  53     }
  54
  55     const APIPermission* operator->() const {
  56       return it_->second.get();
  57     }
  58
  59    private:
  60     APIPermissionMap::const_iterator it_;
  61   };
  62
  63   APIPermissionSet();
  64
  65   APIPermissionSet(const APIPermissionSet& set);
  66
  67   ~APIPermissionSet();
  68
  69   const_iterator begin() const {
  70     return const_iterator(map().begin());
  71   }
  72
  73   const_iterator end() const {
  74     return map().end();
  75   }
  76
  77   const_iterator find(APIPermission::ID id) const {
  78     return map().find(id);
  79   }
  80
  81   const APIPermissionMap& map() const {
  82     return map_;
  83   }
  84
  85   APIPermissionMap& map() {
  86     return map_;
  87   }
  88
  89   void clear() {
  90     map_.clear();
  91   }
  92
  93   size_t count(APIPermission::ID id) const {
  94     return map().count(id);
  95   }
  96
  97   bool empty() const {
  98     return map().empty();
  99   }
 100
 101   size_t erase(APIPermission::ID id) {
 102     return map().erase(id);
 103   }
 104
 105   size_t size() const {
 106     return map().size();
 107   }
 108
 109   APIPermissionSet& operator=(const APIPermissionSet& rhs);
 110
 111   bool operator==(const APIPermissionSet& rhs) const;
 112
 113   bool operator!=(const APIPermissionSet& rhs) const {
 114     return !operator==(rhs);
 115   }
 116
 117   void insert(APIPermission::ID id);
 118
 119   // Insert |permission| into the APIPermissionSet. The APIPermissionSet will
 120   // take the ownership of |permission|,
 121   void insert(APIPermission* permission);
 122
 123   bool Contains(const APIPermissionSet& rhs) const;
 124
 125   static void Difference(
 126       const APIPermissionSet& set1,
 127       const APIPermissionSet& set2,
 128       APIPermissionSet* set3);
 129
 130   static void Intersection(
 131       const APIPermissionSet& set1,
 132       const APIPermissionSet& set2,
 133       APIPermissionSet* set3);
 134
 135   static void Union(
 136       const APIPermissionSet& set1,
 137       const APIPermissionSet& set2,
 138       APIPermissionSet* set3);
 139
 140   // Parses permissions from |permissions_data| and adds the parsed permissions
 141   // to |api_permissions|. If |unhandled_permissions| is not NULL the names of
 142   // all permissions that couldn't be parsed will be added to this vector.
 143   // If |error| is NULL, parsing will continue with the next permission if
 144   // invalid data is detected. If |error| is not NULL, it will be set to an
 145   // error message and false is returned when an invalid permission is found.
 146   static bool ParseFromJSON(
 147       const base::ListValue* permissions_data,
 148       APIPermissionSet* api_permissions,
 149       string16* error,
 150       std::vector<std::string>* unhandled_permissions);
 151
 152  private:
 153   APIPermissionMap map_;
 154 };
 155
 156 }  // namespace extensions
 157
 158 #endif  // CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_