components/permissions/permission_request.cc

   1 // Copyright 2015 The Chromium Authors
   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 "components/permissions/permission_request.h"
   6
   7 #include <string>
   8
   9 #include "base/no_destructor.h"
  10 #include "base/notreached.h"
  11 #include "build/build_config.h"
  12 #include "components/permissions/features.h"
  13 #include "components/permissions/permission_util.h"
  14 #include "components/permissions/request_type.h"
  15 #include "components/strings/grit/components_strings.h"
  16 #include "components/url_formatter/elide_url.h"
  17 #include "ui/base/l10n/l10n_util.h"
  18
  19 namespace permissions {
  20
  21 PermissionRequest::PermissionRequest(
  22     const GURL& requesting_origin,
  23     RequestType request_type,
  24     bool has_gesture,
  25     PermissionDecidedCallback permission_decided_callback,
  26     base::OnceClosure delete_callback)
  27     : data_(
  28           PermissionRequestData(request_type, has_gesture, requesting_origin)),
  29       permission_decided_callback_(std::move(permission_decided_callback)),
  30       delete_callback_(std::move(delete_callback)) {}
  31
  32 PermissionRequest::PermissionRequest(
  33     PermissionRequestData request_data,
  34     PermissionDecidedCallback permission_decided_callback,
  35     base::OnceClosure delete_callback)
  36     : data_(std::move(request_data)),
  37       permission_decided_callback_(std::move(permission_decided_callback)),
  38       delete_callback_(std::move(delete_callback)) {}
  39
  40 PermissionRequest::~PermissionRequest() {
  41   DCHECK(delete_callback_.is_null());
  42 }
  43
  44 RequestType PermissionRequest::request_type() const {
  45   CHECK(data_.request_type);
  46   return data_.request_type.value();
  47 }
  48
  49 bool PermissionRequest::IsDuplicateOf(PermissionRequest* other_request) const {
  50   return request_type() == other_request->request_type() &&
  51          requesting_origin() == other_request->requesting_origin();
  52 }
  53
  54 base::WeakPtr<PermissionRequest> PermissionRequest::GetWeakPtr() {
  55   return weak_factory_.GetWeakPtr();
  56 }
  57
  58 #if BUILDFLAG(IS_ANDROID)
  59 std::u16string PermissionRequest::GetDialogMessageText() const {
  60   int message_id = 0;
  61   switch (request_type()) {
  62     case RequestType::kAccessibilityEvents:
  63       message_id = IDS_ACCESSIBILITY_EVENTS_INFOBAR_TEXT;
  64       break;
  65     case RequestType::kArSession:
  66       message_id = IDS_AR_INFOBAR_TEXT;
  67       break;
  68     case RequestType::kCameraStream:
  69       message_id = IDS_MEDIA_CAPTURE_VIDEO_ONLY_INFOBAR_TEXT;
  70       break;
  71     case RequestType::kClipboard:
  72       message_id = IDS_CLIPBOARD_INFOBAR_TEXT;
  73       break;
  74     case RequestType::kDiskQuota:
  75       // Handled by an override in `QuotaPermissionRequest`.
  76       NOTREACHED();
  77       break;
  78     case RequestType::kGeolocation:
  79       message_id = IDS_GEOLOCATION_INFOBAR_TEXT;
  80       break;
  81     case RequestType::kIdleDetection:
  82       message_id = IDS_IDLE_DETECTION_INFOBAR_TEXT;
  83       break;
  84     case RequestType::kMicStream:
  85       message_id = IDS_MEDIA_CAPTURE_AUDIO_ONLY_INFOBAR_TEXT;
  86       break;
  87     case RequestType::kMidi:
  88       message_id = IDS_MIDI_INFOBAR_TEXT;
  89       break;
  90     case RequestType::kMidiSysex:
  91       message_id = IDS_MIDI_SYSEX_INFOBAR_TEXT;
  92       break;
  93     case RequestType::kMultipleDownloads:
  94       message_id = IDS_MULTI_DOWNLOAD_WARNING;
  95       break;
  96     case RequestType::kNfcDevice:
  97       message_id = IDS_NFC_INFOBAR_TEXT;
  98       break;
  99     case RequestType::kNotifications:
 100       message_id = IDS_NOTIFICATIONS_INFOBAR_TEXT;
 101       break;
 102     case RequestType::kProtectedMediaIdentifier:
 103       message_id =
 104           IDS_PROTECTED_MEDIA_IDENTIFIER_PER_ORIGIN_PROVISIONING_INFOBAR_TEXT;
 105       break;
 106     case RequestType::kStorageAccess:
 107     case RequestType::kTopLevelStorageAccess:
 108       // Handled by `PermissionPromptAndroid::GetMessageText` directly.
 109       NOTREACHED();
 110       break;
 111     case RequestType::kVrSession:
 112       message_id = IDS_VR_INFOBAR_TEXT;
 113       break;
 114   }
 115   DCHECK_NE(0, message_id);
 116   return l10n_util::GetStringFUTF16(
 117       message_id, url_formatter::FormatUrlForSecurityDisplay(
 118                       requesting_origin(),
 119                       url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC));
 120 }
 121 #endif
 122
 123 bool PermissionRequest::IsEmbeddedPermissionElementInitiated() const {
 124   return data_.embedded_permission_element_initiated;
 125 }
 126
 127 #if !BUILDFLAG(IS_ANDROID)
 128
 129 bool PermissionRequest::IsConfirmationChipSupported() {
 130   return permissions::IsConfirmationChipSupported(request_type());
 131 }
 132
 133 IconId PermissionRequest::GetIconForChip() {
 134   return permissions::GetIconId(request_type());
 135 }
 136
 137 IconId PermissionRequest::GetBlockedIconForChip() {
 138   return permissions::GetBlockedIconId(request_type());
 139 }
 140
 141 absl::optional<std::u16string> PermissionRequest::GetRequestChipText(
 142     ChipTextType type) const {
 143   static base::NoDestructor<std::map<RequestType, std::vector<int>>> kMessageIds(
 144       {{RequestType::kArSession,
 145         {IDS_AR_PERMISSION_CHIP, -1, -1, -1, -1, -1, -1, -1}},
 146        {RequestType::kCameraStream,
 147         {IDS_MEDIA_CAPTURE_VIDEO_ONLY_PERMISSION_CHIP, -1,
 148          IDS_PERMISSIONS_PERMISSION_ALLOWED_CONFIRMATION,
 149          IDS_PERMISSIONS_PERMISSION_ALLOWED_ONCE_CONFIRMATION,
 150          IDS_PERMISSIONS_PERMISSION_NOT_ALLOWED_CONFIRMATION,
 151          IDS_PERMISSIONS_CAMERA_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT,
 152          IDS_PERMISSIONS_CAMERA_ALLOWED_ONCE_CONFIRMATION_SCREENREADER_ANNOUNCEMENT,
 153          IDS_PERMISSIONS_CAMERA_NOT_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT}},
 154        {RequestType::kClipboard,
 155         {IDS_CLIPBOARD_PERMISSION_CHIP, -1, -1, -1, -1, -1, -1, -1}},
 156        {RequestType::kGeolocation,
 157         {IDS_GEOLOCATION_PERMISSION_CHIP,
 158          IDS_GEOLOCATION_PERMISSION_BLOCKED_CHIP,
 159          IDS_PERMISSIONS_PERMISSION_ALLOWED_CONFIRMATION,
 160          IDS_PERMISSIONS_PERMISSION_ALLOWED_ONCE_CONFIRMATION,
 161          IDS_PERMISSIONS_PERMISSION_NOT_ALLOWED_CONFIRMATION,
 162          IDS_PERMISSIONS_GEOLOCATION_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT,
 163          IDS_PERMISSIONS_PERMISSION_ALLOWED_ONCE_CONFIRMATION,
 164          IDS_PERMISSIONS_GEOLOCATION_NOT_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT}},
 165        {RequestType::kIdleDetection,
 166         {IDS_IDLE_DETECTION_PERMISSION_CHIP, -1, -1, -1, -1, -1, -1, -1}},
 167        {RequestType::kMicStream,
 168         {IDS_MEDIA_CAPTURE_AUDIO_ONLY_PERMISSION_CHIP, -1,
 169          IDS_PERMISSIONS_PERMISSION_ALLOWED_CONFIRMATION,
 170          IDS_PERMISSIONS_PERMISSION_ALLOWED_ONCE_CONFIRMATION,
 171          IDS_PERMISSIONS_PERMISSION_NOT_ALLOWED_CONFIRMATION,
 172          IDS_PERMISSIONS_MICROPHONE_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT,
 173          IDS_PERMISSIONS_MICROPHONE_ALLOWED_ONCE_CONFIRMATION_SCREENREADER_ANNOUNCEMENT,
 174          IDS_PERMISSIONS_MICROPHONE_NOT_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT}},
 175        {RequestType::kMidi,
 176         {IDS_MIDI_PERMISSION_CHIP, -1, -1, -1, -1, -1, -1, -1}},
 177        {RequestType::kMidiSysex,
 178         {IDS_MIDI_SYSEX_PERMISSION_CHIP, -1, -1, -1, -1, -1, -1, -1}},
 179        {RequestType::kNotifications,
 180         {IDS_NOTIFICATION_PERMISSIONS_CHIP,
 181          IDS_NOTIFICATION_PERMISSIONS_BLOCKED_CHIP,
 182          IDS_PERMISSIONS_PERMISSION_ALLOWED_CONFIRMATION, -1,
 183          IDS_PERMISSIONS_PERMISSION_NOT_ALLOWED_CONFIRMATION,
 184          IDS_PERMISSIONS_NOTIFICATION_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT,
 185          -1,
 186          IDS_PERMISSIONS_NOTIFICATION_NOT_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT}},
 187        {RequestType::kStorageAccess,
 188         {IDS_SAA_PERMISSION_CHIP, -1,
 189          IDS_PERMISSIONS_PERMISSION_ALLOWED_CONFIRMATION, -1,
 190          IDS_PERMISSIONS_PERMISSION_NOT_ALLOWED_CONFIRMATION,
 191          IDS_PERMISSIONS_SAA_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT, -1,
 192          IDS_PERMISSIONS_SAA_NOT_ALLOWED_CONFIRMATION_SCREENREADER_ANNOUNCEMENT}},
 193        {RequestType::kVrSession,
 194         {IDS_VR_PERMISSION_CHIP, -1, -1, -1, -1, -1, -1, -1}}});
 195
 196   auto messages = kMessageIds->find(request_type());
 197   if (messages != kMessageIds->end() && messages->second[type] != -1)
 198     return l10n_util::GetStringUTF16(messages->second[type]);
 199
 200   return absl::nullopt;
 201 }
 202
 203 std::u16string PermissionRequest::GetMessageTextFragment() const {
 204   int message_id = 0;
 205   switch (request_type()) {
 206     case RequestType::kAccessibilityEvents:
 207       message_id = IDS_ACCESSIBILITY_EVENTS_PERMISSION_FRAGMENT;
 208       break;
 209     case RequestType::kArSession:
 210       message_id = IDS_AR_PERMISSION_FRAGMENT;
 211       break;
 212     case RequestType::kCameraPanTiltZoom:
 213       message_id = IDS_MEDIA_CAPTURE_CAMERA_PAN_TILT_ZOOM_PERMISSION_FRAGMENT;
 214       break;
 215     case RequestType::kCameraStream:
 216       message_id = IDS_MEDIA_CAPTURE_VIDEO_ONLY_PERMISSION_FRAGMENT;
 217       break;
 218     case RequestType::kClipboard:
 219       message_id = IDS_CLIPBOARD_PERMISSION_FRAGMENT;
 220       break;
 221     case RequestType::kDiskQuota:
 222       message_id = IDS_REQUEST_QUOTA_PERMISSION_FRAGMENT;
 223       break;
 224     case RequestType::kFileSystemAccess:
 225       message_id = IDS_SITE_SETTINGS_TYPE_FILE_SYSTEM_ACCESS_WRITE;
 226       break;
 227     case RequestType::kGeolocation:
 228       message_id = IDS_GEOLOCATION_INFOBAR_PERMISSION_FRAGMENT;
 229       break;
 230     case RequestType::kIdleDetection:
 231       message_id = IDS_IDLE_DETECTION_PERMISSION_FRAGMENT;
 232       break;
 233     case RequestType::kLocalFonts:
 234       message_id = IDS_FONT_ACCESS_PERMISSION_FRAGMENT;
 235       break;
 236     case RequestType::kMicStream:
 237       message_id = IDS_MEDIA_CAPTURE_AUDIO_ONLY_PERMISSION_FRAGMENT;
 238       break;
 239     case RequestType::kMidi:
 240       message_id = IDS_MIDI_PERMISSION_FRAGMENT;
 241       break;
 242     case RequestType::kMidiSysex:
 243       message_id = IDS_MIDI_SYSEX_PERMISSION_FRAGMENT;
 244       break;
 245     case RequestType::kMultipleDownloads:
 246       message_id = IDS_MULTI_DOWNLOAD_PERMISSION_FRAGMENT;
 247       break;
 248     case RequestType::kNotifications:
 249       message_id = IDS_NOTIFICATION_PERMISSIONS_FRAGMENT;
 250       break;
 251 #if BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_WIN)
 252     case RequestType::kProtectedMediaIdentifier:
 253       message_id = IDS_PROTECTED_MEDIA_IDENTIFIER_PERMISSION_FRAGMENT;
 254       break;
 255 #endif
 256     case RequestType::kRegisterProtocolHandler:
 257       // Handled by an override in `RegisterProtocolHandlerPermissionRequest`.
 258       NOTREACHED();
 259       return std::u16string();
 260     case RequestType::kStorageAccess:
 261     case RequestType::kTopLevelStorageAccess:
 262       message_id = IDS_STORAGE_ACCESS_PERMISSION_FRAGMENT;
 263       break;
 264     case RequestType::kVrSession:
 265       message_id = IDS_VR_PERMISSION_FRAGMENT;
 266       break;
 267     case RequestType::kWindowManagement:
 268       message_id = IDS_WINDOW_MANAGEMENT_PERMISSION_FRAGMENT;
 269       break;
 270   }
 271   DCHECK_NE(0, message_id);
 272   return l10n_util::GetStringUTF16(message_id);
 273 }
 274 #endif
 275
 276 bool PermissionRequest::ShouldUseTwoOriginPrompt() const {
 277   return request_type() == RequestType::kStorageAccess &&
 278          base::FeatureList::IsEnabled(
 279              permissions::features::kPermissionStorageAccessAPI);
 280 }
 281
 282 void PermissionRequest::PermissionGranted(bool is_one_time) {
 283   std::move(permission_decided_callback_)
 284       .Run(CONTENT_SETTING_ALLOW, is_one_time,
 285            /*is_final_decision=*/true);
 286 }
 287
 288 void PermissionRequest::PermissionDenied() {
 289   std::move(permission_decided_callback_)
 290       .Run(CONTENT_SETTING_BLOCK, /*is_one_time=*/false,
 291            /*is_final_decision=*/true);
 292 }
 293
 294 void PermissionRequest::Cancelled(bool is_final_decision) {
 295   permission_decided_callback_.Run(CONTENT_SETTING_DEFAULT,
 296                                    /*is_one_time=*/false, is_final_decision);
 297 }
 298
 299 void PermissionRequest::RequestFinished() {
 300   std::move(delete_callback_).Run();
 301 }
 302
 303 PermissionRequestGestureType PermissionRequest::GetGestureType() const {
 304   return PermissionUtil::GetGestureType(data_.user_gesture);
 305 }
 306
 307 ContentSettingsType PermissionRequest::GetContentSettingsType() const {
 308   auto type = RequestTypeToContentSettingsType(request_type());
 309   if (type.has_value())
 310     return type.value();
 311   return ContentSettingsType::DEFAULT;
 312 }
 313
 314 std::u16string PermissionRequest::GetPermissionNameTextFragment() const {
 315   int message_id = 0;
 316   switch (request_type()) {
 317     case RequestType::kCameraStream:
 318       message_id = IDS_CAMERA_PERMISSION_NAME_FRAGMENT;
 319       break;
 320     case RequestType::kMicStream:
 321       message_id = IDS_MICROPHONE_PERMISSION_NAME_FRAGMENT;
 322       break;
 323     default:
 324       NOTREACHED();
 325       return std::u16string();
 326   }
 327   DCHECK_NE(0, message_id);
 328   return l10n_util::GetStringUTF16(message_id);
 329 }
 330
 331 void PermissionRequest::SetEmbeddedPermissionElementInitiatedForTesting(
 332     bool embedded_permission_element_initiated) {
 333   data_.embedded_permission_element_initiated =
 334       embedded_permission_element_initiated;
 335 }
 336
 337 }  // namespace permissions