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

content/browser/renderer_host/media/media_stream_manager.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_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 46 matching lines @@
 // Helper to verify if a media stream type is part of options or not.
 static bool Requested(const StreamOptions& options,
                       MediaStreamType stream_type) {
   return (options.audio_type == stream_type ||
           options.video_type == stream_type);
 }
 
 // TODO(xians): Merge DeviceRequest with MediaStreamRequest.
 class MediaStreamManager::DeviceRequest {
  public:
-  enum RequestType {
-    DEVICE_ACCESS = 0,
-    GENERATE_STREAM,
-    ENUMERATE_DEVICES,
-    OPEN_DEVICE
-  };
-
   DeviceRequest()
       : requester(NULL),
-        type(GENERATE_STREAM),
+        type(MEDIA_GENERATE_STREAM),
         render_process_id(-1),
         render_view_id(-1),
         state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED) {
   }
 
   DeviceRequest(MediaStreamRequester* requester,
                 const StreamOptions& request_options,
-                RequestType request_type,
+                MediaStreamRequestType request_type,
                 int render_process_id,
                 int render_view_id,
                 const GURL& request_security_origin)
       : requester(requester),
         options(request_options),
         type(request_type),
         render_process_id(render_process_id),
         render_view_id(render_view_id),
         security_origin(request_security_origin),
         state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED) {
@@ skipping 27 matching lines @@
         MediaStreamDevice(
             stream_type, device_id, device_id), new_state);
   }
 
   MediaRequestState state(MediaStreamType stream_type) const {
     return state_[stream_type];
   }
 
   MediaStreamRequester* requester;  // Can be NULL.
   StreamOptions options;
-  RequestType type;
+  MediaStreamRequestType type;
   int render_process_id;
   int render_view_id;
   GURL security_origin;
   std::string requested_device_id;
   StreamDeviceInfoArray devices;
 
   // Callback to the requester which audio/video devices have been selected.
   // It can be null if the requester has no interest to know the result.
   // Currently it is only used by |DEVICE_ACCESS| type.
   MediaRequestResponseCallback callback;
@@ skipping 52 matching lines @@
 std::string MediaStreamManager::MakeMediaAccessRequest(
     int render_process_id,
     int render_view_id,
     const StreamOptions& options,
     const GURL& security_origin,
     const MediaRequestResponseCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Create a new request based on options.
   DeviceRequest* request = new DeviceRequest(NULL,
                                              options,
-                                             DeviceRequest::DEVICE_ACCESS,
+                                             MEDIA_DEVICE_ACCESS,
                                              render_process_id,
                                              render_view_id,
                                              security_origin);
   const std::string& label = AddRequest(request);
   StartEnumeration(request);
 
   request->callback = callback;
 
   PostRequestToUI(label);
 
   return label;
 }
 
 std::string MediaStreamManager::GenerateStream(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
     const StreamOptions& options,
     const GURL& security_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeDeviceForMediaStream)) {
     UseFakeDevice();
   }
 
   // Create a new request based on options.
   DeviceRequest* request = new DeviceRequest(requester, options,
-                                             DeviceRequest::GENERATE_STREAM,
+                                             MEDIA_GENERATE_STREAM,
                                              render_process_id,
                                              render_view_id,
                                              security_origin);
   const std::string& label = AddRequest(request);
   StartEnumeration(request);
 
   // Get user confirmation to use capture devices.
   PostRequestToUI(label);
 
   return label;
@@ skipping 18 matching lines @@
       (options.audio_type != MEDIA_TAB_AUDIO_CAPTURE &&
        options.audio_type != MEDIA_NO_SERVICE) ||
       (options.video_type != MEDIA_TAB_VIDEO_CAPTURE &&
        options.video_type != MEDIA_NO_SERVICE)) {
     LOG(ERROR) << "Invalid request or used tab capture outside extension API.";
     return std::string();
   }
 
   // Create a new request based on options.
   DeviceRequest* request = new DeviceRequest(requester, options,
-                                             DeviceRequest::GENERATE_STREAM,
+                                             MEDIA_GENERATE_STREAM,
                                              target_render_process_id,
                                              target_render_view_id,
                                              security_origin);
   const std::string& label = AddRequest(request);
   request->requested_device_id = device_id;
 
   // Get user confirmation to use the capture device.
   PostRequestToUI(label);
 
   // TODO(miu): We should ask the device manager whether a device with id
