summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorwjia@chromium.org <wjia@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2012-08-08 18:45:05 +0000
committerwjia@chromium.org <wjia@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>2012-08-08 18:45:05 +0000
commit4ad51a93bc3fd568aa32fe2dc0a1de4ed49817c5 (patch)
treea32d7c0488a3d8c788c37cd6a4ff8baa33a9cd8a
parent6825759582fd94ee046f8c2e1dada868e127c7e3 (diff)
downloadchromium_src-4ad51a93bc3fd568aa32fe2dc0a1de4ed49817c5.zip
chromium_src-4ad51a93bc3fd568aa32fe2dc0a1de4ed49817c5.tar.gz
chromium_src-4ad51a93bc3fd568aa32fe2dc0a1de4ed49817c5.tar.bz2
Revert 150491 - refactor EnumerateDevices to make it a persistent request.
After the requester calls EnumerateDevices, it should expect new device list as initial response and whenever devices are changed. A new method StopEnumerateDevices is also added to allow the request to stop device enumeration. It also includes corresponding change in Pepper since EnumerateDevices contract is changed (http://codereview.chromium.org/10837064/). This patch keeps current Pepper API, while using the new API of EnumerateDevices from MediaStreamDispatcher. Pepper calls StopEnumerateDevices when it receives the first enumerated result. A new Pepper API will be created in a separate patch to make EnumerateDevices persistent. BUG=137799 Review URL: https://chromiumcodereview.appspot.com/10830063 BUG=141367 TBR=wjia@chromium.org Review URL: https://chromiumcodereview.appspot.com/10834232 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@150593 0039d316-1c4b-4281-b951-d872f2087c98
-rw-r--r--content/browser/renderer_host/media/media_stream_dispatcher_host.cc4
-rw-r--r--content/browser/renderer_host/media/media_stream_manager.cc297
-rw-r--r--content/browser/renderer_host/media/media_stream_manager.h49
-rw-r--r--content/common/media/media_stream_messages.h3
-rw-r--r--content/common/media/media_stream_options.cc10
-rw-r--r--content/common/media/media_stream_options.h2
-rw-r--r--content/renderer/media/media_stream_dispatcher.cc138
-rw-r--r--content/renderer/media/media_stream_dispatcher.h49
-rw-r--r--content/renderer/media/media_stream_dispatcher_unittest.cc37
-rw-r--r--content/renderer/pepper/pepper_device_enumeration_event_handler.cc3
-rw-r--r--content/renderer/pepper/pepper_plugin_delegate_impl.cc13
-rw-r--r--content/renderer/pepper/pepper_plugin_delegate_impl.h1
-rw-r--r--webkit/plugins/ppapi/mock_plugin_delegate.cc3
-rw-r--r--webkit/plugins/ppapi/mock_plugin_delegate.h1
-rw-r--r--webkit/plugins/ppapi/plugin_delegate.h3
-rw-r--r--webkit/plugins/ppapi/ppb_audio_input_impl.cc4
-rw-r--r--webkit/plugins/ppapi/ppb_video_capture_impl.cc4
17 files changed, 113 insertions, 508 deletions
diff --git a/content/browser/renderer_host/media/media_stream_dispatcher_host.cc b/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
index 1f6eb43..fb817b9 100644
--- a/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
+++ b/content/browser/renderer_host/media/media_stream_dispatcher_host.cc
@@ -100,9 +100,10 @@ void MediaStreamDispatcherHost::DevicesEnumerated(
StreamMap::iterator it = streams_.find(label);
DCHECK(it != streams_.end());
StreamRequest request = it->second;
+ streams_.erase(it);
Send(new MediaStreamMsg_DevicesEnumerated(
- request.render_view_id, request.page_request_id, label, devices));
+ request.render_view_id, request.page_request_id, devices));
}
void MediaStreamDispatcherHost::DeviceOpened(
@@ -195,6 +196,7 @@ void MediaStreamDispatcherHost::OnStopGeneratedStream(
<< ", {label = " << label << "})";
StreamMap::iterator it = streams_.find(label);
+ DCHECK(it != streams_.end());
GetManager()->StopGeneratedStream(label);
streams_.erase(it);
}
diff --git a/content/browser/renderer_host/media/media_stream_manager.cc b/content/browser/renderer_host/media/media_stream_manager.cc
index b41b244..1329b97 100644
--- a/content/browser/renderer_host/media/media_stream_manager.cc
+++ b/content/browser/renderer_host/media/media_stream_manager.cc
@@ -47,10 +47,14 @@ static std::string RandomLabel() {
// Helper to verify if a media stream type is part of options or not.
static bool Requested(const StreamOptions& options,
MediaStreamType stream_type) {
- return (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE &&
- options.video) ||
- (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE &&
- options.audio);
+ if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE &&
+ options.video) {
+ return true;
+ } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE &&
+ options.audio) {
+ return true;
+ }
+ return false;
}
DeviceThread::DeviceThread(const char* name)
@@ -74,24 +78,24 @@ void DeviceThread::CleanUp() {
// TODO(xians): Merge DeviceRequest with MediaStreamRequest.
struct MediaStreamManager::DeviceRequest {
enum RequestState {
- STATE_NOT_REQUESTED = 0,
- STATE_REQUESTED,
- STATE_PENDING_APPROVAL,
- STATE_OPENING,
- STATE_DONE,
- STATE_ERROR
+ kNotRequested = 0,
+ kRequested,
+ kPendingApproval,
+ kOpening,
+ kDone,
+ kError
};
enum RequestType {
- GENERATE_STREAM = 0,
- ENUMERATE_DEVICES,
- OPEN_DEVICE
+ kGenerateStream = 0,
+ kEnumerateDevices,
+ kOpenDevice
};
DeviceRequest()
: requester(NULL),
- state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, STATE_NOT_REQUESTED),
- type(GENERATE_STREAM),
+ state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, kNotRequested),
+ type(kGenerateStream),
render_process_id(-1),
render_view_id(-1) {
options.audio = false;
@@ -105,8 +109,8 @@ struct MediaStreamManager::DeviceRequest {
const GURL& request_security_origin)
: requester(requester),
options(request_options),
- state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, STATE_NOT_REQUESTED),
- type(GENERATE_STREAM),
+ state(content::NUM_MEDIA_STREAM_DEVICE_TYPES, kNotRequested),
+ type(kGenerateStream),
render_process_id(render_process_id),
render_view_id(render_view_id),
security_origin(request_security_origin) {
@@ -127,13 +131,6 @@ struct MediaStreamManager::DeviceRequest {
StreamDeviceInfoArray video_devices;
};
-MediaStreamManager::EnumerationCache::EnumerationCache()
- : valid(false) {
-}
-
-MediaStreamManager::EnumerationCache::~EnumerationCache() {
-}
-
MediaStreamManager::MediaStreamManager(
AudioInputDeviceManager* audio_input_device_manager,
VideoCaptureManager* video_capture_manager)
@@ -141,10 +138,8 @@ MediaStreamManager::MediaStreamManager(
device_settings_(new MediaStreamDeviceSettings(this))),
audio_input_device_manager_(audio_input_device_manager),
video_capture_manager_(video_capture_manager),
- monitoring_started_(false),
+ enumeration_in_progress_(content::NUM_MEDIA_STREAM_DEVICE_TYPES, false),
io_loop_(NULL) {
- memset(active_enumeration_ref_count_, 0,
- sizeof(active_enumeration_ref_count_));
}
MediaStreamManager::~MediaStreamManager() {
@@ -181,17 +176,6 @@ void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
render_view_id,
security_origin);
StartEnumeration(&new_request, label);
-
- // 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()),
- *label, render_process_id,
- render_view_id, options,
- security_origin));
}
void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
@@ -203,7 +187,7 @@ void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
// opened -> close them.
DeviceRequest* request = &(it->second);
if (request->state[content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE] ==
- DeviceRequest::STATE_OPENING) {
+ DeviceRequest::kOpening) {
for (StreamDeviceInfoArray::iterator it =
request->audio_devices.begin(); it != request->audio_devices.end();
++it) {
@@ -211,7 +195,7 @@ void MediaStreamManager::CancelRequests(MediaStreamRequester* requester) {
}
}
if (request->state[content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE] ==
- DeviceRequest::STATE_OPENING) {
+ DeviceRequest::kOpening) {
for (StreamDeviceInfoArray::iterator it =
request->video_devices.begin(); it != request->video_devices.end();
++it) {
@@ -234,7 +218,7 @@ void MediaStreamManager::CancelGenerateStream(const std::string& label) {
if (!RequestDone(it->second)) {
DeviceRequest* request = &(it->second);
if (request->state[content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE] ==
- DeviceRequest::STATE_OPENING) {
+ DeviceRequest::kOpening) {
for (StreamDeviceInfoArray::iterator it =
request->audio_devices.begin(); it != request->audio_devices.end();
++it) {
@@ -242,7 +226,7 @@ void MediaStreamManager::CancelGenerateStream(const std::string& label) {
}
}
if (request->state[content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE] ==
- DeviceRequest::STATE_OPENING) {
+ DeviceRequest::kOpening) {
for (StreamDeviceInfoArray::iterator it =
request->video_devices.begin(); it != request->video_devices.end();
++it) {
@@ -262,10 +246,6 @@ void MediaStreamManager::StopGeneratedStream(const std::string& label) {
// 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) {
- StopEnumerateDevices(label);
- return;
- }
for (StreamDeviceInfoArray::iterator audio_it =
it->second.audio_devices.begin();
audio_it != it->second.audio_devices.end(); ++audio_it) {
@@ -276,10 +256,11 @@ void MediaStreamManager::StopGeneratedStream(const std::string& label) {
video_it != it->second.video_devices.end(); ++video_it) {
video_capture_manager()->Close(video_it->session_id);
}
- if (it->second.type == DeviceRequest::GENERATE_STREAM) {
+ if (it->second.type == DeviceRequest::kGenerateStream) {
NotifyObserverDevicesClosed(&(it->second));
}
requests_.erase(it);
+ return;
}
}
@@ -291,53 +272,21 @@ void MediaStreamManager::EnumerateDevices(
const GURL& security_origin,
std::string* label) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- DCHECK(type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE ||
- type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
// Create a new request.
StreamOptions options;
- EnumerationCache* cache = NULL;
- if (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) {
+ if (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)
options.audio = true;
- cache = &audio_enumeration_cache_;
- } else {
+ else
options.video = true;
- cache = &video_enumeration_cache_;
- }
DeviceRequest new_request(requester, options,
render_process_id,
render_view_id,
security_origin);
- new_request.type = DeviceRequest::ENUMERATE_DEVICES;
-
- if (cache->valid) {
- // Cached device list of this type exists. Just send it out.
- new_request.state[type] = DeviceRequest::STATE_REQUESTED;
- AddRequest(&new_request, label);
- // 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(&new_request, label);
- StartMonitoring();
- }
-}
-
-void MediaStreamManager::StopEnumerateDevices(const std::string& label) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+ new_request.type = DeviceRequest::kEnumerateDevices;
- DeviceRequests::iterator it = requests_.find(label);
- if (it != requests_.end()) {
- DCHECK_EQ(it->second.type, DeviceRequest::ENUMERATE_DEVICES);
- requests_.erase(it);
- if (!HasEnumerationRequest()) {
- StopMonitoring();
- }
- }
+ StartEnumeration(&new_request, label);
}
void MediaStreamManager::OpenDevice(
@@ -361,47 +310,12 @@ void MediaStreamManager::OpenDevice(
render_process_id,
render_view_id,
security_origin);
- new_request.type = DeviceRequest::OPEN_DEVICE;
+ new_request.type = DeviceRequest::kOpenDevice;
new_request.requested_device_id = device_id;
StartEnumeration(&new_request, label);
}
-void MediaStreamManager::SendCachedDeviceList(
- EnumerationCache* cache,
- const std::string& label) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- if (cache->valid) {
- DeviceRequests::iterator it = requests_.find(label);
- if (it != requests_.end()) {
- it->second.requester->DevicesEnumerated(label, cache->devices);
- }
- }
-}
-
-void MediaStreamManager::StartMonitoring() {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- if (!monitoring_started_) {
- monitoring_started_ = true;
- base::SystemMonitor::Get()->AddDevicesChangedObserver(this);
- }
-}
-
-void MediaStreamManager::StopMonitoring() {
- DCHECK_EQ(MessageLoop::current(), io_loop_);
- if (monitoring_started_ && !HasEnumerationRequest()) {
- base::SystemMonitor::Get()->RemoveDevicesChangedObserver(this);
- monitoring_started_ = false;
- ClearEnumerationCache(&audio_enumeration_cache_);
- ClearEnumerationCache(&video_enumeration_cache_);
- }
-}
-
-void MediaStreamManager::ClearEnumerationCache(EnumerationCache* cache) {
- DCHECK_EQ(MessageLoop::current(), io_loop_);
- cache->valid = false;
-}
-
void MediaStreamManager::StartEnumeration(
DeviceRequest* new_request,
std::string* label) {
@@ -409,31 +323,21 @@ void MediaStreamManager::StartEnumeration(
MediaStreamType stream_type = content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE;
if (Requested(new_request->options, stream_type)) {
- new_request->state[stream_type] = DeviceRequest::STATE_REQUESTED;
- DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
- if (!active_enumeration_ref_count_[stream_type]) {
- ++active_enumeration_ref_count_[stream_type];
+ new_request->state[stream_type] = DeviceRequest::kRequested;
+ if (!enumeration_in_progress_[stream_type]) {
+ enumeration_in_progress_[stream_type] = true;
GetDeviceManager(stream_type)->EnumerateDevices();
}
}
stream_type = content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE;
if (Requested(new_request->options, stream_type)) {
- new_request->state[stream_type] = DeviceRequest::STATE_REQUESTED;
- DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
- if (!active_enumeration_ref_count_[stream_type]) {
- ++active_enumeration_ref_count_[stream_type];
+ new_request->state[stream_type] = DeviceRequest::kRequested;
+ if (!enumeration_in_progress_[stream_type]) {
+ enumeration_in_progress_[stream_type] = true;
GetDeviceManager(stream_type)->EnumerateDevices();
}
}
- AddRequest(new_request, label);
-}
-
-void MediaStreamManager::AddRequest(
- DeviceRequest* new_request,
- std::string* label) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
// Create a label for this request and verify it is unique.
std::string request_label;
do {
@@ -442,6 +346,19 @@ void MediaStreamManager::AddRequest(
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, new_request->render_process_id,
+ new_request->render_view_id, new_request->options,
+ new_request->security_origin));
+ }
+
(*label) = request_label;
}
@@ -497,7 +414,7 @@ void MediaStreamManager::Opened(MediaStreamType stream_type,
return;
}
- DCHECK_NE(request->state[stream_type], DeviceRequest::STATE_REQUESTED);
+ DCHECK_NE(request->state[stream_type], DeviceRequest::kRequested);
// Check if all devices for this stream type are opened. Update the state if
// they are.
@@ -508,7 +425,7 @@ void MediaStreamManager::Opened(MediaStreamType stream_type,
return;
}
}
- request->state[stream_type] = DeviceRequest::STATE_DONE;
+ request->state[stream_type] = DeviceRequest::kDone;
if (!RequestDone(*request)) {
// This stream_type is done, but not the other type.
@@ -516,10 +433,10 @@ void MediaStreamManager::Opened(MediaStreamType stream_type,
}
switch (request->type) {
- case DeviceRequest::OPEN_DEVICE:
+ case DeviceRequest::kOpenDevice:
request->requester->DeviceOpened(label, (*devices)[0]);
break;
- case DeviceRequest::GENERATE_STREAM:
+ case DeviceRequest::kGenerateStream:
request->requester->StreamGenerated(label, request->audio_devices,
request->video_devices);
NotifyObserverDevicesOpened(request);
@@ -538,21 +455,6 @@ void MediaStreamManager::DevicesEnumerated(
MediaStreamType stream_type, const StreamDeviceInfoArray& devices) {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- // Only cache device list when there is EnumerateDevices request, since
- // other requests don't turn on device monitoring.
- bool need_update_clients = false;
- EnumerationCache* cache =
- (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE ?
- &audio_enumeration_cache_ : &video_enumeration_cache_);
- if (HasEnumerationRequest(stream_type) &&
- (!cache->valid ||
- !std::equal(devices.begin(), devices.end(), cache->devices.begin(),
- media_stream::StreamDeviceInfo::IsEqual))) {
- cache->valid = true;
- cache->devices = devices;
- need_update_clients = true;
- }
-
// 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
@@ -560,10 +462,9 @@ void MediaStreamManager::DevicesEnumerated(
std::list<std::string> label_list;
for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end();
++it) {
- if (it->second.state[stream_type] == DeviceRequest::STATE_REQUESTED &&
+ if (it->second.state[stream_type] == DeviceRequest::kRequested &&
Requested(it->second.options, stream_type)) {
- if (it->second.type != DeviceRequest::ENUMERATE_DEVICES)
- it->second.state[stream_type] = DeviceRequest::STATE_PENDING_APPROVAL;
+ it->second.state[stream_type] = DeviceRequest::kPendingApproval;
label_list.push_back(it->first);
}
}
@@ -571,11 +472,11 @@ void MediaStreamManager::DevicesEnumerated(
it != label_list.end(); ++it) {
DeviceRequest& request = requests_[*it];
switch (request.type) {
- case DeviceRequest::ENUMERATE_DEVICES:
- if (need_update_clients)
- request.requester->DevicesEnumerated(*it, devices);
+ case DeviceRequest::kEnumerateDevices:
+ request.requester->DevicesEnumerated(*it, devices);
+ requests_.erase(*it);
break;
- case DeviceRequest::OPEN_DEVICE:
+ 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) {
@@ -583,8 +484,7 @@ void MediaStreamManager::DevicesEnumerated(
device.in_use = false;
device.session_id =
GetDeviceManager(device_it->stream_type)->Open(device);
- request.state[device_it->stream_type] =
- DeviceRequest::STATE_OPENING;
+ request.state[device_it->stream_type] = DeviceRequest::kOpening;
if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE)
request.audio_devices.push_back(device);
else
@@ -602,8 +502,7 @@ void MediaStreamManager::DevicesEnumerated(
}
}
label_list.clear();
- --active_enumeration_ref_count_[stream_type];
- DCHECK_GE(active_enumeration_ref_count_[stream_type], 0);
+ enumeration_in_progress_[stream_type] = false;
}
void MediaStreamManager::Error(MediaStreamType stream_type,
@@ -627,7 +526,7 @@ void MediaStreamManager::Error(MediaStreamType stream_type,
device_it != devices->end(); ++device_it, ++device_idx) {
if (device_it->session_id == capture_session_id) {
// We've found the failing device. Find the error case:
- if (it->second.state[stream_type] == DeviceRequest::STATE_DONE) {
+ if (it->second.state[stream_type] == DeviceRequest::kDone) {
// 1. Already opened -> signal device failure and close device.
// Use device_idx to signal which of the devices encountered an
// error.
@@ -677,12 +576,12 @@ void MediaStreamManager::DevicesAccepted(const std::string& label,
// opened. in_use might be true if the device type can be used in more
// than one session.
DCHECK_EQ(request_it->second.state[device_it->stream_type],
- DeviceRequest::STATE_PENDING_APPROVAL);
+ DeviceRequest::kPendingApproval);
device_info.in_use = false;
device_info.session_id =
GetDeviceManager(device_info.stream_type)->Open(device_info);
request_it->second.state[device_it->stream_type] =
- DeviceRequest::STATE_OPENING;
+ DeviceRequest::kOpening;
if (device_info.stream_type ==
content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) {
request_it->second.audio_devices.push_back(device_info);
@@ -698,12 +597,12 @@ void MediaStreamManager::DevicesAccepted(const std::string& label,
content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE;
if (Requested(request_it->second.options, stream_type) &&
request_it->second.audio_devices.size() == 0) {
- request_it->second.state[stream_type] = DeviceRequest::STATE_ERROR;
+ request_it->second.state[stream_type] = DeviceRequest::kError;
}
stream_type = content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE;
if (Requested(request_it->second.options, stream_type) &&
request_it->second.video_devices.size() == 0) {
- request_it->second.state[stream_type] = DeviceRequest::STATE_ERROR;
+ request_it->second.state[stream_type] = DeviceRequest::kError;
}
return;
}
@@ -714,7 +613,7 @@ void MediaStreamManager::SettingsError(const std::string& label) {
// Erase this request and report an error.
DeviceRequests::iterator it = requests_.find(label);
if (it != requests_.end()) {
- DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM);
+ DCHECK_EQ(it->second.type, DeviceRequest::kGenerateStream);
it->second.requester->StreamGenerationFailed(label);
requests_.erase(it);
return;
@@ -729,10 +628,7 @@ void MediaStreamManager::UseFakeDevice() {
void MediaStreamManager::WillDestroyCurrentMessageLoop() {
DCHECK_EQ(MessageLoop::current(), io_loop_);
- DCHECK(requests_.empty());
if (device_thread_.get()) {
- StopMonitoring();
-
video_capture_manager_->Unregister();
audio_input_device_manager_->Unregister();
device_thread_.reset();
@@ -825,57 +721,4 @@ MediaStreamProvider* MediaStreamManager::GetDeviceManager(
return NULL;
}
-void MediaStreamManager::OnDevicesChanged(
- base::SystemMonitor::DeviceType device_type) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- MediaStreamType stream_type;
- EnumerationCache* cache;
- if (device_type == base::SystemMonitor::DEVTYPE_AUDIO_CAPTURE) {
- stream_type = content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE;
- cache = &audio_enumeration_cache_;
- } else if (device_type == base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE) {
- stream_type = content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE;
- cache = &video_enumeration_cache_;
- } else {
- return; // Uninteresting device change.
- }
-
- if (!HasEnumerationRequest(stream_type)) {
- // There is no request for that type, No need to enumerate devices.
- // Therefore, invalidate the cache of that type.
- ClearEnumerationCache(cache);
- return;
- }
-
- // 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();
-}
-
-bool MediaStreamManager::HasEnumerationRequest() {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- for (DeviceRequests::iterator it = requests_.begin();
- it != requests_.end(); ++it) {
- if (it->second.type == DeviceRequest::ENUMERATE_DEVICES) {
- return true;
- }
- }
- return false;
-}
-
-bool MediaStreamManager::HasEnumerationRequest(
- MediaStreamType stream_type) {
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- for (DeviceRequests::iterator it = requests_.begin();
- it != requests_.end(); ++it) {
- if (it->second.type == DeviceRequest::ENUMERATE_DEVICES &&
- Requested(it->second.options, stream_type)) {
- return true;
- }
- }
- return false;
-}
-
} // namespace media_stream
diff --git a/content/browser/renderer_host/media/media_stream_manager.h b/content/browser/renderer_host/media/media_stream_manager.h
index 6fb5269..648f21c 100644
--- a/content/browser/renderer_host/media/media_stream_manager.h
+++ b/content/browser/renderer_host/media/media_stream_manager.h
@@ -30,7 +30,6 @@
#include "base/memory/scoped_ptr.h"
#include "base/memory/ref_counted.h"
#include "base/message_loop.h"
-#include "base/system_monitor/system_monitor.h"
#include "base/threading/thread.h"
#include "content/browser/renderer_host/media/media_stream_provider.h"
#include "content/browser/renderer_host/media/media_stream_settings_requester.h"
@@ -73,8 +72,7 @@ class DeviceThread : public base::Thread {
class CONTENT_EXPORT MediaStreamManager
: public MediaStreamProviderListener,
public MessageLoop::DestructionObserver,
- public SettingsRequester,
- public base::SystemMonitor::DevicesChangedObserver {
+ public SettingsRequester {
public:
// This class takes the ownerships of the |audio_input_device_manager|
// and |video_capture_manager|.
@@ -109,9 +107,6 @@ class CONTENT_EXPORT MediaStreamManager
// Gets a list of devices of |type|.
// The request is identified using |label|, which is pointing to a
// std::string.
- // The request is persistent, which means the client keeps listening to
- // device changes, such as plug/unplug, and expects new device list for
- // such a change, till the client stops the request.
void EnumerateDevices(MediaStreamRequester* requester,
int render_process_id,
int render_view_id,
@@ -146,10 +141,6 @@ class CONTENT_EXPORT MediaStreamManager
const StreamDeviceInfoArray& devices) OVERRIDE;
virtual void SettingsError(const std::string& label) OVERRIDE;
- // Implements base::SystemMonitor::DevicesChangedObserver.
- virtual void OnDevicesChanged(
- base::SystemMonitor::DeviceType device_type) OVERRIDE;
-
// Used by unit test to make sure fake devices are used instead of a real
// devices, which is needed for server based testing.
// TODO(xians): Remove this hack since we can create our own
@@ -165,15 +156,6 @@ class CONTENT_EXPORT MediaStreamManager
// Contains all data needed to keep track of requests.
struct DeviceRequest;
- // Cache enumerated device list.
- struct EnumerationCache {
- EnumerationCache();
- ~EnumerationCache();
-
- bool valid;
- StreamDeviceInfoArray devices;
- };
-
// Helpers for signaling the media observer that new capture devices are
// opened/closed.
void NotifyObserverDevicesOpened(DeviceRequest* request);
@@ -186,26 +168,11 @@ class CONTENT_EXPORT MediaStreamManager
MediaStreamProvider* GetDeviceManager(MediaStreamType stream_type);
void StartEnumeration(DeviceRequest* new_request,
std::string* label);
- void AddRequest(DeviceRequest* new_request, std::string* label);
- bool HasEnumerationRequest(MediaStreamType type);
- bool HasEnumerationRequest();
- void ClearEnumerationCache(EnumerationCache* cache);
// Helper to ensure the device thread and pass the message loop to device
// managers, it also register itself as the listener to the device managers.
void EnsureDeviceThreadAndListener();
- // Sends cached device list to a client corresponding to the request
- // identified by |label|.
- void SendCachedDeviceList(EnumerationCache* cache, const std::string& label);
-
- // Stop the request of enumerating devices indentified by |label|.
- void StopEnumerateDevices(const std::string& label);
-
- // Helpers to start and stop monitoring devices.
- void StartMonitoring();
- void StopMonitoring();
-
// Device thread shared by VideoCaptureManager and AudioInputDeviceManager.
scoped_ptr<base::Thread> device_thread_;
@@ -213,17 +180,9 @@ class CONTENT_EXPORT MediaStreamManager
scoped_refptr<AudioInputDeviceManager> audio_input_device_manager_;
scoped_refptr<VideoCaptureManager> video_capture_manager_;
- // Indicator of device monitoring state.
- bool monitoring_started_;
-
- // Stores most recently enumerated device lists. The cache is cleared when
- // monitoring is stopped or there is no request for that type of device.
- EnumerationCache audio_enumeration_cache_;
- EnumerationCache video_enumeration_cache_;
-
- // Keeps track of live enumeration commands sent to VideoCaptureManager or
- // AudioInputDeviceManager, in order to only enumerate when necessary.
- int active_enumeration_ref_count_[content::NUM_MEDIA_STREAM_DEVICE_TYPES];
+ // Keeps track of device types currently being enumerated to not enumerate
+ // when not necessary.
+ std::vector<bool> enumeration_in_progress_;
// All non-closed request.
typedef std::map<std::string, DeviceRequest> DeviceRequests;
diff --git a/content/common/media/media_stream_messages.h b/content/common/media/media_stream_messages.h
index 5c89f8d..1f87b10 100644
--- a/content/common/media/media_stream_messages.h
+++ b/content/common/media/media_stream_messages.h
@@ -55,9 +55,8 @@ IPC_MESSAGE_ROUTED2(MediaStreamHostMsg_AudioDeviceFailed,
int /* index */)
// The browser has enumerated devices successfully.
-IPC_MESSAGE_ROUTED3(MediaStreamMsg_DevicesEnumerated,
+IPC_MESSAGE_ROUTED2(MediaStreamMsg_DevicesEnumerated,
int /* request id */,
- std::string /* label */,
media_stream::StreamDeviceInfoArray /* device_list */)
// The browser has failed to enumerate devices.
diff --git a/content/common/media/media_stream_options.cc b/content/common/media/media_stream_options.cc
index 9daa96a..28ee038 100644
--- a/content/common/media/media_stream_options.cc
+++ b/content/common/media/media_stream_options.cc
@@ -24,14 +24,4 @@ StreamDeviceInfo::StreamDeviceInfo(MediaStreamType service_param,
in_use(opened),
session_id(kNoId) {}
-// static
-bool StreamDeviceInfo::IsEqual(const StreamDeviceInfo& first,
- const StreamDeviceInfo& second) {
- return first.stream_type == second.stream_type &&
- first.name == second.name &&
- first.device_id == second.device_id &&
- first.in_use == second.in_use &&
- first.session_id == second.session_id;
-}
-
} // namespace media_stream
diff --git a/content/common/media/media_stream_options.h b/content/common/media/media_stream_options.h
index c51d700..e5127ed 100644
--- a/content/common/media/media_stream_options.h
+++ b/content/common/media/media_stream_options.h
@@ -39,8 +39,6 @@ struct CONTENT_EXPORT StreamDeviceInfo {
const std::string& name_param,
const std::string& device_param,
bool opened);
- static bool IsEqual(const StreamDeviceInfo& first,
- const StreamDeviceInfo& second);
// Describes the capture type.
MediaStreamType stream_type;
diff --git a/content/renderer/media/media_stream_dispatcher.cc b/content/renderer/media/media_stream_dispatcher.cc
index 5d97ca0..ed55342 100644
--- a/content/renderer/media/media_stream_dispatcher.cc
+++ b/content/renderer/media/media_stream_dispatcher.cc
@@ -31,36 +31,8 @@ struct MediaStreamDispatcher::Stream {
media_stream::StreamDeviceInfoArray video_array;
};
-MediaStreamDispatcher::EnumerationRequest::EnumerationRequest(
- const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
- int request_id)
- : handler(handler),
- request_id(request_id) {
-}
-
-MediaStreamDispatcher::EnumerationRequest::~EnumerationRequest() {}
-
-MediaStreamDispatcher::EnumerationState::EnumerationState()
- : ipc_id(-1) {
-}
-
-MediaStreamDispatcher::EnumerationState::~EnumerationState() {}
-
-struct MediaStreamDispatcher::EnumerationState::CachedDevices {
- CachedDevices(const std::string& label,
- const media_stream::StreamDeviceInfoArray& device_array)
- : label(label),
- devices(device_array) {
- }
- ~CachedDevices() {}
-
- std::string label;
- media_stream::StreamDeviceInfoArray devices;
-};
-
MediaStreamDispatcher::MediaStreamDispatcher(RenderViewImpl* render_view)
: content::RenderViewObserver(render_view),
- main_loop_(base::MessageLoopProxy::current()),
next_ipc_id_(0) {
}
@@ -71,7 +43,6 @@ void MediaStreamDispatcher::GenerateStream(
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
media_stream::StreamOptions components,
const GURL& security_origin) {
- DCHECK(main_loop_->BelongsToCurrentThread());
DVLOG(1) << "MediaStreamDispatcher::GenerateStream(" << request_id << ")";
requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
@@ -82,7 +53,6 @@ void MediaStreamDispatcher::GenerateStream(
}
void MediaStreamDispatcher::CancelGenerateStream(int request_id) {
- DCHECK(main_loop_->BelongsToCurrentThread());
DVLOG(1) << "MediaStreamDispatcher::CancelGenerateStream"
<< ", {request_id = " << request_id << "}";
@@ -99,7 +69,6 @@ void MediaStreamDispatcher::CancelGenerateStream(int request_id) {
}
void MediaStreamDispatcher::StopStream(const std::string& label) {
- DCHECK(main_loop_->BelongsToCurrentThread());
DVLOG(1) << "MediaStreamDispatcher::StopStream"
<< ", {label = " << label << "}";
@@ -116,64 +85,14 @@ void MediaStreamDispatcher::EnumerateDevices(
const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
media_stream::MediaStreamType type,
const GURL& security_origin) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DCHECK(type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE ||
- type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE);
DVLOG(1) << "MediaStreamDispatcher::EnumerateDevices("
<< request_id << ")";
- EnumerationState* state =
- (type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE ?
- &audio_enumeration_state_ : &video_enumeration_state_);
- state->requests.push_back(
- EnumerationRequest(event_handler, request_id));
-
- if (state->cached_devices.get()) {
- event_handler->OnDevicesEnumerated(
- request_id, state->cached_devices->devices);
- } else if (state->ipc_id < 0) {
- Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
- next_ipc_id_,
- type,
- security_origin));
- state->ipc_id = next_ipc_id_++;
- }
-}
-
-void MediaStreamDispatcher::StopEnumerateDevices(
- int request_id,
- const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DVLOG(1) << "MediaStreamDispatcher::StopEnumerateDevices("
- << request_id << ")";
-
- // Remove the request.
- RemoveEnumerationRequest(
- request_id, event_handler, &audio_enumeration_state_);
- RemoveEnumerationRequest(
- request_id, event_handler, &video_enumeration_state_);
-}
-
-void MediaStreamDispatcher::RemoveEnumerationRequest(
- int request_id,
- const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
- EnumerationState* state) {
- EnumerationRequestList* requests = &state->requests;
- for (EnumerationRequestList::iterator it = requests->begin();
- it != requests->end(); ++it) {
- if (it->request_id == request_id && it->handler == event_handler) {
- requests->erase(it);
- if (requests->empty() && !state->cached_devices.get()) {
- // No more request and has a label, try to stop the label
- // and invalidate the state.
- Send(new MediaStreamHostMsg_StopGeneratedStream(
- routing_id(), state->cached_devices->label));
- state->ipc_id = -1;
- state->cached_devices.reset();
- }
- return;
- }
- }
+ requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
+ Send(new MediaStreamHostMsg_EnumerateDevices(routing_id(),
+ next_ipc_id_++,
+ type,
+ security_origin));
}
void MediaStreamDispatcher::OpenDevice(
@@ -182,7 +101,6 @@ void MediaStreamDispatcher::OpenDevice(
const std::string& device_id,
media_stream::MediaStreamType type,
const GURL& security_origin) {
- DCHECK(main_loop_->BelongsToCurrentThread());
DVLOG(1) << "MediaStreamDispatcher::OpenDevice(" << request_id << ")";
requests_.push_back(Request(event_handler, request_id, next_ipc_id_));
@@ -194,7 +112,6 @@ void MediaStreamDispatcher::OpenDevice(
}
void MediaStreamDispatcher::CloseDevice(const std::string& label) {
- DCHECK(main_loop_->BelongsToCurrentThread());
DVLOG(1) << "MediaStreamDispatcher::CloseDevice"
<< ", {label = " << label << "}";
@@ -230,7 +147,6 @@ void MediaStreamDispatcher::OnStreamGenerated(
const std::string& label,
const media_stream::StreamDeviceInfoArray& audio_array,
const media_stream::StreamDeviceInfoArray& video_array) {
- DCHECK(main_loop_->BelongsToCurrentThread());
for (RequestList::iterator it = requests_.begin();
it != requests_.end(); ++it) {
@@ -254,7 +170,6 @@ void MediaStreamDispatcher::OnStreamGenerated(
}
void MediaStreamDispatcher::OnStreamGenerationFailed(int request_id) {
- DCHECK(main_loop_->BelongsToCurrentThread());
for (RequestList::iterator it = requests_.begin();
it != requests_.end(); ++it) {
Request& request = *it;
@@ -272,7 +187,6 @@ void MediaStreamDispatcher::OnStreamGenerationFailed(int request_id) {
void MediaStreamDispatcher::OnVideoDeviceFailed(const std::string& label,
int index) {
- DCHECK(main_loop_->BelongsToCurrentThread());
LabelStreamMap::iterator it = label_stream_map_.find(label);
if (it == label_stream_map_.end())
return;
@@ -288,7 +202,6 @@ void MediaStreamDispatcher::OnVideoDeviceFailed(const std::string& label,
void MediaStreamDispatcher::OnAudioDeviceFailed(const std::string& label,
int index) {
- DCHECK(main_loop_->BelongsToCurrentThread());
LabelStreamMap::iterator it = label_stream_map_.find(label);
if (it == label_stream_map_.end())
return;
@@ -304,41 +217,24 @@ void MediaStreamDispatcher::OnAudioDeviceFailed(const std::string& label,
void MediaStreamDispatcher::OnDevicesEnumerated(
int request_id,
- const std::string& label,
const media_stream::StreamDeviceInfoArray& device_array) {
- DCHECK(main_loop_->BelongsToCurrentThread());
- DCHECK_GE(request_id, 0);
-
- EnumerationState* state;
- if (request_id == audio_enumeration_state_.ipc_id) {
- state = &audio_enumeration_state_;
- } else if (request_id == video_enumeration_state_.ipc_id) {
- state = &video_enumeration_state_;
- } else {
- // This could happen when requester has stopped enumeration while some
- // enumerated response is on the way. Have to stop the |label| because
- // this might be the first enumerated device list is received. This also
- // lead to same label being stopped multiple times.
- Send(new MediaStreamHostMsg_StopGeneratedStream(routing_id(), label));
- return;
- }
- DCHECK(!label.empty());
- state->cached_devices.reset(new EnumerationState::CachedDevices(
- label, device_array));
-
- for (EnumerationRequestList::iterator it = state->requests.begin();
- it != state->requests.end(); ++it) {
- if (it->handler) {
- it->handler->OnDevicesEnumerated(it->request_id, device_array);
- DVLOG(1) << "MediaStreamDispatcher::OnDevicesEnumerated("
- << it->request_id << ")";
+ for (RequestList::iterator it = requests_.begin();
+ it != requests_.end(); ++it) {
+ Request& request = *it;
+ if (request.ipc_request == request_id) {
+ if (request.handler) {
+ request.handler->OnDevicesEnumerated(request.request_id, device_array);
+ DVLOG(1) << "MediaStreamDispatcher::OnDevicesEnumerated("
+ << request.request_id << ")";
+ }
+ requests_.erase(it);
+ break;
}
}
}
void MediaStreamDispatcher::OnDevicesEnumerationFailed(int request_id) {
- DCHECK(main_loop_->BelongsToCurrentThread());
for (RequestList::iterator it = requests_.begin();
it != requests_.end(); ++it) {
Request& request = *it;
@@ -358,7 +254,6 @@ void MediaStreamDispatcher::OnDeviceOpened(
int request_id,
const std::string& label,
const media_stream::StreamDeviceInfo& device_info) {
- DCHECK(main_loop_->BelongsToCurrentThread());
for (RequestList::iterator it = requests_.begin();
it != requests_.end(); ++it) {
Request& request = *it;
@@ -385,7 +280,6 @@ void MediaStreamDispatcher::OnDeviceOpened(
}
void MediaStreamDispatcher::OnDeviceOpenFailed(int request_id) {
- DCHECK(main_loop_->BelongsToCurrentThread());
for (RequestList::iterator it = requests_.begin();
it != requests_.end(); ++it) {
Request& request = *it;
diff --git a/content/renderer/media/media_stream_dispatcher.h b/content/renderer/media/media_stream_dispatcher.h
index fc1145b..a000c52 100644
--- a/content/renderer/media/media_stream_dispatcher.h
+++ b/content/renderer/media/media_stream_dispatcher.h
@@ -11,17 +11,12 @@
#include "base/basictypes.h"
#include "base/gtest_prod_util.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/memory/weak_ptr.h"
+#include "base/message_loop.h"
#include "content/common/content_export.h"
#include "content/common/media/media_stream_options.h"
#include "content/public/renderer/render_view_observer.h"
#include "content/renderer/media/media_stream_dispatcher_eventhandler.h"
-namespace base {
-class MessageLoopProxy;
-}
-
class RenderViewImpl;
// MediaStreamDispatcher is a delegate for the Media Stream API messages.
@@ -57,11 +52,6 @@ class CONTENT_EXPORT MediaStreamDispatcher
media_stream::MediaStreamType type,
const GURL& security_origin);
- // Request to stop enumerating devices.
- void StopEnumerateDevices(
- int request_id,
- const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler);
-
// Request to open a device.
void OpenDevice(
int request_id,
@@ -93,31 +83,6 @@ class CONTENT_EXPORT MediaStreamDispatcher
// opened it.
struct Stream;
- struct EnumerationRequest {
- EnumerationRequest(
- const base::WeakPtr<MediaStreamDispatcherEventHandler>& handler,
- int request_id);
- ~EnumerationRequest();
-
- base::WeakPtr<MediaStreamDispatcherEventHandler> handler;
- int request_id;
- };
-
- // List of requests made to EnumerateDevices.
- typedef std::list<EnumerationRequest> EnumerationRequestList;
-
- struct EnumerationState {
- EnumerationState();
- ~EnumerationState();
-
- struct CachedDevices;
-
- // If |ipc_id| >= 0, then we've started.
- int ipc_id;
- scoped_ptr<CachedDevices> cached_devices;
- EnumerationRequestList requests;
- };
-
// Messages from the browser.
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
void OnStreamGenerated(
@@ -130,7 +95,6 @@ class CONTENT_EXPORT MediaStreamDispatcher
void OnAudioDeviceFailed(const std::string& label, int index);
void OnDevicesEnumerated(
int request_id,
- const std::string& label,
const media_stream::StreamDeviceInfoArray& device_array);
void OnDevicesEnumerationFailed(int request_id);
void OnDeviceOpened(
@@ -139,21 +103,10 @@ class CONTENT_EXPORT MediaStreamDispatcher
const media_stream::StreamDeviceInfo& device_info);
void OnDeviceOpenFailed(int request_id);
- void RemoveEnumerationRequest(
- int request_id,
- const base::WeakPtr<MediaStreamDispatcherEventHandler>& event_handler,
- EnumerationState* state);
-
- // Used for DCHECKs so methods calls won't execute in the wrong thread.
- scoped_refptr<base::MessageLoopProxy> main_loop_;
-
int next_ipc_id_;
typedef std::map<std::string, Stream> LabelStreamMap;
LabelStreamMap label_stream_map_;
- EnumerationState audio_enumeration_state_;
- EnumerationState video_enumeration_state_;
-
// List of calls made to GenerateStream that has not yet completed.
typedef std::list<Request> RequestList;
RequestList requests_;
diff --git a/content/renderer/media/media_stream_dispatcher_unittest.cc b/content/renderer/media/media_stream_dispatcher_unittest.cc
index 458d61b..c83c8b3 100644
--- a/content/renderer/media/media_stream_dispatcher_unittest.cc
+++ b/content/renderer/media/media_stream_dispatcher_unittest.cc
@@ -22,7 +22,6 @@ const int kRequestId1 = 10;
const int kRequestId2 = 20;
const int kRequestId3 = 30;
const int kRequestId4 = 40;
-static const char kLabel[] = "test";
class MockMediaStreamDispatcherEventHandler
: public MediaStreamDispatcherEventHandler,
@@ -89,7 +88,6 @@ class MockMediaStreamDispatcherEventHandler
} // namespace
TEST(MediaStreamDispatcherTest, BasicStream) {
- scoped_ptr<MessageLoop> message_loop(new MessageLoop());
scoped_ptr<MediaStreamDispatcher> dispatcher(new MediaStreamDispatcher(NULL));
scoped_ptr<MockMediaStreamDispatcherEventHandler>
handler(new MockMediaStreamDispatcherEventHandler);
@@ -165,24 +163,21 @@ TEST(MediaStreamDispatcherTest, BasicStream) {
}
TEST(MediaStreamDispatcherTest, BasicVideoDevice) {
- scoped_ptr<MessageLoop> message_loop(new MessageLoop());
scoped_ptr<MediaStreamDispatcher> dispatcher(new MediaStreamDispatcher(NULL));
scoped_ptr<MockMediaStreamDispatcherEventHandler>
- handler1(new MockMediaStreamDispatcherEventHandler);
- scoped_ptr<MockMediaStreamDispatcherEventHandler>
- handler2(new MockMediaStreamDispatcherEventHandler);
+ handler(new MockMediaStreamDispatcherEventHandler);
GURL security_origin;
int ipc_request_id1 = dispatcher->next_ipc_id_;
- dispatcher->EnumerateDevices(kRequestId1, handler1.get()->AsWeakPtr(),
+ dispatcher->EnumerateDevices(kRequestId1, handler.get()->AsWeakPtr(),
content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
security_origin);
int ipc_request_id2 = dispatcher->next_ipc_id_;
EXPECT_NE(ipc_request_id1, ipc_request_id2);
- dispatcher->EnumerateDevices(kRequestId2, handler2.get()->AsWeakPtr(),
+ dispatcher->EnumerateDevices(kRequestId2, handler.get()->AsWeakPtr(),
content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
security_origin);
- EXPECT_EQ(dispatcher->video_enumeration_state_.requests.size(), size_t(2));
+ EXPECT_EQ(dispatcher->requests_.size(), size_t(2));
media_stream::StreamDeviceInfoArray video_device_array(1);
media_stream::StreamDeviceInfo video_device_info;
@@ -193,23 +188,27 @@ TEST(MediaStreamDispatcherTest, BasicVideoDevice) {
video_device_info.session_id = kVideoSessionId;
video_device_array[0] = video_device_info;
- // Complete the enumeration request and all requesters should receive reply.
+ // Complete the enumeration of request 1.
+ dispatcher->OnMessageReceived(MediaStreamMsg_DevicesEnumerated(
+ kRouteId, ipc_request_id1, video_device_array));
+ EXPECT_EQ(handler->request_id_, kRequestId1);
+
+ // Complete the enumeration of request 2.
dispatcher->OnMessageReceived(MediaStreamMsg_DevicesEnumerated(
- kRouteId, ipc_request_id1, kLabel, video_device_array));
- EXPECT_EQ(handler1->request_id_, kRequestId1);
- EXPECT_EQ(handler2->request_id_, kRequestId2);
+ kRouteId, ipc_request_id2, video_device_array));
+ EXPECT_EQ(handler->request_id_, kRequestId2);
- EXPECT_EQ(dispatcher->video_enumeration_state_.requests.size(), size_t(2));
+ EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(0));
int ipc_request_id3 = dispatcher->next_ipc_id_;
- dispatcher->OpenDevice(kRequestId3, handler1.get()->AsWeakPtr(),
+ dispatcher->OpenDevice(kRequestId3, handler.get()->AsWeakPtr(),
video_device_info.device_id,
content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
security_origin);
int ipc_request_id4 = dispatcher->next_ipc_id_;
EXPECT_NE(ipc_request_id3, ipc_request_id4);
- dispatcher->OpenDevice(kRequestId4, handler1.get()->AsWeakPtr(),
+ dispatcher->OpenDevice(kRequestId4, handler.get()->AsWeakPtr(),
video_device_info.device_id,
content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE,
security_origin);
@@ -219,13 +218,13 @@ TEST(MediaStreamDispatcherTest, BasicVideoDevice) {
std::string stream_label1 = std::string("stream1");
dispatcher->OnMessageReceived(MediaStreamMsg_DeviceOpened(
kRouteId, ipc_request_id3, stream_label1, video_device_info));
- EXPECT_EQ(handler1->request_id_, kRequestId3);
+ EXPECT_EQ(handler->request_id_, kRequestId3);
// Complete the OpenDevice of request 2.
std::string stream_label2 = std::string("stream2");
dispatcher->OnMessageReceived(MediaStreamMsg_DeviceOpened(
kRouteId, ipc_request_id4, stream_label2, video_device_info));
- EXPECT_EQ(handler1->request_id_, kRequestId4);
+ EXPECT_EQ(handler->request_id_, kRequestId4);
EXPECT_EQ(dispatcher->requests_.size(), size_t(0));
EXPECT_EQ(dispatcher->label_stream_map_.size(), size_t(2));
@@ -251,7 +250,6 @@ TEST(MediaStreamDispatcherTest, BasicVideoDevice) {
}
TEST(MediaStreamDispatcherTest, TestFailure) {
- scoped_ptr<MessageLoop> message_loop(new MessageLoop());
scoped_ptr<MediaStreamDispatcher> dispatcher(new MediaStreamDispatcher(NULL));
scoped_ptr<MockMediaStreamDispatcherEventHandler>
handler(new MockMediaStreamDispatcherEventHandler);
@@ -318,7 +316,6 @@ TEST(MediaStreamDispatcherTest, TestFailure) {
}
TEST(MediaStreamDispatcherTest, CancelGenerateStream) {
- scoped_ptr<MessageLoop> message_loop(new MessageLoop());
scoped_ptr<MediaStreamDispatcher> dispatcher(new MediaStreamDispatcher(NULL));
scoped_ptr<MockMediaStreamDispatcherEventHandler>
handler(new MockMediaStreamDispatcherEventHandler);
diff --git a/content/renderer/pepper/pepper_device_enumeration_event_handler.cc b/content/renderer/pepper/pepper_device_enumeration_event_handler.cc
index 3ea089c..d5a1d20 100644
--- a/content/renderer/pepper/pepper_device_enumeration_event_handler.cc
+++ b/content/renderer/pepper/pepper_device_enumeration_event_handler.cc
@@ -127,8 +127,7 @@ void PepperDeviceEnumerationEventHandler::NotifyDevicesEnumerated(
const media_stream::StreamDeviceInfoArray& device_array) {
EnumerateCallbackMap::iterator iter = enumerate_callbacks_.find(request_id);
if (iter == enumerate_callbacks_.end()) {
- // This might be enumerated result sent before StopEnumerateDevices is
- // called since EnumerateDevices is persistent request.
+ NOTREACHED();
return;
}
diff --git a/content/renderer/pepper/pepper_plugin_delegate_impl.cc b/content/renderer/pepper/pepper_plugin_delegate_impl.cc
index c8fc294..351b0a0 100644
--- a/content/renderer/pepper/pepper_plugin_delegate_impl.cc
+++ b/content/renderer/pepper/pepper_plugin_delegate_impl.cc
@@ -1506,19 +1506,6 @@ int PepperPluginDelegateImpl::EnumerateDevices(
return request_id;
}
-void PepperPluginDelegateImpl::StopEnumerateDevices(int request_id) {
-#if defined(ENABLE_WEBRTC)
- // Need to post task since this function might be called inside the callback
- // of EnumerateDevices.
- MessageLoop::current()->PostTask(
- FROM_HERE,
- base::Bind(
- &MediaStreamDispatcher::StopEnumerateDevices,
- base::Unretained(render_view_->media_stream_dispatcher()),
- request_id, device_enumeration_event_handler_.get()->AsWeakPtr()));
-#endif
-}
-
bool PepperPluginDelegateImpl::OnMessageReceived(const IPC::Message& message) {
bool handled = true;
IPC_BEGIN_MESSAGE_MAP(PepperPluginDelegateImpl, message)
diff --git a/content/renderer/pepper/pepper_plugin_delegate_impl.h b/content/renderer/pepper/pepper_plugin_delegate_impl.h
index 09e3986..83d3103 100644
--- a/content/renderer/pepper/pepper_plugin_delegate_impl.h
+++ b/content/renderer/pepper/pepper_plugin_delegate_impl.h
@@ -377,7 +377,6 @@ class PepperPluginDelegateImpl
virtual int EnumerateDevices(
PP_DeviceType_Dev type,
const EnumerateDevicesCallback& callback) OVERRIDE;
- virtual void StopEnumerateDevices(int request_id) OVERRIDE;
virtual webkit_glue::ClipboardClient* CreateClipboardClient() const OVERRIDE;
virtual std::string GetDeviceID() OVERRIDE;
virtual PP_FlashLSORestrictions GetLocalDataRestrictions(
diff --git a/webkit/plugins/ppapi/mock_plugin_delegate.cc b/webkit/plugins/ppapi/mock_plugin_delegate.cc
index 782c728..298ddc9 100644
--- a/webkit/plugins/ppapi/mock_plugin_delegate.cc
+++ b/webkit/plugins/ppapi/mock_plugin_delegate.cc
@@ -451,9 +451,6 @@ int MockPluginDelegate::EnumerateDevices(
return -1;
}
-void MockPluginDelegate::StopEnumerateDevices(int request_id) {
-}
-
webkit_glue::ClipboardClient*
MockPluginDelegate::CreateClipboardClient() const {
return NULL;
diff --git a/webkit/plugins/ppapi/mock_plugin_delegate.h b/webkit/plugins/ppapi/mock_plugin_delegate.h
index 038bd25..3fa4677 100644
--- a/webkit/plugins/ppapi/mock_plugin_delegate.h
+++ b/webkit/plugins/ppapi/mock_plugin_delegate.h
@@ -202,7 +202,6 @@ class MockPluginDelegate : public PluginDelegate {
virtual bool IsPageVisible() const;
virtual int EnumerateDevices(PP_DeviceType_Dev type,
const EnumerateDevicesCallback& callback);
- virtual void StopEnumerateDevices(int request_id);
virtual webkit_glue::ClipboardClient* CreateClipboardClient() const;
virtual std::string GetDeviceID();
virtual PP_FlashLSORestrictions GetLocalDataRestrictions(
diff --git a/webkit/plugins/ppapi/plugin_delegate.h b/webkit/plugins/ppapi/plugin_delegate.h
index fd8a2a5..ab237a3 100644
--- a/webkit/plugins/ppapi/plugin_delegate.h
+++ b/webkit/plugins/ppapi/plugin_delegate.h
@@ -659,9 +659,6 @@ class PluginDelegate {
// callback will be the same as the return value.
virtual int EnumerateDevices(PP_DeviceType_Dev type,
const EnumerateDevicesCallback& callback) = 0;
- // Stop enumerating devices of the specified |request_id|. The |request_id|
- // is the return value of EnumerateDevicesCallback.
- virtual void StopEnumerateDevices(int request_id) = 0;
// Create a ClipboardClient for writing to the clipboard. The caller will own
// the pointer to this.
virtual webkit_glue::ClipboardClient* CreateClipboardClient() const = 0;
diff --git a/webkit/plugins/ppapi/ppb_audio_input_impl.cc b/webkit/plugins/ppapi/ppb_audio_input_impl.cc
index f4f40c0..3b4d609 100644
--- a/webkit/plugins/ppapi/ppb_audio_input_impl.cc
+++ b/webkit/plugins/ppapi/ppb_audio_input_impl.cc
@@ -175,10 +175,6 @@ void PPB_AudioInput_Impl::EnumerateDevicesCallbackFunc(
if (succeeded)
devices_data_ = devices;
- PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
- if (plugin_delegate)
- plugin_delegate->StopEnumerateDevices(request_id);
-
OnEnumerateDevicesComplete(succeeded ? PP_OK : PP_ERROR_FAILED, devices);
}
diff --git a/webkit/plugins/ppapi/ppb_video_capture_impl.cc b/webkit/plugins/ppapi/ppb_video_capture_impl.cc
index caf9027..a39f46a 100644
--- a/webkit/plugins/ppapi/ppb_video_capture_impl.cc
+++ b/webkit/plugins/ppapi/ppb_video_capture_impl.cc
@@ -312,10 +312,6 @@ void PPB_VideoCapture_Impl::EnumerateDevicesCallbackFunc(
if (succeeded)
devices_data_ = devices;
- PluginInstance* instance = ResourceHelper::GetPluginInstance(this);
- if (instance)
- instance->delegate()->StopEnumerateDevices(request_id);
-
OnEnumerateDevicesComplete(succeeded ? PP_OK : PP_ERROR_FAILED, devices);
}