src/chrome/browser/media/media_capture_devices_dispatcher.cc

   1 // Copyright (c) 2012 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/media_capture_devices_dispatcher.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/logging.h"
   9 #include "base/metrics/field_trial.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/scoped_user_pref_update.h"
  12 #include "base/sha1.h"
  13 #include "base/strings/string_number_conversions.h"
  14 #include "base/strings/string_util.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "chrome/browser/content_settings/host_content_settings_map.h"
  17 #include "chrome/browser/media/desktop_streams_registry.h"
  18 #include "chrome/browser/media/media_stream_capture_indicator.h"
  19 #include "chrome/browser/media/media_stream_device_permissions.h"
  20 #include "chrome/browser/media/media_stream_infobar_delegate.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/ui/browser.h"
  23 #include "chrome/browser/ui/browser_finder.h"
  24 #include "chrome/browser/ui/browser_window.h"
  25 #include "chrome/browser/ui/screen_capture_notification_ui.h"
  26 #include "chrome/browser/ui/simple_message_box.h"
  27 #include "chrome/browser/ui/website_settings/permission_bubble_manager.h"
  28 #include "chrome/common/chrome_switches.h"
  29 #include "chrome/common/chrome_version_info.h"
  30 #include "chrome/common/pref_names.h"
  31 #include "chrome/grit/generated_resources.h"
  32 #include "components/content_settings/core/browser/content_settings_provider.h"
  33 #include "components/pref_registry/pref_registry_syncable.h"
  34 #include "content/public/browser/browser_thread.h"
  35 #include "content/public/browser/desktop_media_id.h"
  36 #include "content/public/browser/media_capture_devices.h"
  37 #include "content/public/browser/notification_service.h"
  38 #include "content/public/browser/notification_source.h"
  39 #include "content/public/browser/notification_types.h"
  40 #include "content/public/browser/render_frame_host.h"
  41 #include "content/public/browser/render_process_host.h"
  42 #include "content/public/browser/web_contents.h"
  43 #include "content/public/common/media_stream_request.h"
  44 #include "extensions/common/constants.h"
  45 #include "extensions/common/extension.h"
  46 #include "extensions/common/permissions/permissions_data.h"
  47 #include "media/audio/audio_manager_base.h"
  48 #include "media/base/media_switches.h"
  49 #include "net/base/net_util.h"
  50 #include "third_party/webrtc/modules/desktop_capture/desktop_capture_types.h"
  51 #include "ui/base/l10n/l10n_util.h"
  52
  53 #if defined(OS_CHROMEOS)
  54 #include "ash/shell.h"
  55 #endif  // defined(OS_CHROMEOS)
  56
  57
  58 #if defined(ENABLE_EXTENSIONS)
  59 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
  60 #include "chrome/browser/extensions/extension_service.h"
  61 #include "extensions/browser/app_window/app_window.h"
  62 #include "extensions/browser/app_window/app_window_registry.h"
  63 #include "extensions/browser/extension_system.h"
  64 #endif
  65
  66 using content::BrowserThread;
  67 using content::MediaCaptureDevices;
  68 using content::MediaStreamDevices;
  69
  70 namespace {
  71
  72 // A finch experiment to enable the permission bubble for media requests only.
  73 bool MediaStreamPermissionBubbleExperimentEnabled() {
  74   const std::string group =
  75       base::FieldTrialList::FindFullName("MediaStreamPermissionBubble");
  76   if (group == "enabled")
  77     return true;
  78
  79   return false;
  80 }
  81
  82 // Finds a device in |devices| that has |device_id|, or NULL if not found.
  83 const content::MediaStreamDevice* FindDeviceWithId(
  84     const content::MediaStreamDevices& devices,
  85     const std::string& device_id) {
  86   content::MediaStreamDevices::const_iterator iter = devices.begin();
  87   for (; iter != devices.end(); ++iter) {
  88     if (iter->id == device_id) {
  89       return &(*iter);
  90     }
  91   }
  92   return NULL;
  93 }
  94
  95 // This is a short-term solution to grant camera and/or microphone access to
  96 // extensions:
  97 // 1. Virtual keyboard extension.
  98 // 2. Google Voice Search Hotword extension.
  99 // 3. Flutter gesture recognition extension.
 100 // 4. TODO(smus): Airbender experiment 1.
 101 // 5. TODO(smus): Airbender experiment 2.
 102 // 6. Hotwording component extension.
 103 // Once http://crbug.com/292856 is fixed, remove this whitelist.
 104 bool IsMediaRequestWhitelistedForExtension(
 105     const extensions::Extension* extension) {
 106   return extension->id() == "mppnpdlheglhdfmldimlhpnegondlapf" ||
 107       extension->id() == "bepbmhgboaologfdajaanbcjmnhjmhfn" ||
 108       extension->id() == "jokbpnebhdcladagohdnfgjcpejggllo" ||
 109       extension->id() == "clffjmdilanldobdnedchkdbofoimcgb" ||
 110       extension->id() == "nnckehldicaciogcbchegobnafnjkcne" ||
 111       extension->id() == "nbpagnldghgfoolbancepceaanlmhfmd";
 112 }
 113
 114 bool IsBuiltInExtension(const GURL& origin) {
 115   return
 116       // Feedback Extension.
 117       origin.spec() == "chrome-extension://gfdkimpbcpahaombhbimeihdjnejgicl/";
 118 }
 119
 120 // Returns true of the security origin is associated with casting.
 121 bool IsOriginForCasting(const GURL& origin) {
 122   // Whitelisted tab casting extensions.
 123   return
 124       // Dev
 125       origin.spec() == "chrome-extension://enhhojjnijigcajfphajepfemndkmdlo/" ||
 126       // Canary
 127       origin.spec() == "chrome-extension://hfaagokkkhdbgiakmmlclaapfelnkoah/" ||
 128       // Beta (internal)
 129       origin.spec() == "chrome-extension://fmfcbgogabcbclcofgocippekhfcmgfj/" ||
 130       // Google Cast Beta
 131       origin.spec() == "chrome-extension://dliochdbjfkdbacpmhlcpmleaejidimm/" ||
 132       // Google Cast Stable
 133       origin.spec() == "chrome-extension://boadgeojelhgndaghljhdicfkmllpafd/";
 134 }
 135
 136 // Helper to get title of the calling application shown in the screen capture
 137 // notification.
 138 base::string16 GetApplicationTitle(content::WebContents* web_contents,
 139                                    const extensions::Extension* extension) {
 140   // Use extension name as title for extensions and host/origin for drive-by
 141   // web.
 142   std::string title;
 143   if (extension) {
 144     title = extension->name();
 145   } else {
 146     GURL url = web_contents->GetURL();
 147     title = url.SchemeIsSecure() ? net::GetHostAndOptionalPort(url)
 148                                  : url.GetOrigin().spec();
 149   }
 150   return base::UTF8ToUTF16(title);
 151 }
 152
 153 // Helper to get list of media stream devices for desktop capture in |devices|.
 154 // Registers to display notification if |display_notification| is true.
 155 // Returns an instance of MediaStreamUI to be passed to content layer.
 156 scoped_ptr<content::MediaStreamUI> GetDevicesForDesktopCapture(
 157     content::MediaStreamDevices& devices,
 158     content::DesktopMediaID media_id,
 159     bool capture_audio,
 160     bool display_notification,
 161     const base::string16& application_title,
 162     const base::string16& registered_extension_name) {
 163   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 164   scoped_ptr<content::MediaStreamUI> ui;
 165
 166   // Add selected desktop source to the list.
 167   devices.push_back(content::MediaStreamDevice(
 168       content::MEDIA_DESKTOP_VIDEO_CAPTURE, media_id.ToString(), "Screen"));
 169   if (capture_audio) {
 170     // Use the special loopback device ID for system audio capture.
 171     devices.push_back(content::MediaStreamDevice(
 172         content::MEDIA_LOOPBACK_AUDIO_CAPTURE,
 173         media::AudioManagerBase::kLoopbackInputDeviceId, "System Audio"));
 174   }
 175
 176   // If required, register to display the notification for stream capture.
 177   if (display_notification) {
 178     if (application_title == registered_extension_name) {
 179       ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
 180           IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT,
 181           application_title));
 182     } else {
 183       ui = ScreenCaptureNotificationUI::Create(l10n_util::GetStringFUTF16(
 184           IDS_MEDIA_SCREEN_CAPTURE_NOTIFICATION_TEXT_DELEGATED,
 185           registered_extension_name,
 186           application_title));
 187     }
 188   }
 189
 190   return ui.Pass();
 191 }
 192
 193 #if !defined(OS_ANDROID)
 194 // Find browser or app window from a given |web_contents|.
 195 gfx::NativeWindow FindParentWindowForWebContents(
 196     content::WebContents* web_contents) {
 197   Browser* browser = chrome::FindBrowserWithWebContents(web_contents);
 198   if (browser && browser->window())
 199     return browser->window()->GetNativeWindow();
 200
 201   const extensions::AppWindowRegistry::AppWindowList& window_list =
 202       extensions::AppWindowRegistry::Get(
 203           web_contents->GetBrowserContext())->app_windows();
 204   for (extensions::AppWindowRegistry::AppWindowList::const_iterator iter =
 205            window_list.begin();
 206        iter != window_list.end(); ++iter) {
 207     if ((*iter)->web_contents() == web_contents)
 208       return (*iter)->GetNativeWindow();
 209   }
 210
 211   return NULL;
 212 }
 213 #endif
 214
 215 const extensions::Extension* GetExtensionForOrigin(
 216     Profile* profile,
 217     const GURL& security_origin) {
 218 #if defined(ENABLE_EXTENSIONS)
 219   if (!security_origin.SchemeIs(extensions::kExtensionScheme))
 220     return NULL;
 221
 222   ExtensionService* extensions_service =
 223       extensions::ExtensionSystem::Get(profile)->extension_service();
 224   const extensions::Extension* extension =
 225       extensions_service->extensions()->GetByID(security_origin.host());
 226   DCHECK(extension);
 227   return extension;
 228 #else
 229   return NULL;
 230 #endif
 231 }
 232
 233 }  // namespace
 234
 235 MediaCaptureDevicesDispatcher::PendingAccessRequest::PendingAccessRequest(
 236     const content::MediaStreamRequest& request,
 237     const content::MediaResponseCallback& callback)
 238     : request(request),
 239       callback(callback) {
 240 }
 241
 242 MediaCaptureDevicesDispatcher::PendingAccessRequest::~PendingAccessRequest() {}
 243
 244 MediaCaptureDevicesDispatcher* MediaCaptureDevicesDispatcher::GetInstance() {
 245   return Singleton<MediaCaptureDevicesDispatcher>::get();
 246 }
 247
 248 MediaCaptureDevicesDispatcher::MediaCaptureDevicesDispatcher()
 249     : is_device_enumeration_disabled_(false),
 250       media_stream_capture_indicator_(new MediaStreamCaptureIndicator()) {
 251   // MediaCaptureDevicesDispatcher is a singleton. It should be created on
 252   // UI thread. Otherwise, it will not receive
 253   // content::NOTIFICATION_WEB_CONTENTS_DESTROYED, and that will result in
 254   // possible use after free.
 255   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 256   notifications_registrar_.Add(
 257       this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
 258       content::NotificationService::AllSources());
 259
 260   // AVFoundation is used for video/audio device monitoring and video capture in
 261   // Mac. Experimentally, connect it in Dev, Canary and Unknown (developer
 262   // builds).
 263 #if defined(OS_MACOSX)
 264   chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
 265   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kForceQTKit)) {
 266     if (channel == chrome::VersionInfo::CHANNEL_DEV ||
 267         channel == chrome::VersionInfo::CHANNEL_CANARY ||
 268         channel == chrome::VersionInfo::CHANNEL_UNKNOWN) {
 269       CommandLine::ForCurrentProcess()->AppendSwitch(
 270           switches::kEnableAVFoundation);
 271     }
 272   }
 273 #endif
 274 }
 275
 276 MediaCaptureDevicesDispatcher::~MediaCaptureDevicesDispatcher() {}
 277
 278 void MediaCaptureDevicesDispatcher::RegisterProfilePrefs(
 279     user_prefs::PrefRegistrySyncable* registry) {
 280   registry->RegisterStringPref(
 281       prefs::kDefaultAudioCaptureDevice,
 282       std::string(),
 283       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 284   registry->RegisterStringPref(
 285       prefs::kDefaultVideoCaptureDevice,
 286       std::string(),
 287       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 288 }
 289
 290 void MediaCaptureDevicesDispatcher::AddObserver(Observer* observer) {
 291   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 292   if (!observers_.HasObserver(observer))
 293     observers_.AddObserver(observer);
 294 }
 295
 296 void MediaCaptureDevicesDispatcher::RemoveObserver(Observer* observer) {
 297   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 298   observers_.RemoveObserver(observer);
 299 }
 300
 301 const MediaStreamDevices&
 302 MediaCaptureDevicesDispatcher::GetAudioCaptureDevices() {
 303   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 304   if (is_device_enumeration_disabled_ || !test_audio_devices_.empty())
 305     return test_audio_devices_;
 306
 307   return MediaCaptureDevices::GetInstance()->GetAudioCaptureDevices();
 308 }
 309
 310 const MediaStreamDevices&
 311 MediaCaptureDevicesDispatcher::GetVideoCaptureDevices() {
 312   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 313   if (is_device_enumeration_disabled_ || !test_video_devices_.empty())
 314     return test_video_devices_;
 315
 316   return MediaCaptureDevices::GetInstance()->GetVideoCaptureDevices();
 317 }
 318
 319 void MediaCaptureDevicesDispatcher::Observe(
 320     int type,
 321     const content::NotificationSource& source,
 322     const content::NotificationDetails& details) {
 323   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 324   if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
 325     content::WebContents* web_contents =
 326         content::Source<content::WebContents>(source).ptr();
 327     pending_requests_.erase(web_contents);
 328   }
 329 }
 330
 331 void MediaCaptureDevicesDispatcher::ProcessMediaAccessRequest(
 332     content::WebContents* web_contents,
 333     const content::MediaStreamRequest& request,
 334     const content::MediaResponseCallback& callback,
 335     const extensions::Extension* extension) {
 336   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 337
 338   if (request.video_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE ||
 339       request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE) {
 340     ProcessDesktopCaptureAccessRequest(
 341         web_contents, request, callback, extension);
 342   } else if (request.video_type == content::MEDIA_TAB_VIDEO_CAPTURE ||
 343              request.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE) {
 344     ProcessTabCaptureAccessRequest(
 345         web_contents, request, callback, extension);
 346   } else if (extension && (extension->is_platform_app() ||
 347                            IsMediaRequestWhitelistedForExtension(extension))) {
 348     // For extensions access is approved based on extension permissions.
 349     ProcessMediaAccessRequestFromPlatformAppOrExtension(
 350         web_contents, request, callback, extension);
 351   } else {
 352     ProcessRegularMediaAccessRequest(web_contents, request, callback);
 353   }
 354 }
 355
 356 bool MediaCaptureDevicesDispatcher::CheckMediaAccessPermission(
 357     content::BrowserContext* browser_context,
 358     const GURL& security_origin,
 359     content::MediaStreamType type) {
 360   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 361   DCHECK(type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
 362          type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
 363
 364   Profile* profile = Profile::FromBrowserContext(browser_context);
 365   const extensions::Extension* extension =
 366       GetExtensionForOrigin(profile, security_origin);
 367
 368   if (extension && (extension->is_platform_app() ||
 369                     IsMediaRequestWhitelistedForExtension(extension))) {
 370     return extension->permissions_data()->HasAPIPermission(
 371         type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 372             ? extensions::APIPermission::kAudioCapture
 373             : extensions::APIPermission::kVideoCapture);
 374   }
 375
 376   if (CheckAllowAllMediaStreamContentForOrigin(profile, security_origin))
 377     return true;
 378
 379   const char* policy_name = type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 380                                 ? prefs::kAudioCaptureAllowed
 381                                 : prefs::kVideoCaptureAllowed;
 382   const char* list_policy_name = type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 383                                      ? prefs::kAudioCaptureAllowedUrls
 384                                      : prefs::kVideoCaptureAllowedUrls;
 385   if (GetDevicePolicy(
 386           profile, security_origin, policy_name, list_policy_name) ==
 387       ALWAYS_ALLOW) {
 388     return true;
 389   }
 390
 391   // There's no secondary URL for these content types, hence duplicating
 392   // |security_origin|.
 393   if (profile->GetHostContentSettingsMap()->GetContentSetting(
 394           security_origin,
 395           security_origin,
 396           type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 397               ? CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC
 398               : CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
 399           NO_RESOURCE_IDENTIFIER) == CONTENT_SETTING_ALLOW) {
 400     return true;
 401   }
 402
 403   return false;
 404 }
 405
 406 bool MediaCaptureDevicesDispatcher::CheckMediaAccessPermission(
 407     content::WebContents* web_contents,
 408     const GURL& security_origin,
 409     content::MediaStreamType type) {
 410   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 411   DCHECK(type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
 412          type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
 413
 414   Profile* profile =
 415       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 416
 417   if (CheckAllowAllMediaStreamContentForOrigin(profile, security_origin))
 418     return true;
 419
 420   const char* policy_name = type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 421                                 ? prefs::kAudioCaptureAllowed
 422                                 : prefs::kVideoCaptureAllowed;
 423   const char* list_policy_name = type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 424                                      ? prefs::kAudioCaptureAllowedUrls
 425                                      : prefs::kVideoCaptureAllowedUrls;
 426   if (GetDevicePolicy(
 427           profile, security_origin, policy_name, list_policy_name) ==
 428       ALWAYS_ALLOW) {
 429     return true;
 430   }
 431
 432   // There's no secondary URL for these content types, hence duplicating
 433   // |security_origin|.
 434   if (profile->GetHostContentSettingsMap()->GetContentSetting(
 435           security_origin,
 436           security_origin,
 437           type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 438               ? CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC
 439               : CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
 440           NO_RESOURCE_IDENTIFIER) == CONTENT_SETTING_ALLOW) {
 441     return true;
 442   }
 443
 444   return false;
 445 }
 446
 447 #if defined(ENABLE_EXTENSIONS)
 448 bool MediaCaptureDevicesDispatcher::CheckMediaAccessPermission(
 449     content::WebContents* web_contents,
 450     const GURL& security_origin,
 451     content::MediaStreamType type,
 452     const extensions::Extension* extension) {
 453   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 454   DCHECK(type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
 455          type == content::MEDIA_DEVICE_VIDEO_CAPTURE);
 456
 457   if (extension->is_platform_app() ||
 458       IsMediaRequestWhitelistedForExtension(extension)) {
 459     return extension->permissions_data()->HasAPIPermission(
 460         type == content::MEDIA_DEVICE_AUDIO_CAPTURE
 461             ? extensions::APIPermission::kAudioCapture
 462             : extensions::APIPermission::kVideoCapture);
 463   }
 464
 465   return CheckMediaAccessPermission(web_contents, security_origin, type);
 466 }
 467 #endif
 468
 469 void MediaCaptureDevicesDispatcher::ProcessDesktopCaptureAccessRequest(
 470     content::WebContents* web_contents,
 471     const content::MediaStreamRequest& request,
 472     const content::MediaResponseCallback& callback,
 473     const extensions::Extension* extension) {
 474   content::MediaStreamDevices devices;
 475   scoped_ptr<content::MediaStreamUI> ui;
 476
 477   if (request.video_type != content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
 478     callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
 479     return;
 480   }
 481
 482   // If the device id wasn't specified then this is a screen capture request
 483   // (i.e. chooseDesktopMedia() API wasn't used to generate device id).
 484   if (request.requested_video_device_id.empty()) {
 485     ProcessScreenCaptureAccessRequest(
 486         web_contents, request, callback, extension);
 487     return;
 488   }
 489
 490   // The extension name that the stream is registered with.
 491   std::string original_extension_name;
 492   // Resolve DesktopMediaID for the specified device id.
 493   content::DesktopMediaID media_id;
 494   // TODO(miu): Replace "main RenderFrame" IDs with the request's actual
 495   // RenderFrame IDs once the desktop capture extension API implementation is
 496   // fixed.  http://crbug.com/304341
 497   content::WebContents* const web_contents_for_stream =
 498       content::WebContents::FromRenderFrameHost(
 499           content::RenderFrameHost::FromID(request.render_process_id,
 500                                            request.render_frame_id));
 501   content::RenderFrameHost* const main_frame = web_contents_for_stream ?
 502       web_contents_for_stream->GetMainFrame() : NULL;
 503   if (main_frame) {
 504     media_id = GetDesktopStreamsRegistry()->RequestMediaForStreamId(
 505         request.requested_video_device_id,
 506         main_frame->GetProcess()->GetID(),
 507         main_frame->GetRoutingID(),
 508         request.security_origin,
 509         &original_extension_name);
 510   }
 511
 512   // Received invalid device id.
 513   if (media_id.type == content::DesktopMediaID::TYPE_NONE) {
 514     callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
 515     return;
 516   }
 517
 518   bool loopback_audio_supported = false;
 519 #if defined(USE_CRAS) || defined(OS_WIN)
 520   // Currently loopback audio capture is supported only on Windows and ChromeOS.
 521   loopback_audio_supported = true;
 522 #endif
 523
 524   // Audio is only supported for screen capture streams.
 525   bool capture_audio =
 526       (media_id.type == content::DesktopMediaID::TYPE_SCREEN &&
 527        request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
 528        loopback_audio_supported);
 529
 530   ui = GetDevicesForDesktopCapture(
 531       devices, media_id, capture_audio, true,
 532       GetApplicationTitle(web_contents, extension),
 533       base::UTF8ToUTF16(original_extension_name));
 534
 535   callback.Run(devices, content::MEDIA_DEVICE_OK, ui.Pass());
 536 }
 537
 538 void MediaCaptureDevicesDispatcher::ProcessScreenCaptureAccessRequest(
 539     content::WebContents* web_contents,
 540     const content::MediaStreamRequest& request,
 541     const content::MediaResponseCallback& callback,
 542     const extensions::Extension* extension) {
 543   content::MediaStreamDevices devices;
 544   scoped_ptr<content::MediaStreamUI> ui;
 545
 546   DCHECK_EQ(request.video_type, content::MEDIA_DESKTOP_VIDEO_CAPTURE);
 547
 548   bool loopback_audio_supported = false;
 549 #if defined(USE_CRAS) || defined(OS_WIN)
 550   // Currently loopback audio capture is supported only on Windows and ChromeOS.
 551   loopback_audio_supported = true;
 552 #endif
 553
 554   const bool component_extension =
 555       extension && extension->location() == extensions::Manifest::COMPONENT;
 556
 557   const bool screen_capture_enabled =
 558       CommandLine::ForCurrentProcess()->HasSwitch(
 559           switches::kEnableUserMediaScreenCapturing) ||
 560       IsOriginForCasting(request.security_origin) ||
 561       IsBuiltInExtension(request.security_origin);
 562
 563   const bool origin_is_secure =
 564       request.security_origin.SchemeIsSecure() ||
 565       request.security_origin.SchemeIs(extensions::kExtensionScheme) ||
 566       CommandLine::ForCurrentProcess()->HasSwitch(
 567           switches::kAllowHttpScreenCapture);
 568
 569   // If basic conditions (screen capturing is enabled and origin is secure)
 570   // aren't fulfilled, we'll use "invalid state" as result. Otherwise, we set
 571   // it after checking permission.
 572   // TODO(grunell): It would be good to change this result for something else,
 573   // probably a new one.
 574   content::MediaStreamRequestResult result =
 575       content::MEDIA_DEVICE_INVALID_STATE;
 576
 577   // Approve request only when the following conditions are met:
 578   //  1. Screen capturing is enabled via command line switch or white-listed for
 579   //     the given origin.
 580   //  2. Request comes from a page with a secure origin or from an extension.
 581   if (screen_capture_enabled && origin_is_secure) {
 582     // Get title of the calling application prior to showing the message box.
 583     // chrome::ShowMessageBox() starts a nested message loop which may allow
 584     // |web_contents| to be destroyed on the UI thread before the message box
 585     // is closed. See http://crbug.com/326690.
 586     base::string16 application_title =
 587         GetApplicationTitle(web_contents, extension);
 588 #if !defined(OS_ANDROID)
 589     gfx::NativeWindow parent_window =
 590         FindParentWindowForWebContents(web_contents);
 591 #else
 592     gfx::NativeWindow parent_window = NULL;
 593 #endif
 594     web_contents = NULL;
 595
 596     // For component extensions, bypass message box.
 597     bool user_approved = false;
 598     if (!component_extension) {
 599       base::string16 application_name = base::UTF8ToUTF16(
 600           extension ? extension->name() : request.security_origin.spec());
 601       base::string16 confirmation_text = l10n_util::GetStringFUTF16(
 602           request.audio_type == content::MEDIA_NO_SERVICE ?
 603               IDS_MEDIA_SCREEN_CAPTURE_CONFIRMATION_TEXT :
 604               IDS_MEDIA_SCREEN_AND_AUDIO_CAPTURE_CONFIRMATION_TEXT,
 605           application_name);
 606       chrome::MessageBoxResult result = chrome::ShowMessageBox(
 607           parent_window,
 608           l10n_util::GetStringFUTF16(
 609               IDS_MEDIA_SCREEN_CAPTURE_CONFIRMATION_TITLE, application_name),
 610           confirmation_text,
 611           chrome::MESSAGE_BOX_TYPE_QUESTION);
 612       user_approved = (result == chrome::MESSAGE_BOX_RESULT_YES);
 613     }
 614
 615     if (user_approved || component_extension) {
 616       content::DesktopMediaID screen_id;
 617 #if defined(OS_CHROMEOS)
 618       screen_id = content::DesktopMediaID::RegisterAuraWindow(
 619           ash::Shell::GetInstance()->GetPrimaryRootWindow());
 620 #else  // defined(OS_CHROMEOS)
 621       screen_id =
 622           content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN,
 623                                   webrtc::kFullDesktopScreenId);
 624 #endif  // !defined(OS_CHROMEOS)
 625
 626       bool capture_audio =
 627           (request.audio_type == content::MEDIA_LOOPBACK_AUDIO_CAPTURE &&
 628            loopback_audio_supported);
 629
 630       // Unless we're being invoked from a component extension, register to
 631       // display the notification for stream capture.
 632       bool display_notification = !component_extension;
 633
 634       ui = GetDevicesForDesktopCapture(devices, screen_id, capture_audio,
 635                                        display_notification, application_title,
 636                                        application_title);
 637       DCHECK(!devices.empty());
 638     }
 639
 640     // The only case when devices can be empty is if the user has denied
 641     // permission.
 642     result = devices.empty() ? content::MEDIA_DEVICE_PERMISSION_DENIED
 643                              : content::MEDIA_DEVICE_OK;
 644   }
 645
 646   callback.Run(devices, result, ui.Pass());
 647 }
 648
 649 void MediaCaptureDevicesDispatcher::ProcessTabCaptureAccessRequest(
 650     content::WebContents* web_contents,
 651     const content::MediaStreamRequest& request,
 652     const content::MediaResponseCallback& callback,
 653     const extensions::Extension* extension) {
 654   content::MediaStreamDevices devices;
 655   scoped_ptr<content::MediaStreamUI> ui;
 656
 657 #if defined(ENABLE_EXTENSIONS) && !defined(USE_ATHENA)
 658   Profile* profile =
 659       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 660   extensions::TabCaptureRegistry* tab_capture_registry =
 661       extensions::TabCaptureRegistry::Get(profile);
 662   if (!tab_capture_registry) {
 663     NOTREACHED();
 664     callback.Run(devices, content::MEDIA_DEVICE_INVALID_STATE, ui.Pass());
 665     return;
 666   }
 667   const bool tab_capture_allowed = tab_capture_registry->VerifyRequest(
 668       request.render_process_id, request.render_frame_id, extension->id());
 669
 670   if (request.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE &&
 671       tab_capture_allowed &&
 672       extension->permissions_data()->HasAPIPermission(
 673           extensions::APIPermission::kTabCapture)) {
 674     devices.push_back(content::MediaStreamDevice(
 675         content::MEDIA_TAB_AUDIO_CAPTURE, std::string(), std::string()));
 676   }
 677
 678   if (request.video_type == content::MEDIA_TAB_VIDEO_CAPTURE &&
 679       tab_capture_allowed &&
 680       extension->permissions_data()->HasAPIPermission(
 681           extensions::APIPermission::kTabCapture)) {
 682     devices.push_back(content::MediaStreamDevice(
 683         content::MEDIA_TAB_VIDEO_CAPTURE, std::string(), std::string()));
 684   }
 685
 686   if (!devices.empty()) {
 687     ui = media_stream_capture_indicator_->RegisterMediaStream(
 688         web_contents, devices);
 689   }
 690   callback.Run(
 691     devices,
 692     devices.empty() ? content::MEDIA_DEVICE_INVALID_STATE :
 693                       content::MEDIA_DEVICE_OK,
 694     ui.Pass());
 695 #else  // defined(ENABLE_EXTENSIONS)
 696   callback.Run(devices, content::MEDIA_DEVICE_TAB_CAPTURE_FAILURE, ui.Pass());
 697 #endif  // defined(ENABLE_EXTENSIONS)
 698 }
 699
 700 void MediaCaptureDevicesDispatcher::
 701     ProcessMediaAccessRequestFromPlatformAppOrExtension(
 702         content::WebContents* web_contents,
 703         const content::MediaStreamRequest& request,
 704         const content::MediaResponseCallback& callback,
 705         const extensions::Extension* extension) {
 706   // TODO(vrk): This code is largely duplicated in
 707   // MediaStreamDevicesController::Accept(). Move this code into a shared method
 708   // between the two classes.
 709
 710   Profile* profile =
 711       Profile::FromBrowserContext(web_contents->GetBrowserContext());
 712
 713   bool audio_allowed =
 714       request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE &&
 715       extension->permissions_data()->HasAPIPermission(
 716           extensions::APIPermission::kAudioCapture) &&
 717       GetDevicePolicy(profile, extension->url(),
 718                       prefs::kAudioCaptureAllowed,
 719                       prefs::kAudioCaptureAllowedUrls) != ALWAYS_DENY;
 720   bool video_allowed =
 721       request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
 722       extension->permissions_data()->HasAPIPermission(
 723           extensions::APIPermission::kVideoCapture) &&
 724       GetDevicePolicy(profile, extension->url(),
 725                       prefs::kVideoCaptureAllowed,
 726                       prefs::kVideoCaptureAllowedUrls) != ALWAYS_DENY;
 727
 728   bool get_default_audio_device = audio_allowed;
 729   bool get_default_video_device = video_allowed;
 730
 731   content::MediaStreamDevices devices;
 732
 733   // Set an initial error result. If neither audio or video is allowed, we'll
 734   // never try to get any device below but will just create |ui| and return an
 735   // empty list with "invalid state" result. If at least one is allowed, we'll
 736   // try to get device(s), and if failure, we want to return "no hardware"
 737   // result.
 738   // TODO(grunell): The invalid state result should be changed to a new denied
 739   // result + a dcheck to ensure at least one of audio or video types is
 740   // capture.
 741   content::MediaStreamRequestResult result =
 742       (audio_allowed || video_allowed) ? content::MEDIA_DEVICE_NO_HARDWARE
 743                                        : content::MEDIA_DEVICE_INVALID_STATE;
 744
 745   // Get the exact audio or video device if an id is specified.
 746   // We only set any error result here and before running the callback change
 747   // it to OK if we have any device.
 748   if (audio_allowed && !request.requested_audio_device_id.empty()) {
 749     const content::MediaStreamDevice* audio_device =
 750         GetRequestedAudioDevice(request.requested_audio_device_id);
 751     if (audio_device) {
 752       devices.push_back(*audio_device);
 753       get_default_audio_device = false;
 754     }
 755   }
 756   if (video_allowed && !request.requested_video_device_id.empty()) {
 757     const content::MediaStreamDevice* video_device =
 758         GetRequestedVideoDevice(request.requested_video_device_id);
 759     if (video_device) {
 760       devices.push_back(*video_device);
 761       get_default_video_device = false;
 762     }
 763   }
 764
 765   // If either or both audio and video devices were requested but not
 766   // specified by id, get the default devices.
 767   if (get_default_audio_device || get_default_video_device) {
 768     GetDefaultDevicesForProfile(profile,
 769                                 get_default_audio_device,
 770                                 get_default_video_device,
 771                                 &devices);
 772   }
 773
 774   scoped_ptr<content::MediaStreamUI> ui;
 775   if (!devices.empty()) {
 776     result = content::MEDIA_DEVICE_OK;
 777     ui = media_stream_capture_indicator_->RegisterMediaStream(
 778         web_contents, devices);
 779   }
 780
 781   callback.Run(devices, result, ui.Pass());
 782 }
 783
 784 void MediaCaptureDevicesDispatcher::ProcessRegularMediaAccessRequest(
 785     content::WebContents* web_contents,
 786     const content::MediaStreamRequest& request,
 787     const content::MediaResponseCallback& callback) {
 788   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 789
 790   RequestsQueue& queue = pending_requests_[web_contents];
 791   queue.push_back(PendingAccessRequest(request, callback));
 792
 793   // If this is the only request then show the infobar.
 794   if (queue.size() == 1)
 795     ProcessQueuedAccessRequest(web_contents);
 796 }
 797
 798 void MediaCaptureDevicesDispatcher::ProcessQueuedAccessRequest(
 799     content::WebContents* web_contents) {
 800   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 801
 802   std::map<content::WebContents*, RequestsQueue>::iterator it =
 803       pending_requests_.find(web_contents);
 804
 805   if (it == pending_requests_.end() || it->second.empty()) {
 806     // Don't do anything if the tab was closed.
 807     return;
 808   }
 809
 810   DCHECK(!it->second.empty());
 811
 812   if (PermissionBubbleManager::Enabled() ||
 813       MediaStreamPermissionBubbleExperimentEnabled()) {
 814     scoped_ptr<MediaStreamDevicesController> controller(
 815         new MediaStreamDevicesController(web_contents,
 816             it->second.front().request,
 817             base::Bind(&MediaCaptureDevicesDispatcher::OnAccessRequestResponse,
 818                        base::Unretained(this), web_contents)));
 819     if (controller->DismissInfoBarAndTakeActionOnSettings())
 820       return;
 821     PermissionBubbleManager* bubble_manager =
 822         PermissionBubbleManager::FromWebContents(web_contents);
 823     if (bubble_manager)
 824       bubble_manager->AddRequest(controller.release());
 825     return;
 826   }
 827
 828   // TODO(gbillock): delete this block and the MediaStreamInfoBarDelegate
 829   // when we've transitioned to bubbles. (crbug/337458)
 830   MediaStreamInfoBarDelegate::Create(
 831       web_contents, it->second.front().request,
 832       base::Bind(&MediaCaptureDevicesDispatcher::OnAccessRequestResponse,
 833                  base::Unretained(this), web_contents));
 834 }
 835
 836 void MediaCaptureDevicesDispatcher::OnAccessRequestResponse(
 837     content::WebContents* web_contents,
 838     const content::MediaStreamDevices& devices,
 839     content::MediaStreamRequestResult result,
 840     scoped_ptr<content::MediaStreamUI> ui) {
 841   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 842
 843   std::map<content::WebContents*, RequestsQueue>::iterator it =
 844       pending_requests_.find(web_contents);
 845   if (it == pending_requests_.end()) {
 846     // WebContents has been destroyed. Don't need to do anything.
 847     return;
 848   }
 849
 850   RequestsQueue& queue(it->second);
 851   if (queue.empty())
 852     return;
 853
 854   content::MediaResponseCallback callback = queue.front().callback;
 855   queue.pop_front();
 856
 857   if (!queue.empty()) {
 858     // Post a task to process next queued request. It has to be done
 859     // asynchronously to make sure that calling infobar is not destroyed until
 860     // after this function returns.
 861     BrowserThread::PostTask(
 862         BrowserThread::UI, FROM_HERE,
 863         base::Bind(&MediaCaptureDevicesDispatcher::ProcessQueuedAccessRequest,
 864                    base::Unretained(this), web_contents));
 865   }
 866
 867   callback.Run(devices, result, ui.Pass());
 868 }
 869
 870 void MediaCaptureDevicesDispatcher::GetDefaultDevicesForProfile(
 871     Profile* profile,
 872     bool audio,
 873     bool video,
 874     content::MediaStreamDevices* devices) {
 875   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 876   DCHECK(audio || video);
 877
 878   PrefService* prefs = profile->GetPrefs();
 879   std::string default_device;
 880   if (audio) {
 881     default_device = prefs->GetString(prefs::kDefaultAudioCaptureDevice);
 882     const content::MediaStreamDevice* device =
 883         GetRequestedAudioDevice(default_device);
 884     if (!device)
 885       device = GetFirstAvailableAudioDevice();
 886     if (device)
 887       devices->push_back(*device);
 888   }
 889
 890   if (video) {
 891     default_device = prefs->GetString(prefs::kDefaultVideoCaptureDevice);
 892     const content::MediaStreamDevice* device =
 893         GetRequestedVideoDevice(default_device);
 894     if (!device)
 895       device = GetFirstAvailableVideoDevice();
 896     if (device)
 897       devices->push_back(*device);
 898   }
 899 }
 900
 901 const content::MediaStreamDevice*
 902 MediaCaptureDevicesDispatcher::GetRequestedAudioDevice(
 903     const std::string& requested_audio_device_id) {
 904   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 905   const content::MediaStreamDevices& audio_devices = GetAudioCaptureDevices();
 906   const content::MediaStreamDevice* const device =
 907       FindDeviceWithId(audio_devices, requested_audio_device_id);
 908   return device;
 909 }
 910
 911 const content::MediaStreamDevice*
 912 MediaCaptureDevicesDispatcher::GetFirstAvailableAudioDevice() {
 913   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 914   const content::MediaStreamDevices& audio_devices = GetAudioCaptureDevices();
 915   if (audio_devices.empty())
 916     return NULL;
 917   return &(*audio_devices.begin());
 918 }
 919
 920 const content::MediaStreamDevice*
 921 MediaCaptureDevicesDispatcher::GetRequestedVideoDevice(
 922     const std::string& requested_video_device_id) {
 923   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 924   const content::MediaStreamDevices& video_devices = GetVideoCaptureDevices();
 925   const content::MediaStreamDevice* const device =
 926       FindDeviceWithId(video_devices, requested_video_device_id);
 927   return device;
 928 }
 929
 930 const content::MediaStreamDevice*
 931 MediaCaptureDevicesDispatcher::GetFirstAvailableVideoDevice() {
 932   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 933   const content::MediaStreamDevices& video_devices = GetVideoCaptureDevices();
 934   if (video_devices.empty())
 935     return NULL;
 936   return &(*video_devices.begin());
 937 }
 938
 939 void MediaCaptureDevicesDispatcher::DisableDeviceEnumerationForTesting() {
 940   is_device_enumeration_disabled_ = true;
 941 }
 942
 943 scoped_refptr<MediaStreamCaptureIndicator>
 944 MediaCaptureDevicesDispatcher::GetMediaStreamCaptureIndicator() {
 945   return media_stream_capture_indicator_;
 946 }
 947
 948 DesktopStreamsRegistry*
 949 MediaCaptureDevicesDispatcher::GetDesktopStreamsRegistry() {
 950   if (!desktop_streams_registry_)
 951     desktop_streams_registry_.reset(new DesktopStreamsRegistry());
 952   return desktop_streams_registry_.get();
 953 }
 954
 955 void MediaCaptureDevicesDispatcher::OnAudioCaptureDevicesChanged() {
 956   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 957   BrowserThread::PostTask(
 958       BrowserThread::UI, FROM_HERE,
 959       base::Bind(
 960           &MediaCaptureDevicesDispatcher::NotifyAudioDevicesChangedOnUIThread,
 961           base::Unretained(this)));
 962 }
 963
 964 void MediaCaptureDevicesDispatcher::OnVideoCaptureDevicesChanged() {
 965   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 966   BrowserThread::PostTask(
 967       BrowserThread::UI, FROM_HERE,
 968       base::Bind(
 969           &MediaCaptureDevicesDispatcher::NotifyVideoDevicesChangedOnUIThread,
 970           base::Unretained(this)));
 971 }
 972
 973 void MediaCaptureDevicesDispatcher::OnMediaRequestStateChanged(
 974     int render_process_id,
 975     int render_frame_id,
 976     int page_request_id,
 977     const GURL& security_origin,
 978     content::MediaStreamType stream_type,
 979     content::MediaRequestState state) {
 980   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 981   BrowserThread::PostTask(
 982       BrowserThread::UI, FROM_HERE,
 983       base::Bind(
 984           &MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread,
 985           base::Unretained(this), render_process_id, render_frame_id,
 986           page_request_id, security_origin, stream_type, state));
 987 }
 988
 989 void MediaCaptureDevicesDispatcher::OnCreatingAudioStream(
 990     int render_process_id,
 991     int render_frame_id) {
 992   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 993   BrowserThread::PostTask(
 994       BrowserThread::UI, FROM_HERE,
 995       base::Bind(
 996           &MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread,
 997           base::Unretained(this), render_process_id, render_frame_id));
 998 }
 999
1000 void MediaCaptureDevicesDispatcher::NotifyAudioDevicesChangedOnUIThread() {
1001   MediaStreamDevices devices = GetAudioCaptureDevices();
1002   FOR_EACH_OBSERVER(Observer, observers_,
1003                     OnUpdateAudioDevices(devices));
1004 }
1005
1006 void MediaCaptureDevicesDispatcher::NotifyVideoDevicesChangedOnUIThread() {
1007   MediaStreamDevices devices = GetVideoCaptureDevices();
1008   FOR_EACH_OBSERVER(Observer, observers_,
1009                     OnUpdateVideoDevices(devices));
1010 }
1011
1012 void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
1013     int render_process_id,
1014     int render_frame_id,
1015     int page_request_id,
1016     const GURL& security_origin,
1017     content::MediaStreamType stream_type,
1018     content::MediaRequestState state) {
1019   // Track desktop capture sessions.  Tracking is necessary to avoid unbalanced
1020   // session counts since not all requests will reach MEDIA_REQUEST_STATE_DONE,
1021   // but they will all reach MEDIA_REQUEST_STATE_CLOSING.
1022   if (stream_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE) {
1023     if (state == content::MEDIA_REQUEST_STATE_DONE) {
1024       DesktopCaptureSession session = { render_process_id, render_frame_id,
1025                                         page_request_id };
1026       desktop_capture_sessions_.push_back(session);
1027     } else if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
1028       for (DesktopCaptureSessions::iterator it =
1029                desktop_capture_sessions_.begin();
1030            it != desktop_capture_sessions_.end();
1031            ++it) {
1032         if (it->render_process_id == render_process_id &&
1033             it->render_frame_id == render_frame_id &&
1034             it->page_request_id == page_request_id) {
1035           desktop_capture_sessions_.erase(it);
1036           break;
1037         }
1038       }
1039     }
1040   }
1041
1042   // Cancel the request.
1043   if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
1044     bool found = false;
1045     for (RequestsQueues::iterator rqs_it = pending_requests_.begin();
1046          rqs_it != pending_requests_.end(); ++rqs_it) {
1047       RequestsQueue& queue = rqs_it->second;
1048       for (RequestsQueue::iterator it = queue.begin();
1049            it != queue.end(); ++it) {
1050         if (it->request.render_process_id == render_process_id &&
1051             it->request.render_frame_id == render_frame_id &&
1052             it->request.page_request_id == page_request_id) {
1053           queue.erase(it);
1054           found = true;
1055           break;
1056         }
1057       }
1058       if (found)
1059         break;
1060     }
1061   }
1062
1063 #if defined(OS_CHROMEOS)
1064   if (IsOriginForCasting(security_origin) && IsVideoMediaType(stream_type)) {
1065     // Notify ash that casting state has changed.
1066     if (state == content::MEDIA_REQUEST_STATE_DONE) {
1067       ash::Shell::GetInstance()->OnCastingSessionStartedOrStopped(true);
1068     } else if (state == content::MEDIA_REQUEST_STATE_CLOSING) {
1069       ash::Shell::GetInstance()->OnCastingSessionStartedOrStopped(false);
1070     }
1071   }
1072 #endif
1073
1074   FOR_EACH_OBSERVER(Observer, observers_,
1075                     OnRequestUpdate(render_process_id,
1076                                     render_frame_id,
1077                                     stream_type,
1078                                     state));
1079 }
1080
1081 void MediaCaptureDevicesDispatcher::OnCreatingAudioStreamOnUIThread(
1082     int render_process_id,
1083     int render_frame_id) {
1084   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1085   FOR_EACH_OBSERVER(Observer, observers_,
1086                     OnCreatingAudioStream(render_process_id, render_frame_id));
1087 }
1088
1089 bool MediaCaptureDevicesDispatcher::IsDesktopCaptureInProgress() {
1090   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
1091   return desktop_capture_sessions_.size() > 0;
1092 }
1093
1094 void MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices(
1095     const MediaStreamDevices& devices) {
1096   test_audio_devices_ = devices;
1097 }
1098
1099 void MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices(
1100     const MediaStreamDevices& devices) {
1101   test_video_devices_ = devices;
1102 }