OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "content/browser/renderer_host/media/media_stream_manager.h" | 5 #include "content/browser/renderer_host/media/media_stream_manager.h" |
6 | 6 |
7 #include <list> | 7 #include <list> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
11 #include "base/logging.h" | 11 #include "base/logging.h" |
12 #include "base/rand_util.h" | 12 #include "base/rand_util.h" |
13 #include "content/browser/renderer_host/media/audio_input_device_manager.h" | 13 #include "content/browser/renderer_host/media/audio_input_device_manager.h" |
14 #include "content/browser/renderer_host/media/media_stream_device_settings.h" | 14 #include "content/browser/renderer_host/media/media_stream_device_settings.h" |
15 #include "content/browser/renderer_host/media/media_stream_requester.h" | 15 #include "content/browser/renderer_host/media/media_stream_requester.h" |
16 #include "content/browser/renderer_host/media/video_capture_manager.h" | 16 #include "content/browser/renderer_host/media/video_capture_manager.h" |
17 #include "content/browser/resource_context_impl.h" | |
18 #include "content/common/media/media_stream_options.h" | 17 #include "content/common/media/media_stream_options.h" |
19 #include "content/public/browser/browser_thread.h" | 18 #include "content/public/browser/browser_thread.h" |
20 #include "content/public/browser/content_browser_client.h" | 19 #include "content/public/browser/content_browser_client.h" |
21 #include "content/public/browser/media_observer.h" | 20 #include "content/public/browser/media_observer.h" |
22 #include "googleurl/src/gurl.h" | 21 #include "googleurl/src/gurl.h" |
23 #include "media/audio/audio_manager.h" | |
24 | 22 |
25 using content::BrowserThread; | 23 using content::BrowserThread; |
26 | 24 |
27 static const char* kMediaStreamManagerKeyName = "content_media_stream_manager"; | |
28 | |
29 namespace media_stream { | 25 namespace media_stream { |
30 | 26 |
31 // Creates a random label used to identify requests. | 27 // Creates a random label used to identify requests. |
32 static std::string RandomLabel() { | 28 static std::string RandomLabel() { |
33 // An earlier PeerConnection spec, | 29 // An earlier PeerConnection spec, |
34 // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the | 30 // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the |
35 // MediaStream::label alphabet as containing 36 characters from | 31 // MediaStream::label alphabet as containing 36 characters from |
36 // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E, | 32 // range: U+0021, U+0023 to U+0027, U+002A to U+002B, U+002D to U+002E, |
37 // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E. | 33 // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E. |
38 // Here we use a safe subset. | 34 // Here we use a safe subset. |
(...skipping 70 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
109 std::vector<RequestState> state; | 105 std::vector<RequestState> state; |
110 RequestType type; | 106 RequestType type; |
111 int render_process_id; | 107 int render_process_id; |
112 int render_view_id; | 108 int render_view_id; |
113 GURL security_origin; | 109 GURL security_origin; |
114 std::string requested_device_id; | 110 std::string requested_device_id; |
115 StreamDeviceInfoArray audio_devices; | 111 StreamDeviceInfoArray audio_devices; |
116 StreamDeviceInfoArray video_devices; | 112 StreamDeviceInfoArray video_devices; |
117 }; | 113 }; |
118 | 114 |
119 // static | 115 MediaStreamManager::MediaStreamManager( |
120 MediaStreamManager* MediaStreamManager::GetForResourceContext( | 116 AudioInputDeviceManager* audio_input_device_manager, |
121 content::ResourceContext* resource_context, | 117 VideoCaptureManager* video_capture_manager) |
122 media::AudioManager* audio_manager) { | |
123 MediaStreamManager* rv = static_cast<MediaStreamManager*>( | |
124 resource_context->GetUserData(kMediaStreamManagerKeyName)); | |
125 if (!rv) { | |
126 rv = new MediaStreamManager(audio_manager); | |
127 resource_context->SetUserData(kMediaStreamManagerKeyName, rv); | |
128 } | |
129 return rv; | |
130 } | |
131 | |
132 MediaStreamManager::MediaStreamManager(media::AudioManager* audio_manager) | |
133 : ALLOW_THIS_IN_INITIALIZER_LIST( | 118 : ALLOW_THIS_IN_INITIALIZER_LIST( |
134 device_settings_(new MediaStreamDeviceSettings(this))), | 119 device_settings_(new MediaStreamDeviceSettings(this))), |
135 enumeration_in_progress_(content::NUM_MEDIA_STREAM_DEVICE_TYPES, false), | 120 audio_input_device_manager_(audio_input_device_manager), |
136 audio_manager_(audio_manager) { | 121 video_capture_manager_(video_capture_manager), |
137 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 122 enumeration_in_progress_(content::NUM_MEDIA_STREAM_DEVICE_TYPES, false) { |
138 } | 123 } |
139 | 124 |
140 MediaStreamManager::~MediaStreamManager() { | 125 MediaStreamManager::~MediaStreamManager() { |
141 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 126 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
142 if (video_capture_manager_.get()) | 127 if (device_thread_.get()) { |
143 video_capture_manager_->Unregister(); | 128 video_capture_manager_->Unregister(); |
144 if (audio_input_device_manager_.get()) | |
145 audio_input_device_manager_->Unregister(); | 129 audio_input_device_manager_->Unregister(); |
| 130 device_thread_->Stop(); |
| 131 } |
146 } | 132 } |
147 | 133 |
148 VideoCaptureManager* MediaStreamManager::video_capture_manager() { | 134 VideoCaptureManager* MediaStreamManager::video_capture_manager() { |
149 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 135 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
150 if (!video_capture_manager_.get()) { | 136 DCHECK(video_capture_manager_.get()); |
151 video_capture_manager_ = new VideoCaptureManager(); | 137 EnsureDeviceThreadAndListener(); |
152 video_capture_manager_->Register(this); | |
153 } | |
154 return video_capture_manager_.get(); | 138 return video_capture_manager_.get(); |
155 } | 139 } |
156 | 140 |
157 AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() { | 141 AudioInputDeviceManager* MediaStreamManager::audio_input_device_manager() { |
158 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 142 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
159 if (!audio_input_device_manager_.get()) { | 143 DCHECK(audio_input_device_manager_.get()); |
160 audio_input_device_manager_ = new AudioInputDeviceManager(audio_manager_); | 144 EnsureDeviceThreadAndListener(); |
161 audio_input_device_manager_->Register(this); | |
162 } | |
163 return audio_input_device_manager_.get(); | 145 return audio_input_device_manager_.get(); |
164 } | 146 } |
165 | 147 |
166 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester, | 148 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester, |
167 int render_process_id, | 149 int render_process_id, |
168 int render_view_id, | 150 int render_view_id, |
169 const StreamOptions& options, | 151 const StreamOptions& options, |
170 const GURL& security_origin, | 152 const GURL& security_origin, |
171 std::string* label) { | 153 std::string* label) { |
172 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 154 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
(...skipping 187 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
360 base::Bind(&MediaStreamDeviceSettings::RequestCaptureDeviceUsage, | 342 base::Bind(&MediaStreamDeviceSettings::RequestCaptureDeviceUsage, |
361 base::Unretained(device_settings_.get()), | 343 base::Unretained(device_settings_.get()), |
362 request_label, new_request->render_process_id, | 344 request_label, new_request->render_process_id, |
363 new_request->render_view_id, new_request->options, | 345 new_request->render_view_id, new_request->options, |
364 new_request->security_origin)); | 346 new_request->security_origin)); |
365 } | 347 } |
366 | 348 |
367 (*label) = request_label; | 349 (*label) = request_label; |
368 } | 350 } |
369 | 351 |
| 352 void MediaStreamManager::EnsureDeviceThreadAndListener() { |
| 353 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 354 if (device_thread_.get()) |
| 355 return; |
| 356 |
| 357 device_thread_.reset(new DeviceThread("MediaStreamDeviceThread")); |
| 358 CHECK(device_thread_->Start()); |
| 359 |
| 360 audio_input_device_manager_->Register(this, |
| 361 device_thread_->message_loop_proxy()); |
| 362 video_capture_manager_->Register(this, device_thread_->message_loop_proxy()); |
| 363 } |
| 364 |
370 void MediaStreamManager::Opened(MediaStreamType stream_type, | 365 void MediaStreamManager::Opened(MediaStreamType stream_type, |
371 int capture_session_id) { | 366 int capture_session_id) { |
372 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 367 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
373 | 368 |
374 // Find the request containing this device and mark it as used. | 369 // Find the request containing this device and mark it as used. |
375 DeviceRequest* request = NULL; | 370 DeviceRequest* request = NULL; |
376 StreamDeviceInfoArray* devices = NULL; | 371 StreamDeviceInfoArray* devices = NULL; |
377 std::string label; | 372 std::string label; |
378 for (DeviceRequests::iterator request_it = requests_.begin(); | 373 for (DeviceRequests::iterator request_it = requests_.begin(); |
379 request_it != requests_.end() && request == NULL; ++request_it) { | 374 request_it != requests_.end() && request == NULL; ++request_it) { |
(...skipping 308 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
688 if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) { | 683 if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE) { |
689 return video_capture_manager(); | 684 return video_capture_manager(); |
690 } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) { | 685 } else if (stream_type == content::MEDIA_STREAM_DEVICE_TYPE_AUDIO_CAPTURE) { |
691 return audio_input_device_manager(); | 686 return audio_input_device_manager(); |
692 } | 687 } |
693 NOTREACHED(); | 688 NOTREACHED(); |
694 return NULL; | 689 return NULL; |
695 } | 690 } |
696 | 691 |
697 } // namespace media_stream | 692 } // namespace media_stream |
OLD | NEW |