support video device enumeration from renderer process.

content/browser/renderer_host/media/media_stream_manager.cc

 // Copyright (c) 2011 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/compiler_specific.h"
@@ skipping 33 matching lines @@
   if (stream_type == kVideoCapture &&
       (options.video_option != StreamOptions::kNoCamera)) {
     return true;
   } else if (stream_type == kAudioCapture && options.audio == true) {
     return true;
   }
   return false;
 }
 
 struct MediaStreamManager::DeviceRequest {
-  DeviceRequest()
-      : requester(NULL),
-        state(kNumMediaStreamTypes, kNotRequested) {
-    options.audio = false;
-    options.video_option = StreamOptions::kNoCamera;
-  }
-  DeviceRequest(MediaStreamRequester* requester,
-                const StreamOptions& request_options)
-      : requester(requester),
-        options(request_options),
-        state(kNumMediaStreamTypes, kNotRequested) {
-    DCHECK(requester);
-  }
-  ~DeviceRequest() {}
-
   enum RequestState {
     kNotRequested = 0,
     kRequested,
     kOpening,
     kDone,
     kError
   };
 
+  enum RequestType {
+    kGenerateStream = 0,
+    kEnumerateDevices,
+    kOpenDevice
+  };
+
+  DeviceRequest()
+      : requester(NULL),
+        state(kNumMediaStreamTypes, kNotRequested),
+        type(kGenerateStream) {
+    options.audio = false;
+    options.video_option = StreamOptions::kNoCamera;
+  }
+
+  DeviceRequest(MediaStreamRequester* requester,
+                const StreamOptions& request_options)
+      : requester(requester),
+        options(request_options),
+        state(kNumMediaStreamTypes, kNotRequested),
+        type(kGenerateStream) {
+    DCHECK(requester);
+  }
+
+  ~DeviceRequest() {}
+
   MediaStreamRequester* requester;
   StreamOptions options;
   std::vector<RequestState> state;
+  RequestType type;
+  std::string requested_device_id;
   StreamDeviceInfoArray audio_devices;
   StreamDeviceInfoArray video_devices;
 };
 
 MediaStreamManager::MediaStreamManager(AudioManager* audio_manager)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           device_settings_(new MediaStreamDeviceSettings(this))),
       enumeration_in_progress_(kNumMediaStreamTypes, false),
       audio_manager_(audio_manager) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 25 matching lines @@
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const StreamOptions& options,
                                         const std::string& security_origin,
                                         std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Create a new request based on options.
   DeviceRequest new_request = DeviceRequest(requester, options);
-  if (Requested(new_request.options, kAudioCapture)) {
-    new_request.state[kAudioCapture] = DeviceRequest::kRequested;
-  }
-  if (Requested(new_request.options, kVideoCapture)) {
-    new_request.state[kVideoCapture] = DeviceRequest::kRequested;
-  }
-
-  // Create a label for this request and verify it is unique.
-  std::string request_label;
-  do {
-    request_label = RandomLabel();
-  } while (requests_.find(request_label) != requests_.end());
-
-  requests_.insert(std::make_pair(request_label, new_request));
-
-  // Get user confirmation to use capture devices.
-  // Need to make an asynchronous call to make sure the |requester| gets the
-  // |label| before it would receive any event.
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&MediaStreamDeviceSettings::RequestCaptureDeviceUsage,
-                 base::Unretained(device_settings_.get()),
-                 request_label, render_process_id,
-                 render_view_id, options,
-                 security_origin));
-
-  (*label) = request_label;
+  StartEnumeration(&new_request, render_process_id, render_view_id,
+                   security_origin, label);
 }
 
 void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequests::iterator it = requests_.begin();
   while (it != requests_.end()) {
     if (it->second.requester == requester && !RequestDone(it->second)) {
       // The request isn't complete, but there might be some devices already
       // opened -> close them.
       DeviceRequest* request = &(it->second);
@@ skipping 35 matching lines @@
     for (StreamDeviceInfoArray::iterator video_it =
          it->second.video_devices.begin();
          video_it != it->second.video_devices.end(); ++video_it) {
       video_capture_manager()->Close(video_it->session_id);
     }
     requests_.erase(it);
     return;
   }
 }
 
