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

content/browser/renderer_host/media/media_stream_ui_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 "content/browser/renderer_host/media/media_stream_ui_controller.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 53 matching lines @@
 
 }  // namespace
 
 // UI request contains all data needed to keep track of requests between the
 // different calls.
 class MediaStreamRequestForUI : public MediaStreamRequest {
  public:
   MediaStreamRequestForUI(int render_pid,
                           int render_vid,
                           const GURL& origin,
-                          const StreamOptions& options)
-      : MediaStreamRequest(render_pid, render_vid, origin),
+                          const StreamOptions& options,
+                          MediaStreamRequestType request_type)
+      : MediaStreamRequest(render_pid, render_vid, origin, request_type),
         wait_for_audio(IsAudioMediaType(options.audio_type)),
         wait_for_video(IsVideoMediaType(options.video_type)),
         posted_task(false) {
     DCHECK(wait_for_audio || wait_for_video);
   }
 
   ~MediaStreamRequestForUI() {}
 
   bool IsRequestReadyForView() const {
     if (wait_for_audio || wait_for_video)
@@ skipping 42 matching lines @@
   DCHECK(requester_);
 }
 
 MediaStreamUIController::~MediaStreamUIController() {
   DCHECK(requests_.empty());
 }
 
 void MediaStreamUIController::MakeUIRequest(
     const std::string& label, int render_process_id, int render_view_id,
     const StreamOptions& request_options,
-    const GURL& security_origin) {
+    const GURL& security_origin, MediaStreamRequestType request_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request.
   if (!requests_.insert(
       std::make_pair(label, new MediaStreamRequestForUI(
           render_process_id, render_view_id, security_origin,
-          request_options))).second) {
+          request_options, request_type))).second) {
     NOTREACHED();
   }
 }
 
 void MediaStreamUIController::CancelUIRequest(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   UIRequests::iterator request_iter = requests_.find(label);
   if (request_iter != requests_.end()) {
     // Proceed the next pending request for the same page.
     scoped_ptr<MediaStreamRequestForUI> request(request_iter->second);
@@ skipping 215 matching lines @@
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamUIController::PostResponse,
                  weak_ptr_factory_.GetWeakPtr(), label, devices_to_use));
 }
 
 }  // namespace content