extensions/common/api/bluetooth/bluetooth_manifest_permission.cc

   1 // Copyright 2014 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/api/bluetooth/bluetooth_manifest_permission.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "base/stl_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/values.h"
  11 #include "device/bluetooth/bluetooth_uuid.h"
  12 #include "extensions/common/api/bluetooth/bluetooth_manifest_data.h"
  13 #include "extensions/common/api/extensions_manifest_types.h"
  14 #include "extensions/common/error_utils.h"
  15 #include "extensions/common/manifest_constants.h"
  16 #include "grit/extensions_strings.h"
  17 #include "ipc/ipc_message.h"
  18 #include "ui/base/l10n/l10n_util.h"
  19
  20 namespace extensions {
  21
  22 namespace bluetooth_errors {
  23 const char kErrorInvalidUuid[] = "Invalid UUID '*'";
  24 }
  25
  26 namespace errors = bluetooth_errors;
  27
  28 namespace {
  29
  30 bool ParseUuid(BluetoothManifestPermission* permission,
  31                const std::string& uuid,
  32                base::string16* error) {
  33   device::BluetoothUUID bt_uuid(uuid);
  34   if (!bt_uuid.IsValid()) {
  35     *error = ErrorUtils::FormatErrorMessageUTF16(
  36         errors::kErrorInvalidUuid, uuid);
  37     return false;
  38   }
  39   permission->AddPermission(uuid);
  40   return true;
  41 }
  42
  43 bool ParseUuidArray(BluetoothManifestPermission* permission,
  44                     const scoped_ptr<std::vector<std::string> >& uuids,
  45                     base::string16* error) {
  46   for (std::vector<std::string>::const_iterator it = uuids->begin();
  47        it != uuids->end();
  48        ++it) {
  49     if (!ParseUuid(permission, *it, error)) {
  50       return false;
  51     }
  52   }
  53   return true;
  54 }
  55
  56 }  // namespace
  57
  58 BluetoothManifestPermission::BluetoothManifestPermission()
  59   : socket_(false),
  60     low_energy_(false) {}
  61
  62 BluetoothManifestPermission::~BluetoothManifestPermission() {}
  63
  64 // static
  65 scoped_ptr<BluetoothManifestPermission> BluetoothManifestPermission::FromValue(
  66     const base::Value& value,
  67     base::string16* error) {
  68   scoped_ptr<core_api::extensions_manifest_types::Bluetooth> bluetooth =
  69       core_api::extensions_manifest_types::Bluetooth::FromValue(value, error);
  70   if (!bluetooth)
  71     return scoped_ptr<BluetoothManifestPermission>();
  72
  73   scoped_ptr<BluetoothManifestPermission> result(
  74       new BluetoothManifestPermission());
  75   if (bluetooth->uuids) {
  76     if (!ParseUuidArray(result.get(), bluetooth->uuids, error)) {
  77       return scoped_ptr<BluetoothManifestPermission>();
  78     }
  79   }
  80   if (bluetooth->socket) {
  81     result->socket_ = *(bluetooth->socket);
  82   }
  83   if (bluetooth->low_energy) {
  84     result->low_energy_ = *(bluetooth->low_energy);
  85   }
  86   return result.Pass();
  87 }
  88
  89 bool BluetoothManifestPermission::CheckRequest(
  90     const Extension* extension,
  91     const BluetoothPermissionRequest& request) const {
  92
  93   device::BluetoothUUID param_uuid(request.uuid);
  94   for (BluetoothUuidSet::const_iterator it = uuids_.begin();
  95        it != uuids_.end();
  96        ++it) {
  97     device::BluetoothUUID uuid(*it);
  98     if (param_uuid == uuid)
  99       return true;
 100   }
 101   return false;
 102 }
 103
 104 bool BluetoothManifestPermission::CheckSocketPermitted(
 105     const Extension* extension) const {
 106   return socket_;
 107 }
 108
 109 bool BluetoothManifestPermission::CheckLowEnergyPermitted(
 110     const Extension* extension) const {
 111   return low_energy_;
 112 }
 113
 114 std::string BluetoothManifestPermission::name() const {
 115   return manifest_keys::kBluetooth;
 116 }
 117
 118 std::string BluetoothManifestPermission::id() const { return name(); }
 119
 120 bool BluetoothManifestPermission::HasMessages() const { return true; }
 121
 122 PermissionMessages BluetoothManifestPermission::GetMessages() const {
 123   DCHECK(HasMessages());
 124   PermissionMessages result;
 125
 126   result.push_back(PermissionMessage(
 127       PermissionMessage::kBluetooth,
 128       l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH)));
 129
 130   if (!uuids_.empty()) {
 131     result.push_back(
 132         PermissionMessage(PermissionMessage::kBluetoothDevices,
 133                           l10n_util::GetStringUTF16(
 134                               IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_DEVICES)));
 135   }
 136
 137   return result;
 138 }
 139
 140 bool BluetoothManifestPermission::FromValue(const base::Value* value) {
 141   if (!value)
 142     return false;
 143   base::string16 error;
 144   scoped_ptr<BluetoothManifestPermission> manifest_permission(
 145       BluetoothManifestPermission::FromValue(*value, &error));
 146
 147   if (!manifest_permission)
 148     return false;
 149
 150   uuids_ = manifest_permission->uuids_;
 151   return true;
 152 }
 153
 154 scoped_ptr<base::Value> BluetoothManifestPermission::ToValue() const {
 155   core_api::extensions_manifest_types::Bluetooth bluetooth;
 156   bluetooth.uuids.reset(new std::vector<std::string>(uuids_.begin(),
 157                                                      uuids_.end()));
 158   return bluetooth.ToValue().Pass();
 159 }
 160
 161 ManifestPermission* BluetoothManifestPermission::Diff(
 162     const ManifestPermission* rhs) const {
 163   const BluetoothManifestPermission* other =
 164       static_cast<const BluetoothManifestPermission*>(rhs);
 165
 166   scoped_ptr<BluetoothManifestPermission> result(
 167       new BluetoothManifestPermission());
 168   result->uuids_ = base::STLSetDifference<BluetoothUuidSet>(
 169       uuids_, other->uuids_);
 170   return result.release();
 171 }
 172
 173 ManifestPermission* BluetoothManifestPermission::Union(
 174     const ManifestPermission* rhs) const {
 175   const BluetoothManifestPermission* other =
 176       static_cast<const BluetoothManifestPermission*>(rhs);
 177
 178   scoped_ptr<BluetoothManifestPermission> result(
 179       new BluetoothManifestPermission());
 180   result->uuids_ = base::STLSetUnion<BluetoothUuidSet>(
 181       uuids_, other->uuids_);
 182   return result.release();
 183 }
 184
 185 ManifestPermission* BluetoothManifestPermission::Intersect(
 186     const ManifestPermission* rhs) const {
 187   const BluetoothManifestPermission* other =
 188       static_cast<const BluetoothManifestPermission*>(rhs);
 189
 190   scoped_ptr<BluetoothManifestPermission> result(
 191       new BluetoothManifestPermission());
 192   result->uuids_ = base::STLSetIntersection<BluetoothUuidSet>(
 193       uuids_, other->uuids_);
 194   return result.release();
 195 }
 196
 197 void BluetoothManifestPermission::AddPermission(const std::string& uuid) {
 198   uuids_.insert(uuid);
 199 }
 200
 201 }  // namespace extensions