chrome/browser/media/extension_media_access_handler.cc

   1 // Copyright 2015 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 "chrome/browser/media/extension_media_access_handler.h"
   6
   7 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
   8 #include "chrome/browser/media/media_stream_capture_indicator.h"
   9 #include "chrome/browser/media/media_stream_device_permissions.h"
  10 #include "chrome/browser/profiles/profile.h"
  11 #include "chrome/common/pref_names.h"
  12 #include "content/public/browser/web_contents.h"
  13 #include "extensions/common/extension.h"
  14 #include "extensions/common/permissions/permissions_data.h"
  15
  16 namespace {
  17
  18 // This is a short-term solution to grant camera and/or microphone access to
  19 // extensions:
  20 // 1. Virtual keyboard extension.
  21 // 2. Flutter gesture recognition extension.
  22 // 3. TODO(smus): Airbender experiment 1.
  23 // 4. TODO(smus): Airbender experiment 2.
  24 // 5. Hotwording component extension.
  25 // 6. XKB input method component extension.
  26 // 7. M17n/T13n/CJK input method component extension.
  27 // Once http://crbug.com/292856 is fixed, remove this whitelist.
  28 bool IsMediaRequestWhitelistedForExtension(
  29     const extensions::Extension* extension) {
  30   return extension->id() == "mppnpdlheglhdfmldimlhpnegondlapf" ||
  31          extension->id() == "jokbpnebhdcladagohdnfgjcpejggllo" ||
  32          extension->id() == "clffjmdilanldobdnedchkdbofoimcgb" ||
  33          extension->id() == "nnckehldicaciogcbchegobnafnjkcne" ||
  34          extension->id() == "nbpagnldghgfoolbancepceaanlmhfmd" ||
  35          extension->id() == "jkghodnilhceideoidjikpgommlajknk" ||
  36          extension->id() == "gjaehgfemfahhmlgpdfknkhdnemmolop";
  37 }
  38
  39 }  // namespace
  40
  41 ExtensionMediaAccessHandler::ExtensionMediaAccessHandler() {
  42 }
  43
  44 ExtensionMediaAccessHandler::~ExtensionMediaAccessHandler() {
  45 }
  46
  47 bool ExtensionMediaAccessHandler::SupportsStreamType(
  48     const content::MediaStreamType type,
  49     const extensions::Extension* extension) {
  50   return extension && (extension->is_platform_app() ||
  51                        IsMediaRequestWhitelistedForExtension(extension)) &&
  52          (type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
  53           type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
  54 }
  55
  56 bool ExtensionMediaAccessHandler::CheckMediaAccessPermission(
  57     content::WebContents* web_contents,
  58     const GURL& security_origin,
  59     content::MediaStreamType type,
  60     const extensions::Extension* extension) {
  61   return extension->permissions_data()->HasAPIPermission(
  62       type == content::MEDIA_DEVICE_AUDIO_CAPTURE
  63           ? extensions::APIPermission::kAudioCapture
  64           : extensions::APIPermission::kVideoCapture);
  65 }
  66
  67 void ExtensionMediaAccessHandler::HandleRequest(
  68     content::WebContents* web_contents,
  69     const content::MediaStreamRequest& request,
  70     const content::MediaResponseCallback& callback,
  71     const extensions::Extension* extension) {
  72   // TODO(vrk): This code is largely duplicated in
  73   // MediaStreamDevicesController::Accept(). Move this code into a shared method
  74   // between the two classes.
  75
  76   Profile* profile =
  77       Profile::FromBrowserContext(web_contents->GetBrowserContext());
  78
  79   bool audio_allowed =
  80       request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE &&
  81       extension->permissions_data()->HasAPIPermission(
  82           extensions::APIPermission::kAudioCapture) &&
  83       GetDevicePolicy(profile, extension->url(), prefs::kAudioCaptureAllowed,
  84                       prefs::kAudioCaptureAllowedUrls) != ALWAYS_DENY;
  85   bool video_allowed =
  86       request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
  87       extension->permissions_data()->HasAPIPermission(
  88           extensions::APIPermission::kVideoCapture) &&
  89       GetDevicePolicy(profile, extension->url(), prefs::kVideoCaptureAllowed,
  90                       prefs::kVideoCaptureAllowedUrls) != ALWAYS_DENY;
  91
  92   bool get_default_audio_device = audio_allowed;
  93   bool get_default_video_device = video_allowed;
  94
  95   content::MediaStreamDevices devices;
  96
  97   // Set an initial error result. If neither audio or video is allowed, we'll
  98   // never try to get any device below but will just create |ui| and return an
  99   // empty list with "invalid state" result. If at least one is allowed, we'll
 100   // try to get device(s), and if failure, we want to return "no hardware"
 101   // result.
 102   // TODO(grunell): The invalid state result should be changed to a new denied
 103   // result + a dcheck to ensure at least one of audio or video types is
 104   // capture.
 105   content::MediaStreamRequestResult result =
 106       (audio_allowed || video_allowed) ? content::MEDIA_DEVICE_NO_HARDWARE
 107                                        : content::MEDIA_DEVICE_INVALID_STATE;
 108
 109   // Get the exact audio or video device if an id is specified.
 110   // We only set any error result here and before running the callback change
 111   // it to OK if we have any device.
 112   if (audio_allowed && !request.requested_audio_device_id.empty()) {
 113     const content::MediaStreamDevice* audio_device =
 114         MediaCaptureDevicesDispatcher::GetInstance()->GetRequestedAudioDevice(
 115             request.requested_audio_device_id);
 116     if (audio_device) {
 117       devices.push_back(*audio_device);
 118       get_default_audio_device = false;
 119     }
 120   }
 121   if (video_allowed && !request.requested_video_device_id.empty()) {
 122     const content::MediaStreamDevice* video_device =
 123         MediaCaptureDevicesDispatcher::GetInstance()->GetRequestedVideoDevice(
 124             request.requested_video_device_id);
 125     if (video_device) {
 126       devices.push_back(*video_device);
 127       get_default_video_device = false;
 128     }
 129   }
 130
 131   // If either or both audio and video devices were requested but not
 132   // specified by id, get the default devices.
 133   if (get_default_audio_device || get_default_video_device) {
 134     MediaCaptureDevicesDispatcher::GetInstance()->GetDefaultDevicesForProfile(
 135         profile, get_default_audio_device, get_default_video_device, &devices);
 136   }
 137
 138   scoped_ptr<content::MediaStreamUI> ui;
 139   if (!devices.empty()) {
 140     result = content::MEDIA_DEVICE_OK;
 141     ui = MediaCaptureDevicesDispatcher::GetInstance()
 142              ->GetMediaStreamCaptureIndicator()
 143              ->RegisterMediaStream(web_contents, devices);
 144   }
 145
 146   callback.Run(devices, result, ui.Pass());
 147 }