+void MediaStreamManager::EnumerateDevices(
+    MediaStreamRequester* requester,
+    int render_process_id,
+    int render_view_id,
+    MediaStreamType type,
+    const std::string& security_origin,
+    std::string* label) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Create a new request.
+  StreamOptions options;
+  if (type == media_stream::kAudioCapture)
+    options.audio = true;
+  else
+    options.video_option = StreamOptions::kFacingUser;
+
+  DeviceRequest new_request = DeviceRequest(requester, options);
+  new_request.type = DeviceRequest::kEnumerateDevices;
+
+  StartEnumeration(&new_request, render_process_id, render_view_id,
+                   security_origin, label);
+}
+
+void MediaStreamManager::OpenDevice(
+    MediaStreamRequester* requester,
+    int render_process_id,
+    int render_view_id,
+    const std::string& device_id,
+    MediaStreamType type,
+    const std::string& security_origin,
+    std::string* label) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  // Create a new request.
+  StreamOptions options;
+  if (type == media_stream::kAudioCapture)
+    options.audio = true;
+  else
+    options.video_option = StreamOptions::kFacingUser;
+
+  DeviceRequest new_request = DeviceRequest(requester, options);
+  new_request.type = DeviceRequest::kOpenDevice;
+  new_request.requested_device_id = device_id;
+
+  StartEnumeration(&new_request, render_process_id, render_view_id,
+                   security_origin, label);
+}
+
+void MediaStreamManager::StartEnumeration(
+    DeviceRequest* new_request,
+    int render_process_id,
+    int render_view_id,
+    const std::string& security_origin,
+    std::string* label) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (Requested(new_request->options, kAudioCapture)) {
+    new_request->state[kAudioCapture] = DeviceRequest::kRequested;
+    if (!enumeration_in_progress_[kAudioCapture]) {
+      enumeration_in_progress_[kAudioCapture] = true;
+      GetDeviceManager(kAudioCapture)->EnumerateDevices();
+    }
+  }
+  if (Requested(new_request->options, kVideoCapture)) {
+    new_request->state[kVideoCapture] = DeviceRequest::kRequested;
+    if (!enumeration_in_progress_[kVideoCapture]) {
+      enumeration_in_progress_[kVideoCapture] = true;
+      GetDeviceManager(kVideoCapture)->EnumerateDevices();
+    }
+  }
+
+  // Create a label for this request and verify it is unique.
+  std::string request_label;
+  do {
+    request_label = RandomLabel();
+  } while (requests_.find(request_label) != requests_.end());
+
+  requests_.insert(std::make_pair(request_label, *new_request));
+
+  // Get user confirmation to use capture devices.
+  // Need to make an asynchronous call to make sure the |requester| gets the
+  // |label| before it would receive any event.
+  if (new_request->type == DeviceRequest::kGenerateStream) {
+    BrowserThread::PostTask(BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&MediaStreamDeviceSettings::RequestCaptureDeviceUsage,
+                   base::Unretained(device_settings_.get()),
+                   request_label, render_process_id,
+                   render_view_id, new_request->options,
+                   security_origin));
+  }
+
+  (*label) = request_label;
+}
+
 void MediaStreamManager::Opened(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // Find the request containing this device and mark it as used.
   DeviceRequest* request = NULL;
   StreamDeviceInfoArray* devices = NULL;
   std::string label;
   for (DeviceRequests::iterator request_it = requests_.begin();
        request_it != requests_.end() && request == NULL; ++request_it) {
@@ skipping 32 matching lines @@
       return;
     }
   }
   request->state[stream_type] = DeviceRequest::kDone;
 
   if (!RequestDone(*request)) {
     // This stream_type is done, but not the other type.
     return;
   }
 
