extensions/common/permissions/api_permission.cc

   1 // Copyright 2013 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 #include "extensions/common/permissions/api_permission.h"
   6
   7 #include "extensions/common/permissions/api_permission_set.h"
   8 #include "ui/base/l10n/l10n_util.h"
   9
  10 namespace {
  11
  12 using extensions::APIPermission;
  13 using extensions::APIPermissionInfo;
  14 using extensions::PermissionMessage;
  15 using extensions::PermissionMessages;
  16
  17 class SimpleAPIPermission : public APIPermission {
  18  public:
  19   explicit SimpleAPIPermission(const APIPermissionInfo* permission)
  20     : APIPermission(permission) { }
  21
  22   ~SimpleAPIPermission() override {}
  23
  24   extensions::PermissionIDSet GetPermissions() const override {
  25     extensions::PermissionIDSet permissions;
  26     permissions.insert(id());
  27     return permissions;
  28   }
  29
  30   bool Check(const APIPermission::CheckParam* param) const override {
  31     return !param;
  32   }
  33
  34   bool Contains(const APIPermission* rhs) const override {
  35     CHECK_EQ(info(), rhs->info());
  36     return true;
  37   }
  38
  39   bool Equal(const APIPermission* rhs) const override {
  40     if (this != rhs)
  41       CHECK_EQ(info(), rhs->info());
  42     return true;
  43   }
  44
  45   bool FromValue(const base::Value* value,
  46                  std::string* /*error*/,
  47                  std::vector<std::string>* /*unhandled_permissions*/) override {
  48     return (value == NULL);
  49   }
  50
  51   scoped_ptr<base::Value> ToValue() const override {
  52     return scoped_ptr<base::Value>();
  53   }
  54
  55   APIPermission* Clone() const override {
  56     return new SimpleAPIPermission(info());
  57   }
  58
  59   APIPermission* Diff(const APIPermission* rhs) const override {
  60     CHECK_EQ(info(), rhs->info());
  61     return NULL;
  62   }
  63
  64   APIPermission* Union(const APIPermission* rhs) const override {
  65     CHECK_EQ(info(), rhs->info());
  66     return new SimpleAPIPermission(info());
  67   }
  68
  69   APIPermission* Intersect(const APIPermission* rhs) const override {
  70     CHECK_EQ(info(), rhs->info());
  71     return new SimpleAPIPermission(info());
  72   }
  73
  74   void Write(IPC::Message* m) const override {}
  75
  76   bool Read(const IPC::Message* m, base::PickleIterator* iter) override {
  77     return true;
  78   }
  79
  80   void Log(std::string* log) const override {}
  81 };
  82
  83 }  // namespace
  84
  85 namespace extensions {
  86
  87 APIPermission::APIPermission(const APIPermissionInfo* info)
  88   : info_(info) {
  89   DCHECK(info_);
  90 }
  91
  92 APIPermission::~APIPermission() { }
  93
  94 APIPermission::ID APIPermission::id() const {
  95   return info()->id();
  96 }
  97
  98 const char* APIPermission::name() const {
  99   return info()->name();
 100 }
 101
 102 //
 103 // APIPermissionInfo
 104 //
 105
 106 APIPermissionInfo::APIPermissionInfo(const APIPermissionInfo::InitInfo& info)
 107     : id_(info.id),
 108       name_(info.name),
 109       flags_(info.flags),
 110       api_permission_constructor_(info.constructor) {
 111 }
 112
 113 APIPermissionInfo::~APIPermissionInfo() { }
 114
 115 APIPermission* APIPermissionInfo::CreateAPIPermission() const {
 116   return api_permission_constructor_ ?
 117     api_permission_constructor_(this) : new SimpleAPIPermission(this);
 118 }
 119
 120 }  // namespace extensions