@@ skipping 54 matching lines @@
       StopGeneratedStream(label);
     }
   }
 }
 
 void MediaStreamManager::StopGeneratedStream(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Find the request and close all open devices for the request.
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
-    if (it->second->type == DeviceRequest::ENUMERATE_DEVICES) {
+    if (it->second->type == MEDIA_ENUMERATE_DEVICES) {
       StopEnumerateDevices(label);
       return;
     }
 
     scoped_ptr<DeviceRequest> request(it->second);
     requests_.erase(it);
     for (StreamDeviceInfoArray::const_iterator device_it =
              request->devices.begin();
          device_it != request->devices.end(); ++device_it) {
       GetDeviceManager(device_it->stream_type)->Close(device_it->session_id);
     }
-    if (request->type == DeviceRequest::GENERATE_STREAM &&
+    if (request->type == MEDIA_GENERATE_STREAM &&
         RequestDone(*request)) {
       // Notify observers that this device is being closed.
       for (int i = MEDIA_NO_SERVICE + 1; i != NUM_MEDIA_TYPES; ++i) {
         if (request->state(static_cast<MediaStreamType>(i)) !=
             MEDIA_REQUEST_STATE_NOT_REQUESTED) {
           request->SetState(static_cast<MediaStreamType>(i),
                             MEDIA_REQUEST_STATE_CLOSING);
         }
       }
       NotifyDevicesClosed(*request);
@@ skipping 33 matching lines @@
   } else if (type == MEDIA_DEVICE_VIDEO_CAPTURE) {
     options.video_type = type;
     cache = &video_enumeration_cache_;
   } else {
     NOTREACHED();
     return std::string();
   }
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              options,
-                                             DeviceRequest::ENUMERATE_DEVICES,
+                                             MEDIA_ENUMERATE_DEVICES,
                                              render_process_id,
                                              render_view_id,
                                              security_origin);
   const std::string& label = AddRequest(request);
 
   if (cache->valid) {
     // Cached device list of this type exists. Just send it out.
     request->SetState(type, MEDIA_REQUEST_STATE_REQUESTED);
 
     // Need to post a task since the requester won't have label till
     // this function returns.
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&MediaStreamManager::SendCachedDeviceList,
                    base::Unretained(this), cache, label));
   } else {
     StartEnumeration(request);
   }
 
   return label;
 }
 
 void MediaStreamManager::StopEnumerateDevices(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
-    DCHECK_EQ(it->second->type, DeviceRequest::ENUMERATE_DEVICES);
+    DCHECK_EQ(it->second->type, MEDIA_ENUMERATE_DEVICES);
     // Delete the DeviceRequest.
     scoped_ptr<DeviceRequest> request(it->second);
     requests_.erase(it);
   }
 }
 
 std::string MediaStreamManager::OpenDevice(
     MediaStreamRequester* requester,
     int render_process_id,
     int render_view_id,
@@ skipping 10 matching lines @@
     options.audio_type = type;
   } else if (IsVideoMediaType(type)) {
     options.video_type = type;
   } else {
     NOTREACHED();
     return std::string();
   }
 
   DeviceRequest* request = new DeviceRequest(requester,
                                              options,
-                                             DeviceRequest::OPEN_DEVICE,
+                                             MEDIA_OPEN_DEVICE,
                                              render_process_id,
                                              render_view_id,
                                              security_origin);
   request->requested_device_id = device_id;
   const std::string& label = AddRequest(request);
   StartEnumeration(request);
 
+  PostRequestToUI(label);
+
   return label;
 }
 
 void MediaStreamManager::NotifyUIDevicesOpened(
     int render_process_id,
     int render_view_id,
     const MediaStreamDevices& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ui_controller_->NotifyUIIndicatorDevicesOpened(render_process_id,
                                                  render_view_id,
@@ skipping 100 matching lines @@
 }
 
 void MediaStreamManager::PostRequestToUI(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequest* request = requests_[label];
   // Get user confirmation to use capture devices.
   ui_controller_->MakeUIRequest(label,
                                 request->render_process_id,
                                 request->render_view_id,
                                 request->options,
-                                request->security_origin);
+                                request->security_origin,
+                                request->type);
 }
 
 void MediaStreamManager::InitializeDeviceManagersOnIOThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (device_thread_.get())
     return;
 
   device_thread_.reset(new base::Thread("MediaStreamDeviceThread"));
 #if defined(OS_WIN)
   device_thread_->init_com_with_mta(true);