-  request->requester->StreamGenerated(label, request->audio_devices,
-                                      request->video_devices);
+  switch (request->type) {
+    case DeviceRequest::kOpenDevice:
+      request->requester->DeviceOpened(label, (*devices)[0]);
+      break;
+    case DeviceRequest::kGenerateStream:
+      request->requester->StreamGenerated(label, request->audio_devices,
+                                          request->video_devices);
+      break;
+    default:
+      NOTREACHED();
+  }
 }
 
 void MediaStreamManager::Closed(MediaStreamType stream_type,
                                 int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 void MediaStreamManager::DevicesEnumerated(
     MediaStreamType stream_type, const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // 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] == DeviceRequest::kRequested &&
         Requested(it->second.options, stream_type)) {
       label_list.push_back(it->first);
     }
   }
   for (std::list<std::string>::iterator it = label_list.begin();
        it != label_list.end(); ++it) {
-    device_settings_->AvailableDevices(*it, stream_type, devices);
+    DeviceRequest& request = requests_[*it];
+    switch (request.type) {
+      case DeviceRequest::kEnumerateDevices:
+        request.requester->DevicesEnumerated(*it, devices);
+        requests_.erase(*it);
+        break;
+      case DeviceRequest::kOpenDevice:
+        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.state[device_it->stream_type] = DeviceRequest::kOpening;
+            if (stream_type == kAudioCapture)
+              request.audio_devices.push_back(device);
+            else
+              request.video_devices.push_back(device);
+            break;
+          }
+        }
+        break;
+      default:
+        BrowserThread::PostTask(BrowserThread::IO,
+            FROM_HERE,
+            base::Bind(&MediaStreamDeviceSettings::AvailableDevices,
+                       base::Unretained(device_settings_.get()),
+                       *it, stream_type, devices));
+    }
   }
   label_list.clear();
   enumeration_in_progress_[stream_type] = false;
 }
 
 void MediaStreamManager::Error(MediaStreamType stream_type,
                                int capture_session_id,
                                MediaStreamProviderError error) {
   // Find the device for the error call.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 34 matching lines @@
           // 3. Not opened but other devices exists for this request -> remove
           //    device from list, but don't signal an error.
           devices->erase(device_it);
         }
         return;
       }
     }
   }
 }
 
-void MediaStreamManager::GetDevices(const std::string& label,
-                                    MediaStreamType stream_type) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!enumeration_in_progress_[stream_type]) {
-    enumeration_in_progress_[stream_type] = true;
-    GetDeviceManager(stream_type)->EnumerateDevices();
-  }
-}
-
 void MediaStreamManager::DevicesAccepted(const std::string& label,
                                          const StreamDeviceInfoArray& devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DeviceRequests::iterator request_it = requests_.find(label);
   if (request_it != requests_.end()) {
     if (devices.empty()) {
       // No available devices or user didn't accept device usage.
       request_it->second.requester->StreamGenerationFailed(request_it->first);
       requests_.erase(request_it);
       return;
@@ skipping 31 matching lines @@
     }
     return;
   }
 }
 
 void MediaStreamManager::SettingsError(const std::string& label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Erase this request and report an error.
   DeviceRequests::iterator it = requests_.find(label);
   if (it != requests_.end()) {
+    DCHECK_EQ(it->second.type, DeviceRequest::kGenerateStream);
     it->second.requester->StreamGenerationFailed(label);
     requests_.erase(it);
     return;
   }
 }
 
 void MediaStreamManager::UseFakeDevice() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   video_capture_manager()->UseFakeDevice();
   device_settings_->UseFakeUI();
@@ skipping 29 matching lines @@
   if (stream_type == kVideoCapture) {
     return video_capture_manager();
   } else if (stream_type == kAudioCapture) {
     return audio_input_device_manager();
   }
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace media_stream