Home | History | Annotate | Download | only in permissions 
      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   enum ParseSource {
     64     // Don't allow internal permissions to be parsed (e.g. entries in the
     65     // "permissions" list in a manifest).
     66     kDisallowInternalPermissions,
     67 
     68     // Allow internal permissions to be parsed (e.g. from the "api" field of a
     69     // permissions list in the prefs).
     70     kAllowInternalPermissions,
     71   };
     72 
     73   APIPermissionSet();
     74 
     75   APIPermissionSet(const APIPermissionSet& set);
     76 
     77   ~APIPermissionSet();
     78 
     79   const_iterator begin() const {
     80     return const_iterator(map().begin());
     81   }
     82 
     83   const_iterator end() const {
     84     return map().end();
     85   }
     86 
     87   const_iterator find(APIPermission::ID id) const {
     88     return map().find(id);
     89   }
     90 
     91   const APIPermissionMap& map() const {
     92     return map_;
     93   }
     94 
     95   APIPermissionMap& map() {
     96     return map_;
     97   }
     98 
     99   void clear() {
    100     map_.clear();
    101   }
    102 
    103   size_t count(APIPermission::ID id) const {
    104     return map().count(id);
    105   }
    106 
    107   bool empty() const {
    108     return map().empty();
    109   }
    110 
    111   size_t erase(APIPermission::ID id) {
    112     return map().erase(id);
    113   }
    114 
    115   size_t size() const {
    116     return map().size();
    117   }
    118 
    119   APIPermissionSet& operator=(const APIPermissionSet& rhs);
    120 
    121   bool operator==(const APIPermissionSet& rhs) const;
    122 
    123   bool operator!=(const APIPermissionSet& rhs) const {
    124     return !operator==(rhs);
    125   }
    126 
    127   void insert(APIPermission::ID id);
    128 
    129   // Insert |permission| into the APIPermissionSet. The APIPermissionSet will
    130   // take the ownership of |permission|,
    131   void insert(APIPermission* permission);
    132 
    133   bool Contains(const APIPermissionSet& rhs) const;
    134 
    135   static void Difference(
    136       const APIPermissionSet& set1,
    137       const APIPermissionSet& set2,
    138       APIPermissionSet* set3);
    139 
    140   static void Intersection(
    141       const APIPermissionSet& set1,
    142       const APIPermissionSet& set2,
    143       APIPermissionSet* set3);
    144 
    145   static void Union(
    146       const APIPermissionSet& set1,
    147       const APIPermissionSet& set2,
    148       APIPermissionSet* set3);
    149 
    150   // Parses permissions from |permissions| and adds the parsed permissions to
    151   // |api_permissions|. If |source| is kDisallowInternalPermissions, treat
    152   // permissions with kFlagInternal as errors. If |unhandled_permissions|
    153   // is not NULL, the names of all permissions that couldn't be parsed will be
    154   // added to this vector. If |error| is NULL, parsing will continue with the
    155   // next permission if invalid data is detected. If |error| is not NULL, it
    156   // will be set to an error message and false is returned when an invalid
    157   // permission is found.
    158   static bool ParseFromJSON(
    159       const base::ListValue* permissions,
    160       ParseSource source,
    161       APIPermissionSet* api_permissions,
    162       string16* error,
    163       std::vector<std::string>* unhandled_permissions);
    164 
    165  private:
    166   APIPermissionMap map_;
    167 };
    168 
    169 }  // namespace extensions
    170 
    171 #endif  // CHROME_COMMON_EXTENSIONS_PERMISSIONS_API_PERMISSION_SET_H_
    172