Force extension media access to obey enterprise policy.

chrome/browser/media/media_capture_devices_dispatcher.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_capture_devices_dispatcher.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/prefs/pref_service.h"
@@ skipping 679 matching lines @@
 void MediaCaptureDevicesDispatcher::
     ProcessMediaAccessRequestFromPlatformAppOrExtension(
         content::WebContents* web_contents,
         const content::MediaStreamRequest& request,
         const content::MediaResponseCallback& callback,
         const extensions::Extension* extension) {
   // TODO(vrk): This code is largely duplicated in
   // MediaStreamDevicesController::Accept(). Move this code into a shared method
   // between the two classes.
 
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+
   bool audio_allowed =
       request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE &&
       extension->permissions_data()->HasAPIPermission(
-          extensions::APIPermission::kAudioCapture);
+          extensions::APIPermission::kAudioCapture) &&
+      GetDevicePolicy(profile, extension->url(),
+                      prefs::kAudioCaptureAllowed,
+                      prefs::kAudioCaptureAllowedUrls) != ALWAYS_DENY;
   bool video_allowed =
       request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
       extension->permissions_data()->HasAPIPermission(
-          extensions::APIPermission::kVideoCapture);
+          extensions::APIPermission::kVideoCapture) &&
+      GetDevicePolicy(profile, extension->url(),
+                      prefs::kVideoCaptureAllowed,
+                      prefs::kVideoCaptureAllowedUrls) != ALWAYS_DENY;
 
   bool get_default_audio_device = audio_allowed;
   bool get_default_video_device = video_allowed;
 
   content::MediaStreamDevices devices;
 
   // Get the exact audio or video device if an id is specified.
   if (audio_allowed && !request.requested_audio_device_id.empty()) {
     const content::MediaStreamDevice* audio_device =
         GetRequestedAudioDevice(request.requested_audio_device_id);
     if (audio_device) {
       devices.push_back(*audio_device);
       get_default_audio_device = false;
     }
   }
   if (video_allowed && !request.requested_video_device_id.empty()) {
     const content::MediaStreamDevice* video_device =
         GetRequestedVideoDevice(request.requested_video_device_id);
     if (video_device) {
       devices.push_back(*video_device);
       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 (get_default_audio_device || get_default_video_device) {
-    Profile* profile =
-        Profile::FromBrowserContext(web_contents->GetBrowserContext());
     GetDefaultDevicesForProfile(profile,
                                 get_default_audio_device,
                                 get_default_video_device,
                                 &devices);
   }
 
   scoped_ptr<content::MediaStreamUI> ui;
   if (!devices.empty()) {
     ui = media_stream_capture_indicator_->RegisterMediaStream(
         web_contents, devices);
@@ skipping 317 matching lines @@
 
 void MediaCaptureDevicesDispatcher::SetTestAudioCaptureDevices(
     const MediaStreamDevices& devices) {
   test_audio_devices_ = devices;
 }
 
 void MediaCaptureDevicesDispatcher::SetTestVideoCaptureDevices(
     const MediaStreamDevices& devices) {
   test_video_devices_ = devices;
 }