Make sure that all OpenDevice requests are scrutinized against the audio and video policies.

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/values.h"
 #include "chrome/browser/content_settings/content_settings_provider.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/extensions/api/tab_capture/tab_capture_registry.h"
@@ skipping 62 matching lines @@
   prefs->RegisterBooleanPref(prefs::kVideoCaptureAllowed,
                              true,
                              PrefService::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kAudioCaptureAllowed,
                              true,
                              PrefService::UNSYNCABLE_PREF);
 }
 
 
 bool MediaStreamDevicesController::DismissInfoBarAndTakeActionOnSettings() {
+  // If this is a no UI check for policies only go straight to accept - policy
+  // check will be done automatically on the way.
+  if (request_.request_type == content::OPEN_DEVICE) {

[no longer working on chromium, 2012/12/10 10:17:56]

thanks, the code is much clearer now since we are sure it is only for
OPEN_DEVICE request.

+    std::string audio, video;
+    if (has_audio_)
+      audio = GetFirstDeviceId(content::MEDIA_DEVICE_AUDIO_CAPTURE);
+    if (has_video_)
+      video = GetFirstDeviceId(content::MEDIA_DEVICE_VIDEO_CAPTURE);
+    Accept(audio, video, false);
+    return true;
+  }
+
   // For tab media requests, we need to make sure the request came from the
   // extension API, so we check the registry here.
   content::MediaStreamDeviceMap::const_iterator tab_video =
       request_.devices.find(content::MEDIA_TAB_VIDEO_CAPTURE);
   content::MediaStreamDeviceMap::const_iterator tab_audio =
       request_.devices.find(content::MEDIA_TAB_AUDIO_CAPTURE);
   if (tab_video != request_.devices.end() ||
       tab_audio != request_.devices.end()) {
     std::string audio_device_id;
     std::string video_device_id;
@@ skipping 38 matching lines @@
   GetAlwaysAllowedDevices(&audio, &video);
   if ((has_audio_ && audio.empty()) || (has_video_ && video.empty())) {
     // If there is no "always allowed" device for the origin, or the device is
     // not available in the device lists, Check the default setting to see if
     // the user has blocked the access to the media device.
     if (IsMediaDeviceBlocked()) {
       Deny();
       return true;
     }
 
-    // Show the infobar.
     return false;
   }
 
   // Dismiss the infobar by selecting the "always allowed" devices.
   Accept(audio, video, false);
   return true;
 }
 
 content::MediaStreamDevices
 MediaStreamDevicesController::GetAudioDevices() const {
@@ skipping 230 matching lines @@
     for (content::MediaStreamDevices::const_iterator device_it =
              it->second.begin();
          device_it != it->second.end(); ++device_it) {
       const content::MediaStreamDevice& candidate = *device_it;
       if (candidate.device_id == device_id)
         return &candidate;
     }
   }
   return NULL;
 }