// no-ops until MediaStreamManager is aware that a renderer process has
// started logging. crbug.com/333894
if (content::BrowserMainLoop::GetInstance()) {
- content::BrowserMainLoop::GetInstance()->
- media_stream_manager()->AddLogMessageOnUIThread(message);
+ BrowserThread::PostTask(
+ BrowserThread::IO,
+ FROM_HERE,
+ base::Bind(&MediaStreamManager::AddLogMessageOnIOThread,
+ base::Unretained(content::BrowserMainLoop::GetInstance()
+ ->media_stream_manager()),
+ message));
}
}
return output_string;
}
+// Needed for MediaStreamManager::GenerateStream below.
+std::string ReturnEmptySalt() {
+ return std::string();
+}
+
} // namespace
const GURL& security_origin,
MediaStreamRequestType request_type,
const StreamOptions& options,
- ResourceContext* resource_context)
+ const ResourceContext::SaltCallback& salt_callback)
: requester(requester),
requesting_process_id(requesting_process_id),
requesting_view_id(requesting_view_id),
security_origin(security_origin),
request_type(request_type),
options(options),
- resource_context(resource_context),
+ salt_callback(salt_callback),
state_(NUM_MEDIA_TYPES, MEDIA_REQUEST_STATE_NOT_REQUESTED),
audio_type_(MEDIA_NO_SERVICE),
video_type_(MEDIA_NO_SERVICE) {
const StreamOptions options;
- ResourceContext* resource_context;
+ ResourceContext::SaltCallback salt_callback;
StreamDeviceInfoArray devices;
MediaStreamManager::~MediaStreamManager() {
DVLOG(1) << "~MediaStreamManager";
DCHECK(requests_.empty());
- DCHECK(!device_thread_.get());
+ DCHECK(!device_task_runner_);
}
VideoCaptureManager* MediaStreamManager::video_capture_manager() {
security_origin,
MEDIA_DEVICE_ACCESS,
options,
- NULL);
+ base::Bind(&ReturnEmptySalt));
const std::string& label = AddRequest(request);
void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
int render_process_id,
int render_view_id,
- ResourceContext* rc,
+ const ResourceContext::SaltCallback& sc,
int page_request_id,
const StreamOptions& options,
const GURL& security_origin) {
security_origin,
MEDIA_GENERATE_STREAM,
options,
- rc);
+ sc);
const std::string& label = AddRequest(request);
MediaStreamRequester* requester,
int render_process_id,
int render_view_id,
- ResourceContext* rc,
+ const ResourceContext::SaltCallback& sc,
int page_request_id,
MediaStreamType type,
const GURL& security_origin) {
security_origin,
MEDIA_ENUMERATE_DEVICES,
StreamOptions(),
- rc);
+ sc);
if (IsAudioMediaType(type))
request->SetAudioType(type);
else if (IsVideoMediaType(type))
void MediaStreamManager::OpenDevice(MediaStreamRequester* requester,
int render_process_id,
int render_view_id,
- ResourceContext* rc,
+ const ResourceContext::SaltCallback& sc,
int page_request_id,
const std::string& device_id,
MediaStreamType type,
security_origin,
MEDIA_OPEN_DEVICE,
options,
- rc);
+ sc);
const std::string& label = AddRequest(request);
// Post a task and handle the request asynchronously. The reason is that the
for (StreamDeviceInfoArray::const_iterator old_dev_it = old_devices.begin();
old_dev_it != old_devices.end(); ++old_dev_it) {
bool device_found = false;
- for (StreamDeviceInfoArray::const_iterator new_dev_it = new_devices.begin();
- new_dev_it != new_devices.end(); ++new_dev_it) {
+ StreamDeviceInfoArray::const_iterator new_dev_it = new_devices.begin();
+ for (; new_dev_it != new_devices.end(); ++new_dev_it) {
if (old_dev_it->device.id == new_dev_it->device.id) {
device_found = true;
break;
request->devices.begin();
device_it != request->devices.end(); ++device_it) {
std::string source_id = content::GetHMACForMediaDeviceID(
- request->resource_context,
+ request->salt_callback,
request->security_origin,
device.id);
if (device_it->device.id == source_id &&
// id.
if (source_ids.size() == 1 &&
!TranslateSourceIdToDeviceId(type,
- request->resource_context,
+ request->salt_callback,
request->security_origin,
source_ids[0], device_id)) {
LOG(WARNING) << "Invalid mandatory " << kMediaStreamSourceInfoId
for (std::vector<std::string>::const_iterator it = source_ids.begin();
it != source_ids.end(); ++it) {
if (TranslateSourceIdToDeviceId(type,
- request->resource_context,
+ request->salt_callback,
request->security_origin,
*it,
device_id)) {
if (request->audio_type() == MEDIA_DEVICE_AUDIO_CAPTURE ||
request->video_type() == MEDIA_DEVICE_VIDEO_CAPTURE) {
device->id = content::GetHMACForMediaDeviceID(
- request->resource_context,
+ request->salt_callback,
request->security_origin,
device->id);
}
bool MediaStreamManager::TranslateSourceIdToDeviceId(
MediaStreamType stream_type,
- ResourceContext* rc,
+ const ResourceContext::SaltCallback& sc,
const GURL& security_origin,
const std::string& source_id,
std::string* device_id) const {
for (StreamDeviceInfoArray::const_iterator it = cache->devices.begin();
it != cache->devices.end();
++it) {
- if (content::DoesMediaDeviceIDMatchHMAC(rc, security_origin, source_id,
+ if (content::DoesMediaDeviceIDMatchHMAC(sc, security_origin, source_id,
it->device.id)) {
*device_id = it->device.id;
return true;
DCHECK(existing_request_state);
std::string source_id = content::GetHMACForMediaDeviceID(
- new_request.resource_context,
+ new_request.salt_callback,
new_request.security_origin,
new_device_info.id);
void MediaStreamManager::InitializeDeviceManagersOnIOThread() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
- if (device_thread_)
+ if (device_task_runner_)
return;
- device_thread_.reset(new base::Thread("MediaStreamDeviceThread"));
-#if defined(OS_WIN)
- device_thread_->init_com_with_mta(true);
-#endif
- CHECK(device_thread_->Start());
+ device_task_runner_ = audio_manager_->GetWorkerTaskRunner();
audio_input_device_manager_ = new AudioInputDeviceManager(audio_manager_);
- audio_input_device_manager_->Register(
- this, device_thread_->message_loop_proxy().get());
+ audio_input_device_manager_->Register(this, device_task_runner_);
video_capture_manager_ = new VideoCaptureManager();
- video_capture_manager_->Register(this,
- device_thread_->message_loop_proxy().get());
+ video_capture_manager_->Register(this, device_task_runner_);
// We want to be notified of IO message loop destruction to delete the thread
// and the device managers.
base::Bind(DoAddLogMessage, message));
}
-void MediaStreamManager::AddLogMessageOnUIThread(const std::string& message) {
-#if defined(OS_ANDROID)
- // It appears android_aosp is being built with ENABLE_WEBRTC=0, since it does
- // not find RenderProcessHostImpl::WebRtcLogMessage. Logging is not enabled on
- // Android anyway, so make this function a no-op.
- // TODO(vrk): Figure out what's going on here and fix.
- return;
-#else
- // Must be on the UI thread to access RenderProcessHost from process ID.
- DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+void MediaStreamManager::AddLogMessageOnIOThread(const std::string& message) {
+ // Get render process ids on the IO thread.
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
// Grab all unique process ids that request a MediaStream or have a
// MediaStream running.
requesting_process_ids.insert(request->requesting_process_id);
}
+ // MediaStreamManager is a singleton in BrowserMainLoop, which owns the UI
+ // thread. MediaStreamManager has the same lifetime as the UI thread, so it is
+ // safe to use base::Unretained.
+ BrowserThread::PostTask(
+ BrowserThread::UI,
+ FROM_HERE,
+ base::Bind(&MediaStreamManager::AddLogMessageOnUIThread,
+ base::Unretained(this),
+ requesting_process_ids,
+ message));
+}
+
+void MediaStreamManager::AddLogMessageOnUIThread(
+ const std::set<int>& requesting_process_ids,
+ const std::string& message) {
+#if defined(ENABLE_WEBRTC)
+ // Must be on the UI thread to access RenderProcessHost from process ID.
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
for (std::set<int>::const_iterator it = requesting_process_ids.begin();
it != requesting_process_ids.end(); ++it) {
// Log the message to all renderers that are requesting a MediaStream or
DVLOG(3) << "MediaStreamManager::WillDestroyCurrentMessageLoop()";
DCHECK_EQ(base::MessageLoop::current(), io_loop_);
DCHECK(requests_.empty());
- if (device_thread_) {
+ if (device_task_runner_) {
StopMonitoring();
video_capture_manager_->Unregister();
audio_input_device_manager_->Unregister();
- device_thread_.reset();
+ device_task_runner_ = NULL;
}
audio_input_device_manager_ = NULL;
projects / platform / framework / web / crosswalk.git / blobdiff