extensions/common/permissions/extensions_api_permissions.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/permissions/extensions_api_permissions.h"
   6
   7 #include <vector>
   8
   9 #include "extensions/common/permissions/api_permission.h"
  10 #include "extensions/common/permissions/permission_message.h"
  11 #include "extensions/common/permissions/socket_permission.h"
  12 #include "extensions/common/permissions/usb_device_permission.h"
  13 #include "grit/extensions_strings.h"
  14
  15 namespace extensions {
  16
  17 namespace {
  18
  19 const char kOldAlwaysOnTopWindowsPermission[] = "alwaysOnTopWindows";
  20 const char kOldFullscreenPermission[] = "fullscreen";
  21 const char kOldOverrideEscFullscreenPermission[] = "overrideEscFullscreen";
  22 const char kOldUnlimitedStoragePermission[] = "unlimited_storage";
  23
  24 template <typename T>
  25 APIPermission* CreateAPIPermission(const APIPermissionInfo* permission) {
  26   return new T(permission);
  27 }
  28
  29 }  // namespace
  30
  31 std::vector<APIPermissionInfo*> ExtensionsAPIPermissions::GetAllPermissions()
  32     const {
  33   APIPermissionInfo::InitInfo permissions_to_register[] = {
  34       {APIPermission::kAlphaEnabled, "app.window.alpha"},
  35       {APIPermission::kAlwaysOnTopWindows, "app.window.alwaysOnTop"},
  36       {APIPermission::kAppView,
  37        "appview",
  38        APIPermissionInfo::kFlagCannotBeOptional},
  39       {APIPermission::kAudio, "audio"},
  40       {APIPermission::kAudioCapture,
  41        "audioCapture",
  42        APIPermissionInfo::kFlagNone,
  43        IDS_EXTENSION_PROMPT_WARNING_AUDIO_CAPTURE,
  44        PermissionMessage::kAudioCapture},
  45       {APIPermission::kBluetoothPrivate,
  46        "bluetoothPrivate",
  47        APIPermissionInfo::kFlagCannotBeOptional,
  48        IDS_EXTENSION_PROMPT_WARNING_BLUETOOTH_PRIVATE,
  49        PermissionMessage::kBluetoothPrivate},
  50       {APIPermission::kClipboardRead,
  51        "clipboardRead",
  52        APIPermissionInfo::kFlagSupportsContentCapabilities,
  53        IDS_EXTENSION_PROMPT_WARNING_CLIPBOARD,
  54        PermissionMessage::kClipboard},
  55       {APIPermission::kClipboardWrite,
  56        "clipboardWrite",
  57        APIPermissionInfo::kFlagSupportsContentCapabilities},
  58       {APIPermission::kDeclarativeWebRequest,
  59        "declarativeWebRequest",
  60        APIPermissionInfo::kFlagNone,
  61        IDS_EXTENSION_PROMPT_WARNING_DECLARATIVE_WEB_REQUEST,
  62        PermissionMessage::kDeclarativeWebRequest},
  63       {APIPermission::kDns, "dns"},
  64       {APIPermission::kExternallyConnectableAllUrls,
  65        "externally_connectable.all_urls"},
  66       {APIPermission::kFullscreen, "app.window.fullscreen"},
  67       {APIPermission::kHid, "hid", APIPermissionInfo::kFlagNone},
  68       {APIPermission::kImeWindowEnabled, "app.window.ime"},
  69       {APIPermission::kOverrideEscFullscreen,
  70        "app.window.fullscreen.overrideEsc"},
  71       {APIPermission::kIdle, "idle"},
  72       {APIPermission::kPower, "power"},
  73       {APIPermission::kPrinterProvider, "printerProvider"},
  74       {APIPermission::kSerial,
  75        "serial",
  76        APIPermissionInfo::kFlagNone,
  77        IDS_EXTENSION_PROMPT_WARNING_SERIAL,
  78        PermissionMessage::kSerial},
  79       // Because warning messages for the "socket" permission vary based
  80       // on the permissions parameters, no message ID or message text is
  81       // specified here.  The message ID and text used will be
  82       // determined at run-time in the |SocketPermission| class.
  83       {APIPermission::kSocket,
  84        "socket",
  85        APIPermissionInfo::kFlagCannotBeOptional,
  86        0,
  87        PermissionMessage::kNone,
  88        &CreateAPIPermission<SocketPermission>},
  89       {APIPermission::kStorage, "storage"},
  90       {APIPermission::kSystemCpu, "system.cpu"},
  91       {APIPermission::kSystemMemory, "system.memory"},
  92       {APIPermission::kSystemNetwork, "system.network"},
  93       {APIPermission::kSystemDisplay, "system.display"},
  94       {APIPermission::kSystemStorage, "system.storage"},
  95       {APIPermission::kU2fDevices,
  96        "u2fDevices",
  97        APIPermissionInfo::kFlagNone,
  98        IDS_EXTENSION_PROMPT_WARNING_U2F_DEVICES,
  99        PermissionMessage::kU2fDevices},
 100       {APIPermission::kUnlimitedStorage,
 101        "unlimitedStorage",
 102        APIPermissionInfo::kFlagCannotBeOptional |
 103            APIPermissionInfo::kFlagSupportsContentCapabilities},
 104       {APIPermission::kUsb, "usb", APIPermissionInfo::kFlagNone},
 105       {APIPermission::kUsbDevice,
 106        "usbDevices",
 107        APIPermissionInfo::kFlagNone,
 108        0,
 109        PermissionMessage::kNone,
 110        &CreateAPIPermission<UsbDevicePermission>},
 111       {APIPermission::kVideoCapture,
 112        "videoCapture",
 113        APIPermissionInfo::kFlagNone,
 114        IDS_EXTENSION_PROMPT_WARNING_VIDEO_CAPTURE,
 115        PermissionMessage::kVideoCapture},
 116       {APIPermission::kVpnProvider,
 117        "vpnProvider",
 118        APIPermissionInfo::kFlagCannotBeOptional,
 119        IDS_EXTENSION_PROMPT_WARNING_VPN,
 120        PermissionMessage::kVpnProvider},
 121       // NOTE(kalman): This is provided by a manifest property but needs to
 122       // appear in the install permission dialogue, so we need a fake
 123       // permission for it. See http://crbug.com/247857.
 124       {APIPermission::kWebConnectable,
 125        "webConnectable",
 126        APIPermissionInfo::kFlagCannotBeOptional |
 127            APIPermissionInfo::kFlagInternal,
 128        IDS_EXTENSION_PROMPT_WARNING_WEB_CONNECTABLE,
 129        PermissionMessage::kWebConnectable},
 130       {APIPermission::kWebRequest, "webRequest"},
 131       {APIPermission::kWebRequestBlocking, "webRequestBlocking"},
 132       {APIPermission::kWebView,
 133        "webview",
 134        APIPermissionInfo::kFlagCannotBeOptional},
 135       {APIPermission::kWindowShape, "app.window.shape"},
 136   };
 137
 138   std::vector<APIPermissionInfo*> permissions;
 139   for (size_t i = 0; i < arraysize(permissions_to_register); ++i)
 140     permissions.push_back(new APIPermissionInfo(permissions_to_register[i]));
 141   return permissions;
 142 }
 143
 144 std::vector<PermissionsProvider::AliasInfo>
 145 ExtensionsAPIPermissions::GetAllAliases() const {
 146   std::vector<PermissionsProvider::AliasInfo> aliases;
 147   aliases.push_back(PermissionsProvider::AliasInfo(
 148       "app.window.alwaysOnTop", kOldAlwaysOnTopWindowsPermission));
 149   aliases.push_back(PermissionsProvider::AliasInfo("app.window.fullscreen",
 150                                                    kOldFullscreenPermission));
 151   aliases.push_back(
 152       PermissionsProvider::AliasInfo("app.window.fullscreen.overrideEsc",
 153                                      kOldOverrideEscFullscreenPermission));
 154   aliases.push_back(PermissionsProvider::AliasInfo(
 155       "unlimitedStorage", kOldUnlimitedStoragePermission));
 156   return aliases;
 157 }
 158
 159 }  // namespace extensions