Make sure we don't open audio or video device if blocked by policy.

chrome/browser/media/media_stream_devices_controller.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/media/media_stream_devices_controller.h"
 
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
@@ skipping 170 matching lines @@
   // Get the default devices for the request.
   content::MediaStreamDevices devices;
   bool audio_allowed = IsDeviceAudioCaptureRequestedAndAllowed();
   bool video_allowed = IsDeviceVideoCaptureRequestedAndAllowed();
   if (audio_allowed || video_allowed) {
     switch (request_.request_type) {
       case content::MEDIA_OPEN_DEVICE: {
         const content::MediaStreamDevice* device = NULL;
         // For open device request pick the desired device or fall back to the
         // first available of the given type.
-        if (request_.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
+        if (audio_allowed &&
+            request_.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE) {
           device = MediaCaptureDevicesDispatcher::GetInstance()->
               GetRequestedAudioDevice(request_.requested_audio_device_id);
           // TODO(wjia): Confirm this is the intended behavior.
           if (!device) {
             device = MediaCaptureDevicesDispatcher::GetInstance()->
                 GetFirstAvailableAudioDevice();
           }
-        } else if (request_.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
+        } else if (video_allowed &&
+            request_.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE) {
           // Pepper API opens only one device at a time.
           device = MediaCaptureDevicesDispatcher::GetInstance()->
               GetRequestedVideoDevice(request_.requested_video_device_id);
           // TODO(wjia): Confirm this is the intended behavior.
           if (!device) {
             device = MediaCaptureDevicesDispatcher::GetInstance()->
                 GetFirstAvailableVideoDevice();
           }
         }
         if (device)
           devices.push_back(*device);
         break;
-      } case content::MEDIA_GENERATE_STREAM: {
-        bool needs_audio_device = audio_allowed;
-        bool needs_video_device = video_allowed;
+      }
+      case content::MEDIA_GENERATE_STREAM: {
+        bool get_default_audio_device = audio_allowed;
+        bool get_default_video_device = video_allowed;
 
         // Get the exact audio or video device if an id is specified.
-        if (!request_.requested_audio_device_id.empty()) {
+        if (audio_allowed && !request_.requested_audio_device_id.empty()) {
           const content::MediaStreamDevice* audio_device =
               MediaCaptureDevicesDispatcher::GetInstance()->
                   GetRequestedAudioDevice(request_.requested_audio_device_id);
           if (audio_device) {
             devices.push_back(*audio_device);
-            needs_audio_device = false;
+            get_default_audio_device = false;
           }
         }
-        if (!request_.requested_video_device_id.empty()) {
+        if (video_allowed && !request_.requested_video_device_id.empty()) {
           const content::MediaStreamDevice* video_device =
               MediaCaptureDevicesDispatcher::GetInstance()->
                   GetRequestedVideoDevice(request_.requested_video_device_id);
           if (video_device) {
             devices.push_back(*video_device);
-            needs_video_device = false;
+            get_default_video_device = false;
           }
         }
 
         // If either or both audio and video devices were requested but not
         // specified by id, get the default devices.
-        if (needs_audio_device || needs_video_device) {
+        if (get_default_audio_device || get_default_video_device) {
           MediaCaptureDevicesDispatcher::GetInstance()->
               GetDefaultDevicesForProfile(profile_,
-                                          needs_audio_device,
-                                          needs_video_device,
+                                          get_default_audio_device,
+                                          get_default_video_device,
                                           &devices);
         }
         break;
-      } case content::MEDIA_DEVICE_ACCESS:
+      }
+      case content::MEDIA_DEVICE_ACCESS: {
         // Get the default devices for the request.
         MediaCaptureDevicesDispatcher::GetInstance()->
             GetDefaultDevicesForProfile(profile_,
                                         audio_allowed,
                                         video_allowed,
                                         &devices);
         break;
-      case content::MEDIA_ENUMERATE_DEVICES:
+      }
+      case content::MEDIA_ENUMERATE_DEVICES: {
         // Do nothing.
         NOTREACHED();
         break;
-    }
+      }
+    }  // switch
 
     // TODO(raymes): We currently set the content permission for non-https
     // websites for Pepper requests as well. This is temporary and should be
     // removed.
     if (update_content_setting) {
       if ((IsSchemeSecure() && !devices.empty()) ||
           request_.request_type == content::MEDIA_OPEN_DEVICE) {
         SetPermission(true);
       }
     }
@@ skipping 235 matching lines @@
       request_permissions_.find(content::MEDIA_DEVICE_AUDIO_CAPTURE);
   return it != request_permissions_.end() && it->second == MEDIA_ALLOWED;
 }
 
 bool MediaStreamDevicesController::IsDeviceVideoCaptureRequestedAndAllowed()
     const {
   MediaStreamTypePermissionMap::const_iterator it =
       request_permissions_.find(content::MEDIA_DEVICE_VIDEO_CAPTURE);
   return it != request_permissions_.end() && it->second == MEDIA_ALLOWED;
 }