@@ skipping 57 matching lines @@
   }
 
   request->SetState(stream_type, MEDIA_REQUEST_STATE_DONE);
 
   if (!RequestDone(*request)) {
     // This stream_type is done, but not the other type.
     return;
   }
 
   switch (request->type) {
-    case DeviceRequest::OPEN_DEVICE:
+    case MEDIA_OPEN_DEVICE:
       request->requester->DeviceOpened(label, devices->front());
       break;
-    case DeviceRequest::GENERATE_STREAM: {
+    case MEDIA_GENERATE_STREAM: {
       // Partition the array of devices into audio vs video.
       StreamDeviceInfoArray audio_devices, video_devices;
       for (StreamDeviceInfoArray::const_iterator device_it = devices->begin();
            device_it != devices->end(); ++device_it) {
         if (IsAudioMediaType(device_it->stream_type)) {
           audio_devices.push_back(*device_it);
         } else if (IsVideoMediaType(device_it->stream_type)) {
           video_devices.push_back(*device_it);
         } else {
           NOTREACHED();
@@ skipping 39 matching lines @@
   // Publish the result for all requests waiting for device list(s).
   // Find the requests waiting for this device list, store their labels and
   // release the iterator before calling device settings. We might get a call
   // back from device_settings that will need to iterate through devices.
   std::list<std::string> label_list;
   for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end();
        ++it) {
     if (it->second->state(stream_type) ==
         MEDIA_REQUEST_STATE_REQUESTED &&
         Requested(it->second->options, stream_type)) {
-      if (it->second->type != DeviceRequest::ENUMERATE_DEVICES)
+      if (it->second->type != MEDIA_ENUMERATE_DEVICES)
         it->second->SetState(stream_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
       label_list.push_back(it->first);
     }
   }
   for (std::list<std::string>::iterator it = label_list.begin();
        it != label_list.end(); ++it) {
     DeviceRequest* request = requests_[*it];
     switch (request->type) {
-      case DeviceRequest::ENUMERATE_DEVICES:
+      case MEDIA_ENUMERATE_DEVICES:
         if (need_update_clients && request->requester)
           request->requester->DevicesEnumerated(*it, devices);
         break;
-      case DeviceRequest::OPEN_DEVICE:
-        DCHECK(!request->requested_device_id.empty());
-        for (StreamDeviceInfoArray::const_iterator device_it = devices.begin();
-             device_it != devices.end(); ++device_it) {
-          if (request->requested_device_id == device_it->device_id) {
-            StreamDeviceInfo device = *device_it;
-            device.in_use = false;
-            device.session_id =
-                GetDeviceManager(device_it->stream_type)->Open(device);
-            request->SetState(device_it->stream_type,
-                              MEDIA_REQUEST_STATE_OPENING);
-            request->devices.push_back(device);
-            break;
-          }
-        }
-        break;
       default:
         ui_controller_->AddAvailableDevicesToRequest(*it, stream_type,
                                                      devices);
         break;
     }
   }
   label_list.clear();
   --active_enumeration_ref_count_[stream_type];
   DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
 }
@@ skipping 54 matching lines @@
 
 void MediaStreamManager::DevicesAccepted(const std::string& label,
                                          const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!devices.empty());
   DeviceRequests::iterator request_it = requests_.find(label);
   if (request_it == requests_.end()) {
     return;
   }
 
-  if (request_it->second->type == DeviceRequest::DEVICE_ACCESS) {
+  if (request_it->second->type == MEDIA_DEVICE_ACCESS) {
     scoped_ptr<DeviceRequest> request(request_it->second);
     if (!request->callback.is_null()) {
       // Map the devices to MediaStreamDevices.
       MediaStreamDevices selected_devices;
       for (StreamDeviceInfoArray::const_iterator it = devices.begin();
            it != devices.end(); ++it) {
         selected_devices.push_back(MediaStreamDevice(
             it->stream_type, it->device_id, it->name));
       }
 
@@ skipping 50 matching lines @@
   // Erase this request and report an error.
   DeviceRequests::iterator it = requests_.find(label);
   if (it == requests_.end())
     return;
 
   // Notify the users about the request result.
   scoped_ptr<DeviceRequest> request(it->second);
   if (request->requester)
     request->requester->StreamGenerationFailed(label);
 
-  if (request->type == DeviceRequest::DEVICE_ACCESS &&
+  if (request->type == MEDIA_DEVICE_ACCESS &&
       !request->callback.is_null()) {
     request->callback.Run(label, MediaStreamDevices());
   }
 
   requests_.erase(it);
 }
 
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   video_capture_manager()->UseFakeDevice();
@@ skipping 138 matching lines @@
   }
 
   // Always do enumeration even though some enumeration is in progress,
   // because those enumeration commands could be sent before these devices
   // change.
   ++active_enumeration_ref_count_[stream_type];
   GetDeviceManager(stream_type)->EnumerateDevices();
 }
 
 }  // namespace content