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/common/media/media_stream_options.h" | 17 #include "content/common/media/media_stream_options.h" |
18 #include "content/public/browser/browser_thread.h" | 18 #include "content/public/browser/browser_thread.h" |
19 #include "content/public/browser/content_browser_client.h" | 19 #include "content/public/browser/content_browser_client.h" |
20 #include "content/public/browser/media_observer.h" | 20 #include "content/public/browser/media_observer.h" |
21 #include "googleurl/src/gurl.h" | 21 #include "googleurl/src/gurl.h" |
22 | 22 |
23 #if defined(OS_WIN) | 23 #if defined(OS_WIN) |
24 #include "base/win/scoped_com_initializer.h" | 24 #include "base/win/scoped_com_initializer.h" |
25 #endif | 25 #endif |
26 | 26 |
27 using content::BrowserThread; | 27 using content::BrowserThread; |
| 28 using content::MediaStreamRequest; |
| 29 |
| 30 namespace { |
| 31 const char kExtensionScheme[] = "chrome-extension"; |
| 32 } // namespace |
28 | 33 |
29 namespace media_stream { | 34 namespace media_stream { |
30 | 35 |
31 // Creates a random label used to identify requests. | 36 // Creates a random label used to identify requests. |
32 static std::string RandomLabel() { | 37 static std::string RandomLabel() { |
33 // An earlier PeerConnection spec, | 38 // An earlier PeerConnection spec, |
34 // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the | 39 // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the |
35 // MediaStream::label alphabet as containing 36 characters from | 40 // 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, | 41 // 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. | 42 // U+0030 to U+0039, U+0041 to U+005A, U+005E to U+007E. |
(...skipping 28 matching lines...) Expand all Loading... |
66 com_initializer_.reset(new base::win::ScopedCOMInitializer( | 71 com_initializer_.reset(new base::win::ScopedCOMInitializer( |
67 base::win::ScopedCOMInitializer::kMTA)); | 72 base::win::ScopedCOMInitializer::kMTA)); |
68 } | 73 } |
69 | 74 |
70 void DeviceThread::CleanUp() { | 75 void DeviceThread::CleanUp() { |
71 com_initializer_.reset(); | 76 com_initializer_.reset(); |
72 } | 77 } |
73 #endif | 78 #endif |
74 | 79 |
75 // TODO(xians): Merge DeviceRequest with MediaStreamRequest. | 80 // TODO(xians): Merge DeviceRequest with MediaStreamRequest. |
76 struct MediaStreamManager::DeviceRequest { | 81 class MediaStreamManager::DeviceRequest { |
77 enum RequestState { | 82 public: |
78 STATE_NOT_REQUESTED = 0, | |
79 STATE_REQUESTED, | |
80 STATE_PENDING_APPROVAL, | |
81 STATE_OPENING, | |
82 STATE_DONE, | |
83 STATE_ERROR | |
84 }; | |
85 | |
86 enum RequestType { | 83 enum RequestType { |
87 GENERATE_STREAM = 0, | 84 GENERATE_STREAM = 0, |
88 ENUMERATE_DEVICES, | 85 ENUMERATE_DEVICES, |
89 OPEN_DEVICE | 86 OPEN_DEVICE |
90 }; | 87 }; |
91 | 88 |
92 DeviceRequest() | 89 DeviceRequest() |
93 : requester(NULL), | 90 : requester(NULL), |
94 state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED), | |
95 type(GENERATE_STREAM), | 91 type(GENERATE_STREAM), |
96 render_process_id(-1), | 92 render_process_id(-1), |
97 render_view_id(-1) { | 93 render_view_id(-1), |
| 94 state_(content::NUM_MEDIA_TYPES, |
| 95 MediaStreamRequest::STATE_NOT_REQUESTED) { |
98 } | 96 } |
99 | 97 |
100 DeviceRequest(MediaStreamRequester* requester, | 98 DeviceRequest(MediaStreamRequester* requester, |
101 const StreamOptions& request_options, | 99 const StreamOptions& request_options, |
102 int render_process_id, | 100 int render_process_id, |
103 int render_view_id, | 101 int render_view_id, |
104 const GURL& request_security_origin) | 102 const GURL& request_security_origin) |
105 : requester(requester), | 103 : requester(requester), |
106 options(request_options), | 104 options(request_options), |
107 state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED), | |
108 type(GENERATE_STREAM), | 105 type(GENERATE_STREAM), |
109 render_process_id(render_process_id), | 106 render_process_id(render_process_id), |
110 render_view_id(render_view_id), | 107 render_view_id(render_view_id), |
111 security_origin(request_security_origin) { | 108 security_origin(request_security_origin), |
| 109 state_(content::NUM_MEDIA_TYPES, |
| 110 MediaStreamRequest::STATE_NOT_REQUESTED) { |
112 DCHECK(requester); | 111 DCHECK(requester); |
113 } | 112 } |
114 | 113 |
115 ~DeviceRequest() {} | 114 ~DeviceRequest() {} |
116 | 115 |
117 MediaStreamRequester* requester; | 116 MediaStreamRequester* requester; |
118 StreamOptions options; | 117 StreamOptions options; |
119 std::vector<RequestState> state; | |
120 RequestType type; | 118 RequestType type; |
121 int render_process_id; | 119 int render_process_id; |
122 int render_view_id; | 120 int render_view_id; |
123 GURL security_origin; | 121 GURL security_origin; |
124 std::string requested_device_id; | 122 std::string requested_device_id; |
125 StreamDeviceInfoArray devices; | 123 StreamDeviceInfoArray devices; |
| 124 |
| 125 // Update the request state and notify observers. |
| 126 void setState(MediaStreamType stream_type, |
| 127 MediaStreamRequest::RequestState new_state) { |
| 128 state_[stream_type] = new_state; |
| 129 |
| 130 content::MediaObserver* media_observer = |
| 131 content::GetContentClient()->browser()->GetMediaObserver(); |
| 132 if (media_observer == NULL || |
| 133 (options.video_type != content::MEDIA_TAB_VIDEO_CAPTURE && |
| 134 options.audio_type != content::MEDIA_TAB_AUDIO_CAPTURE)) |
| 135 return; |
| 136 |
| 137 media_observer->OnMediaRequestStateChanged( |
| 138 render_process_id, render_view_id, |
| 139 content::MediaStreamDevice(stream_type, |
| 140 requested_device_id, |
| 141 requested_device_id), |
| 142 new_state); |
| 143 } |
| 144 |
| 145 MediaStreamRequest::RequestState getState(MediaStreamType stream_type) const { |
| 146 return state_[stream_type]; |
| 147 } |
| 148 |
| 149 private: |
| 150 std::vector<MediaStreamRequest::RequestState> state_; |
126 }; | 151 }; |
127 | 152 |
128 MediaStreamManager::EnumerationCache::EnumerationCache() | 153 MediaStreamManager::EnumerationCache::EnumerationCache() |
129 : valid(false) { | 154 : valid(false) { |
130 } | 155 } |
131 | 156 |
132 MediaStreamManager::EnumerationCache::~EnumerationCache() { | 157 MediaStreamManager::EnumerationCache::~EnumerationCache() { |
133 } | 158 } |
134 | 159 |
135 bool MediaStreamManager::always_use_fake_devices_ = false; | 160 bool MediaStreamManager::always_use_fake_devices_ = false; |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
200 const StreamOptions& options, const std::string& device_id, | 225 const StreamOptions& options, const std::string& device_id, |
201 const GURL& security_origin, std::string* label) { | 226 const GURL& security_origin, std::string* label) { |
202 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 227 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
203 | 228 |
204 // Create a new request based on options. | 229 // Create a new request based on options. |
205 AddRequest(DeviceRequest(requester, options, | 230 AddRequest(DeviceRequest(requester, options, |
206 render_process_id, render_view_id, | 231 render_process_id, render_view_id, |
207 security_origin), | 232 security_origin), |
208 label); | 233 label); |
209 DeviceRequest& request = requests_[*label]; | 234 DeviceRequest& request = requests_[*label]; |
| 235 request.requested_device_id = device_id; |
210 | 236 |
211 // Get user confirmation to use the capture device. | 237 // Get user confirmation to use the capture device. |
212 device_settings_->RequestCaptureDeviceUsage(*label, | 238 device_settings_->RequestCaptureDeviceUsage(*label, |
213 render_process_id, | 239 render_process_id, |
214 render_view_id, | 240 render_view_id, |
215 options, | 241 options, |
216 security_origin); | 242 security_origin); |
| 243 |
| 244 if (!security_origin.SchemeIs(kExtensionScheme) || |
| 245 (options.audio_type != content::MEDIA_TAB_AUDIO_CAPTURE && |
| 246 options.audio_type != content::MEDIA_NO_SERVICE) || |
| 247 (options.video_type != content::MEDIA_TAB_VIDEO_CAPTURE && |
| 248 options.video_type != content::MEDIA_NO_SERVICE)) { |
| 249 LOG(ERROR) << "Invalid request or used tab capture outside extension API."; |
| 250 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
| 251 base::Bind(&MediaStreamManager::CancelGenerateStream, |
| 252 base::Unretained(this), *label)); |
| 253 return; |
| 254 } |
| 255 |
217 // TODO(miu): We should ask the device manager whether a device with id | 256 // TODO(miu): We should ask the device manager whether a device with id |
218 // |device_id| actually exists. Note that no such MediaStreamProvider API for | 257 // |device_id| actually exists. Note that no such MediaStreamProvider API for |
219 // this currently exists. Also, we don't have a user-friendly device name for | 258 // this currently exists. Also, we don't have a user-friendly device name for |
220 // the infobar UI. | 259 // the infobar UI. |
| 260 StreamDeviceInfoArray devices; |
221 if (content::IsAudioMediaType(options.audio_type)) { | 261 if (content::IsAudioMediaType(options.audio_type)) { |
222 request.state[options.audio_type] = DeviceRequest::STATE_PENDING_APPROVAL; | 262 // TODO(justinlin): Updating the state to requested and pending are no-ops |
223 device_settings_->AvailableDevices( | 263 // in terms of the media manager, but these are the state changes we want to |
224 *label, options.audio_type, StreamDeviceInfoArray( | 264 // support in terms of extensions (which is registered as an observer). |
225 1, StreamDeviceInfo(options.audio_type, device_id, device_id, | 265 request.setState(options.audio_type, MediaStreamRequest::STATE_REQUESTED); |
226 false))); | 266 request.setState(options.audio_type, |
| 267 MediaStreamRequest::STATE_PENDING_APPROVAL); |
| 268 devices.push_back( |
| 269 StreamDeviceInfo(options.audio_type, device_id, device_id, false)); |
227 } | 270 } |
228 if (content::IsVideoMediaType(options.video_type)) { | 271 if (content::IsVideoMediaType(options.video_type)) { |
229 request.state[options.video_type] = DeviceRequest::STATE_PENDING_APPROVAL; | 272 request.setState(options.video_type, MediaStreamRequest::STATE_REQUESTED); |
230 device_settings_->AvailableDevices( | 273 request.setState(options.video_type, |
231 *label, options.video_type, StreamDeviceInfoArray( | 274 MediaStreamRequest::STATE_PENDING_APPROVAL); |
232 1, StreamDeviceInfo(options.video_type, device_id, device_id, | 275 devices.push_back( |
233 false))); | 276 StreamDeviceInfo(options.video_type, device_id, device_id, false)); |
234 } | 277 } |
| 278 |
| 279 // Bypass the user authorization dropdown for tab capture. |
| 280 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, |
| 281 base::Bind(&MediaStreamManager::DevicesAccepted, |
| 282 base::Unretained(this), *label, devices)); |
235 } | 283 } |
236 | 284 |
237 void MediaStreamManager::CancelGenerateStream(const std::string& label) { | 285 void MediaStreamManager::CancelGenerateStream(const std::string& label) { |
238 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 286 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
239 | 287 |
240 DeviceRequests::iterator it = requests_.find(label); | 288 DeviceRequests::iterator it = requests_.find(label); |
241 if (it != requests_.end()) { | 289 if (it != requests_.end()) { |
242 // The request isn't complete. | 290 // The request isn't complete. |
243 if (!RequestDone(it->second)) { | 291 if (!RequestDone(it->second)) { |
244 DeviceRequest& request = it->second; | 292 DeviceRequest& request = it->second; |
245 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; | 293 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; |
246 ++i) { | 294 ++i) { |
247 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); | 295 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); |
248 if (request.state[stream_type] != DeviceRequest::STATE_OPENING) { | 296 if (request.getState(stream_type) != |
| 297 MediaStreamRequest::STATE_OPENING) { |
249 continue; | 298 continue; |
250 } | 299 } |
251 for (StreamDeviceInfoArray::const_iterator device_it = | 300 for (StreamDeviceInfoArray::const_iterator device_it = |
252 request.devices.begin(); | 301 request.devices.begin(); |
253 device_it != request.devices.end(); ++device_it) { | 302 device_it != request.devices.end(); ++device_it) { |
254 if (device_it->stream_type == stream_type) { | 303 if (device_it->stream_type == stream_type) { |
255 GetDeviceManager(stream_type)->Close(device_it->session_id); | 304 GetDeviceManager(stream_type)->Close(device_it->session_id); |
256 } | 305 } |
257 } | 306 } |
258 } | 307 } |
(...skipping 14 matching lines...) Expand all Loading... |
273 StopEnumerateDevices(label); | 322 StopEnumerateDevices(label); |
274 return; | 323 return; |
275 } | 324 } |
276 for (StreamDeviceInfoArray::const_iterator device_it = | 325 for (StreamDeviceInfoArray::const_iterator device_it = |
277 it->second.devices.begin(); | 326 it->second.devices.begin(); |
278 device_it != it->second.devices.end(); ++device_it) { | 327 device_it != it->second.devices.end(); ++device_it) { |
279 GetDeviceManager(device_it->stream_type)->Close(device_it->session_id); | 328 GetDeviceManager(device_it->stream_type)->Close(device_it->session_id); |
280 } | 329 } |
281 if (it->second.type == DeviceRequest::GENERATE_STREAM && | 330 if (it->second.type == DeviceRequest::GENERATE_STREAM && |
282 RequestDone(it->second)) { | 331 RequestDone(it->second)) { |
| 332 // Notify observers that this device is being closed. |
| 333 for (int i = content::MEDIA_NO_SERVICE + 1; |
| 334 i != content::NUM_MEDIA_TYPES; ++i) { |
| 335 if (it->second.getState(static_cast<MediaStreamType>(i)) != |
| 336 MediaStreamRequest::STATE_NOT_REQUESTED) |
| 337 it->second.setState(static_cast<MediaStreamType>(i), |
| 338 MediaStreamRequest::STATE_CLOSING); |
| 339 } |
283 NotifyObserverDevicesClosed(&(it->second)); | 340 NotifyObserverDevicesClosed(&(it->second)); |
284 } | 341 } |
285 requests_.erase(it); | 342 requests_.erase(it); |
286 } | 343 } |
287 } | 344 } |
288 | 345 |
289 void MediaStreamManager::EnumerateDevices( | 346 void MediaStreamManager::EnumerateDevices( |
290 MediaStreamRequester* requester, | 347 MediaStreamRequester* requester, |
291 int render_process_id, | 348 int render_process_id, |
292 int render_view_id, | 349 int render_view_id, |
(...skipping 19 matching lines...) Expand all Loading... |
312 } | 369 } |
313 | 370 |
314 DeviceRequest new_request(requester, options, | 371 DeviceRequest new_request(requester, options, |
315 render_process_id, | 372 render_process_id, |
316 render_view_id, | 373 render_view_id, |
317 security_origin); | 374 security_origin); |
318 new_request.type = DeviceRequest::ENUMERATE_DEVICES; | 375 new_request.type = DeviceRequest::ENUMERATE_DEVICES; |
319 | 376 |
320 if (cache->valid) { | 377 if (cache->valid) { |
321 // Cached device list of this type exists. Just send it out. | 378 // Cached device list of this type exists. Just send it out. |
322 new_request.state[type] = DeviceRequest::STATE_REQUESTED; | 379 new_request.setState(type, MediaStreamRequest::STATE_REQUESTED); |
323 AddRequest(new_request, label); | 380 AddRequest(new_request, label); |
324 // Need to post a task since the requester won't have label till | 381 // Need to post a task since the requester won't have label till |
325 // this function returns. | 382 // this function returns. |
326 BrowserThread::PostTask(BrowserThread::IO, | 383 BrowserThread::PostTask(BrowserThread::IO, |
327 FROM_HERE, | 384 FROM_HERE, |
328 base::Bind(&MediaStreamManager::SendCachedDeviceList, | 385 base::Bind(&MediaStreamManager::SendCachedDeviceList, |
329 base::Unretained(this), cache, *label)); | 386 base::Unretained(this), cache, *label)); |
330 } else { | 387 } else { |
331 StartEnumeration(&new_request, label); | 388 StartEnumeration(&new_request, label); |
332 StartMonitoring(); | 389 StartMonitoring(); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
416 | 473 |
417 void MediaStreamManager::StartEnumeration( | 474 void MediaStreamManager::StartEnumeration( |
418 DeviceRequest* new_request, | 475 DeviceRequest* new_request, |
419 std::string* label) { | 476 std::string* label) { |
420 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 477 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
421 | 478 |
422 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; | 479 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; |
423 ++i) { | 480 ++i) { |
424 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); | 481 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); |
425 if (Requested(new_request->options, stream_type)) { | 482 if (Requested(new_request->options, stream_type)) { |
426 new_request->state[stream_type] = DeviceRequest::STATE_REQUESTED; | 483 new_request->setState(stream_type, |
| 484 MediaStreamRequest::STATE_REQUESTED); |
427 DCHECK_GE(active_enumeration_ref_count_[stream_type], 0); | 485 DCHECK_GE(active_enumeration_ref_count_[stream_type], 0); |
428 if (active_enumeration_ref_count_[stream_type] == 0) { | 486 if (active_enumeration_ref_count_[stream_type] == 0) { |
429 ++active_enumeration_ref_count_[stream_type]; | 487 ++active_enumeration_ref_count_[stream_type]; |
430 GetDeviceManager(stream_type)->EnumerateDevices(); | 488 GetDeviceManager(stream_type)->EnumerateDevices(); |
431 } | 489 } |
432 } | 490 } |
433 } | 491 } |
434 | 492 |
435 AddRequest(*new_request, label); | 493 AddRequest(*new_request, label); |
436 } | 494 } |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
495 request = &(request_it->second); | 553 request = &(request_it->second); |
496 break; | 554 break; |
497 } | 555 } |
498 } | 556 } |
499 } | 557 } |
500 if (request == NULL) { | 558 if (request == NULL) { |
501 // The request doesn't exist. | 559 // The request doesn't exist. |
502 return; | 560 return; |
503 } | 561 } |
504 | 562 |
505 DCHECK_NE(request->state[stream_type], DeviceRequest::STATE_REQUESTED); | 563 DCHECK_NE(request->getState(stream_type), |
| 564 MediaStreamRequest::STATE_REQUESTED); |
506 | 565 |
507 // Check if all devices for this stream type are opened. Update the state if | 566 // Check if all devices for this stream type are opened. Update the state if |
508 // they are. | 567 // they are. |
509 for (StreamDeviceInfoArray::iterator device_it = devices->begin(); | 568 for (StreamDeviceInfoArray::iterator device_it = devices->begin(); |
510 device_it != devices->end(); ++device_it) { | 569 device_it != devices->end(); ++device_it) { |
511 if (device_it->stream_type != stream_type) { | 570 if (device_it->stream_type != stream_type) { |
512 continue; | 571 continue; |
513 } | 572 } |
514 if (device_it->in_use == false) { | 573 if (device_it->in_use == false) { |
515 // Wait for more devices to be opened before we're done. | 574 // Wait for more devices to be opened before we're done. |
516 return; | 575 return; |
517 } | 576 } |
518 } | 577 } |
519 request->state[stream_type] = DeviceRequest::STATE_DONE; | 578 |
| 579 request->setState(stream_type, MediaStreamRequest::STATE_DONE); |
520 | 580 |
521 if (!RequestDone(*request)) { | 581 if (!RequestDone(*request)) { |
522 // This stream_type is done, but not the other type. | 582 // This stream_type is done, but not the other type. |
523 return; | 583 return; |
524 } | 584 } |
525 | 585 |
526 switch (request->type) { | 586 switch (request->type) { |
527 case DeviceRequest::OPEN_DEVICE: | 587 case DeviceRequest::OPEN_DEVICE: |
528 request->requester->DeviceOpened(label, devices->front()); | 588 request->requester->DeviceOpened(label, devices->front()); |
529 break; | 589 break; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
576 need_update_clients = true; | 636 need_update_clients = true; |
577 } | 637 } |
578 | 638 |
579 // Publish the result for all requests waiting for device list(s). | 639 // Publish the result for all requests waiting for device list(s). |
580 // Find the requests waiting for this device list, store their labels and | 640 // Find the requests waiting for this device list, store their labels and |
581 // release the iterator before calling device settings. We might get a call | 641 // release the iterator before calling device settings. We might get a call |
582 // back from device_settings that will need to iterate through devices. | 642 // back from device_settings that will need to iterate through devices. |
583 std::list<std::string> label_list; | 643 std::list<std::string> label_list; |
584 for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end(); | 644 for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end(); |
585 ++it) { | 645 ++it) { |
586 if (it->second.state[stream_type] == DeviceRequest::STATE_REQUESTED && | 646 if (it->second.getState(stream_type) == |
| 647 MediaStreamRequest::STATE_REQUESTED && |
587 Requested(it->second.options, stream_type)) { | 648 Requested(it->second.options, stream_type)) { |
588 if (it->second.type != DeviceRequest::ENUMERATE_DEVICES) | 649 if (it->second.type != DeviceRequest::ENUMERATE_DEVICES) |
589 it->second.state[stream_type] = DeviceRequest::STATE_PENDING_APPROVAL; | 650 it->second.setState(stream_type, |
| 651 MediaStreamRequest::STATE_PENDING_APPROVAL); |
590 label_list.push_back(it->first); | 652 label_list.push_back(it->first); |
591 } | 653 } |
592 } | 654 } |
593 for (std::list<std::string>::iterator it = label_list.begin(); | 655 for (std::list<std::string>::iterator it = label_list.begin(); |
594 it != label_list.end(); ++it) { | 656 it != label_list.end(); ++it) { |
595 DeviceRequest& request = requests_[*it]; | 657 DeviceRequest& request = requests_[*it]; |
596 switch (request.type) { | 658 switch (request.type) { |
597 case DeviceRequest::ENUMERATE_DEVICES: | 659 case DeviceRequest::ENUMERATE_DEVICES: |
598 if (need_update_clients) | 660 if (need_update_clients) |
599 request.requester->DevicesEnumerated(*it, devices); | 661 request.requester->DevicesEnumerated(*it, devices); |
600 break; | 662 break; |
601 case DeviceRequest::OPEN_DEVICE: | 663 case DeviceRequest::OPEN_DEVICE: |
602 DCHECK(!request.requested_device_id.empty()); | 664 DCHECK(!request.requested_device_id.empty()); |
603 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); | 665 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); |
604 device_it != devices.end(); ++device_it) { | 666 device_it != devices.end(); ++device_it) { |
605 if (request.requested_device_id == device_it->device_id) { | 667 if (request.requested_device_id == device_it->device_id) { |
606 StreamDeviceInfo device = *device_it; | 668 StreamDeviceInfo device = *device_it; |
607 device.in_use = false; | 669 device.in_use = false; |
608 device.session_id = | 670 device.session_id = |
609 GetDeviceManager(device_it->stream_type)->Open(device); | 671 GetDeviceManager(device_it->stream_type)->Open(device); |
610 request.state[device_it->stream_type] = | 672 request.setState(device_it->stream_type, |
611 DeviceRequest::STATE_OPENING; | 673 MediaStreamRequest::STATE_OPENING); |
612 request.devices.push_back(device); | 674 request.devices.push_back(device); |
613 break; | 675 break; |
614 } | 676 } |
615 } | 677 } |
616 break; | 678 break; |
617 default: | 679 default: |
618 device_settings_->AvailableDevices(*it, stream_type, devices); | 680 device_settings_->AvailableDevices(*it, stream_type, devices); |
619 break; | 681 break; |
620 } | 682 } |
621 } | 683 } |
(...skipping 27 matching lines...) Expand all Loading... |
649 NOTREACHED(); | 711 NOTREACHED(); |
650 continue; | 712 continue; |
651 } | 713 } |
652 if (device_it->stream_type != stream_type || | 714 if (device_it->stream_type != stream_type || |
653 device_it->session_id != capture_session_id) { | 715 device_it->session_id != capture_session_id) { |
654 continue; | 716 continue; |
655 } | 717 } |
656 // We've found the failing device. Find the error case: | 718 // We've found the failing device. Find the error case: |
657 // An error should only be reported to the MediaStreamManager if | 719 // An error should only be reported to the MediaStreamManager if |
658 // the request has not been fulfilled yet. | 720 // the request has not been fulfilled yet. |
659 DCHECK(it->second.state[stream_type] != DeviceRequest::STATE_DONE); | 721 DCHECK(it->second.getState(stream_type) |
660 if (it->second.state[stream_type] != DeviceRequest::STATE_DONE) { | 722 != MediaStreamRequest::STATE_DONE); |
| 723 if (it->second.getState(stream_type) != MediaStreamRequest::STATE_DONE) { |
661 // Request is not done, devices are not opened in this case. | 724 // Request is not done, devices are not opened in this case. |
662 if (devices.size() <= 1) { | 725 if (devices.size() <= 1) { |
663 // 1. Device not opened and no other devices for this request -> | 726 // 1. Device not opened and no other devices for this request -> |
664 // signal stream error and remove the request. | 727 // signal stream error and remove the request. |
665 it->second.requester->StreamGenerationFailed(it->first); | 728 it->second.requester->StreamGenerationFailed(it->first); |
666 requests_.erase(it); | 729 requests_.erase(it); |
667 } else { | 730 } else { |
668 // 2. Not opened but other devices exists for this request -> remove | 731 // 2. Not opened but other devices exists for this request -> remove |
669 // device from list, but don't signal an error. | 732 // device from list, but don't signal an error. |
670 devices.erase(device_it); // NOTE: This invalidates device_it! | 733 devices.erase(device_it); // NOTE: This invalidates device_it! |
(...skipping 23 matching lines...) Expand all Loading... |
694 | 757 |
695 // Process all newly-accepted devices for this request. | 758 // Process all newly-accepted devices for this request. |
696 bool found_audio = false, found_video = false; | 759 bool found_audio = false, found_video = false; |
697 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); | 760 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); |
698 device_it != devices.end(); ++device_it) { | 761 device_it != devices.end(); ++device_it) { |
699 StreamDeviceInfo device_info = *device_it; // Make a copy. | 762 StreamDeviceInfo device_info = *device_it; // Make a copy. |
700 | 763 |
701 // Set in_use to false to be able to track if this device has been | 764 // Set in_use to false to be able to track if this device has been |
702 // opened. in_use might be true if the device type can be used in more | 765 // opened. in_use might be true if the device type can be used in more |
703 // than one session. | 766 // than one session. |
704 DCHECK_EQ(request.state[device_it->stream_type], | 767 DCHECK_EQ(request.getState(device_it->stream_type), |
705 DeviceRequest::STATE_PENDING_APPROVAL); | 768 MediaStreamRequest::STATE_PENDING_APPROVAL); |
706 device_info.in_use = false; | 769 device_info.in_use = false; |
| 770 |
707 device_info.session_id = | 771 device_info.session_id = |
708 GetDeviceManager(device_info.stream_type)->Open(device_info); | 772 GetDeviceManager(device_info.stream_type)->Open(device_info); |
709 request.state[device_it->stream_type] = DeviceRequest::STATE_OPENING; | 773 request.setState(device_it->stream_type, |
| 774 MediaStreamRequest::STATE_OPENING); |
710 request.devices.push_back(device_info); | 775 request.devices.push_back(device_info); |
711 | 776 |
712 if (device_info.stream_type == request.options.audio_type) { | 777 if (device_info.stream_type == request.options.audio_type) { |
713 found_audio = true; | 778 found_audio = true; |
714 } else if (device_info.stream_type == request.options.video_type) { | 779 } else if (device_info.stream_type == request.options.video_type) { |
715 found_video = true; | 780 found_video = true; |
716 } | 781 } |
717 } | 782 } |
718 | 783 |
719 // Check whether we've received all stream types requested. | 784 // Check whether we've received all stream types requested. |
720 if (!found_audio && content::IsAudioMediaType(request.options.audio_type)) { | 785 if (!found_audio && content::IsAudioMediaType(request.options.audio_type)) { |
721 request.state[request.options.audio_type] = DeviceRequest::STATE_ERROR; | 786 request.setState(request.options.audio_type, |
| 787 MediaStreamRequest::STATE_ERROR); |
722 } | 788 } |
723 if (!found_video && content::IsVideoMediaType(request.options.video_type)) { | 789 if (!found_video && content::IsVideoMediaType(request.options.video_type)) { |
724 request.state[request.options.video_type] = DeviceRequest::STATE_ERROR; | 790 request.setState(request.options.video_type, |
| 791 MediaStreamRequest::STATE_ERROR); |
725 } | 792 } |
726 } | 793 } |
727 | 794 |
728 void MediaStreamManager::SettingsError(const std::string& label) { | 795 void MediaStreamManager::SettingsError(const std::string& label) { |
729 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 796 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
730 // Erase this request and report an error. | 797 // Erase this request and report an error. |
731 DeviceRequests::iterator it = requests_.find(label); | 798 DeviceRequests::iterator it = requests_.find(label); |
732 if (it != requests_.end()) { | 799 if (it != requests_.end()) { |
733 DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM); | 800 DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM); |
734 it->second.requester->StreamGenerationFailed(label); | 801 it->second.requester->StreamGenerationFailed(label); |
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
799 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const { | 866 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const { |
800 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 867 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
801 | 868 |
802 const bool requested_audio = | 869 const bool requested_audio = |
803 content::IsAudioMediaType(request.options.audio_type); | 870 content::IsAudioMediaType(request.options.audio_type); |
804 const bool requested_video = | 871 const bool requested_video = |
805 content::IsVideoMediaType(request.options.video_type); | 872 content::IsVideoMediaType(request.options.video_type); |
806 | 873 |
807 const bool audio_done = | 874 const bool audio_done = |
808 !requested_audio || | 875 !requested_audio || |
809 request.state[request.options.audio_type] == DeviceRequest::STATE_DONE || | 876 request.getState(request.options.audio_type) == |
810 request.state[request.options.audio_type] == DeviceRequest::STATE_ERROR; | 877 MediaStreamRequest::STATE_DONE || |
| 878 request.getState(request.options.audio_type) == |
| 879 MediaStreamRequest::STATE_ERROR; |
811 if (!audio_done) { | 880 if (!audio_done) { |
812 return false; | 881 return false; |
813 } | 882 } |
814 | 883 |
815 const bool video_done = | 884 const bool video_done = |
816 !requested_video || | 885 !requested_video || |
817 request.state[request.options.video_type] == DeviceRequest::STATE_DONE || | 886 request.getState(request.options.video_type) == |
818 request.state[request.options.video_type] == DeviceRequest::STATE_ERROR; | 887 MediaStreamRequest::STATE_DONE || |
| 888 request.getState(request.options.video_type) == |
| 889 MediaStreamRequest::STATE_ERROR; |
819 if (!video_done) { | 890 if (!video_done) { |
820 return false; | 891 return false; |
821 } | 892 } |
822 | 893 |
823 for (StreamDeviceInfoArray::const_iterator it = request.devices.begin(); | 894 for (StreamDeviceInfoArray::const_iterator it = request.devices.begin(); |
824 it != request.devices.end(); ++it) { | 895 it != request.devices.end(); ++it) { |
825 if (it->in_use == false) { | 896 if (it->in_use == false) { |
826 return false; | 897 return false; |
827 } | 898 } |
828 } | 899 } |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
892 it != requests_.end(); ++it) { | 963 it != requests_.end(); ++it) { |
893 if (it->second.type == DeviceRequest::ENUMERATE_DEVICES && | 964 if (it->second.type == DeviceRequest::ENUMERATE_DEVICES && |
894 Requested(it->second.options, stream_type)) { | 965 Requested(it->second.options, stream_type)) { |
895 return true; | 966 return true; |
896 } | 967 } |
897 } | 968 } |
898 return false; | 969 return false; |
899 } | 970 } |
900 | 971 |
901 } // namespace media_stream | 972 } // namespace media_stream |
OLD | NEW |