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; |
28 | 29 |
29 namespace media_stream { | 30 namespace media_stream { |
30 | 31 |
31 // Creates a random label used to identify requests. | 32 // Creates a random label used to identify requests. |
32 static std::string RandomLabel() { | 33 static std::string RandomLabel() { |
33 // An earlier PeerConnection spec, | 34 // An earlier PeerConnection spec, |
34 // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the | 35 // http://dev.w3.org/2011/webrtc/editor/webrtc.html, specified the |
35 // MediaStream::label alphabet as containing 36 characters from | 36 // 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, | 37 // 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. | 38 // 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( | 67 com_initializer_.reset(new base::win::ScopedCOMInitializer( |
67 base::win::ScopedCOMInitializer::kMTA)); | 68 base::win::ScopedCOMInitializer::kMTA)); |
68 } | 69 } |
69 | 70 |
70 void DeviceThread::CleanUp() { | 71 void DeviceThread::CleanUp() { |
71 com_initializer_.reset(); | 72 com_initializer_.reset(); |
72 } | 73 } |
73 #endif | 74 #endif |
74 | 75 |
75 // TODO(xians): Merge DeviceRequest with MediaStreamRequest. | 76 // TODO(xians): Merge DeviceRequest with MediaStreamRequest. |
76 struct MediaStreamManager::DeviceRequest { | 77 class MediaStreamManager::DeviceRequest { |
77 enum RequestState { | 78 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 { | 79 enum RequestType { |
87 GENERATE_STREAM = 0, | 80 GENERATE_STREAM = 0, |
88 ENUMERATE_DEVICES, | 81 ENUMERATE_DEVICES, |
89 OPEN_DEVICE | 82 OPEN_DEVICE |
90 }; | 83 }; |
91 | 84 |
92 DeviceRequest() | 85 DeviceRequest() |
93 : requester(NULL), | 86 : requester(NULL), |
94 state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED), | |
95 type(GENERATE_STREAM), | 87 type(GENERATE_STREAM), |
96 render_process_id(-1), | 88 render_process_id(-1), |
97 render_view_id(-1) { | 89 render_view_id(-1), |
| 90 state_(content::NUM_MEDIA_TYPES, |
| 91 MediaStreamRequest::STATE_NOT_REQUESTED) { |
98 } | 92 } |
99 | 93 |
100 DeviceRequest(MediaStreamRequester* requester, | 94 DeviceRequest(MediaStreamRequester* requester, |
101 const StreamOptions& request_options, | 95 const StreamOptions& request_options, |
102 int render_process_id, | 96 int render_process_id, |
103 int render_view_id, | 97 int render_view_id, |
104 const GURL& request_security_origin) | 98 const GURL& request_security_origin) |
105 : requester(requester), | 99 : requester(requester), |
106 options(request_options), | 100 options(request_options), |
107 state(content::NUM_MEDIA_TYPES, STATE_NOT_REQUESTED), | |
108 type(GENERATE_STREAM), | 101 type(GENERATE_STREAM), |
109 render_process_id(render_process_id), | 102 render_process_id(render_process_id), |
110 render_view_id(render_view_id), | 103 render_view_id(render_view_id), |
111 security_origin(request_security_origin) { | 104 security_origin(request_security_origin), |
| 105 state_(content::NUM_MEDIA_TYPES, |
| 106 MediaStreamRequest::STATE_NOT_REQUESTED) { |
112 DCHECK(requester); | 107 DCHECK(requester); |
113 } | 108 } |
114 | 109 |
115 ~DeviceRequest() {} | 110 ~DeviceRequest() {} |
116 | 111 |
117 MediaStreamRequester* requester; | 112 MediaStreamRequester* requester; |
118 StreamOptions options; | 113 StreamOptions options; |
119 std::vector<RequestState> state; | |
120 RequestType type; | 114 RequestType type; |
121 int render_process_id; | 115 int render_process_id; |
122 int render_view_id; | 116 int render_view_id; |
123 GURL security_origin; | 117 GURL security_origin; |
124 std::string requested_device_id; | 118 std::string requested_device_id; |
125 StreamDeviceInfoArray devices; | 119 StreamDeviceInfoArray devices; |
| 120 |
| 121 void setState(MediaStreamType stream_type, |
| 122 MediaStreamRequest::RequestState new_state) { |
| 123 state_[stream_type] = new_state; |
| 124 } |
| 125 |
| 126 MediaStreamRequest::RequestState getState(MediaStreamType stream_type) const { |
| 127 return state_[stream_type]; |
| 128 } |
| 129 |
| 130 private: |
| 131 std::vector<MediaStreamRequest::RequestState> state_; |
126 }; | 132 }; |
127 | 133 |
| 134 // Helper to update the request state and notify observers. |
| 135 static void UpdateRequestState( |
| 136 MediaStreamManager::DeviceRequest* request, |
| 137 MediaStreamType stream_type, |
| 138 const MediaStreamRequest::RequestState new_state) { |
| 139 request->setState(stream_type, new_state); |
| 140 |
| 141 content::MediaObserver* media_observer = |
| 142 content::GetContentClient()->browser()->GetMediaObserver(); |
| 143 if (media_observer == NULL) |
| 144 return; |
| 145 media_observer->OnMediaRequestStateChanged( |
| 146 request->render_process_id, |
| 147 request->render_view_id, |
| 148 content::MediaStreamDevice(stream_type, |
| 149 request->requested_device_id, |
| 150 request->requested_device_id), |
| 151 new_state); |
| 152 } |
| 153 |
128 MediaStreamManager::EnumerationCache::EnumerationCache() | 154 MediaStreamManager::EnumerationCache::EnumerationCache() |
129 : valid(false) { | 155 : valid(false) { |
130 } | 156 } |
131 | 157 |
132 MediaStreamManager::EnumerationCache::~EnumerationCache() { | 158 MediaStreamManager::EnumerationCache::~EnumerationCache() { |
133 } | 159 } |
134 | 160 |
135 bool MediaStreamManager::always_use_fake_devices_ = false; | 161 bool MediaStreamManager::always_use_fake_devices_ = false; |
136 | 162 |
137 // static | 163 // static |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
200 const StreamOptions& options, const std::string& device_id, | 226 const StreamOptions& options, const std::string& device_id, |
201 const GURL& security_origin, std::string* label) { | 227 const GURL& security_origin, std::string* label) { |
202 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 228 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
203 | 229 |
204 // Create a new request based on options. | 230 // Create a new request based on options. |
205 AddRequest(DeviceRequest(requester, options, | 231 AddRequest(DeviceRequest(requester, options, |
206 render_process_id, render_view_id, | 232 render_process_id, render_view_id, |
207 security_origin), | 233 security_origin), |
208 label); | 234 label); |
209 DeviceRequest& request = requests_[*label]; | 235 DeviceRequest& request = requests_[*label]; |
| 236 request.requested_device_id = device_id; |
210 | 237 |
211 // Get user confirmation to use the capture device. | 238 // Get user confirmation to use the capture device. |
212 device_settings_->RequestCaptureDeviceUsage(*label, | 239 device_settings_->RequestCaptureDeviceUsage(*label, |
213 render_process_id, | 240 render_process_id, |
214 render_view_id, | 241 render_view_id, |
215 options, | 242 options, |
216 security_origin); | 243 security_origin); |
217 // TODO(miu): We should ask the device manager whether a device with id | 244 // 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 | 245 // |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 | 246 // this currently exists. Also, we don't have a user-friendly device name for |
220 // the infobar UI. | 247 // the infobar UI. |
221 if (content::IsAudioMediaType(options.audio_type)) { | 248 if (content::IsAudioMediaType(options.audio_type)) { |
222 request.state[options.audio_type] = DeviceRequest::STATE_PENDING_APPROVAL; | 249 UpdateRequestState(&request, options.audio_type, |
223 device_settings_->AvailableDevices( | 250 MediaStreamRequest::STATE_PENDING_APPROVAL); |
224 *label, options.audio_type, StreamDeviceInfoArray( | 251 DevicesAccepted(*label, StreamDeviceInfoArray(1, |
225 1, StreamDeviceInfo(options.audio_type, device_id, device_id, | 252 StreamDeviceInfo(options.audio_type, device_id, device_id, false))); |
226 false))); | |
227 } | 253 } |
228 if (content::IsVideoMediaType(options.video_type)) { | 254 if (content::IsVideoMediaType(options.video_type)) { |
229 request.state[options.video_type] = DeviceRequest::STATE_PENDING_APPROVAL; | 255 UpdateRequestState(&request, options.video_type, |
230 device_settings_->AvailableDevices( | 256 MediaStreamRequest::STATE_PENDING_APPROVAL); |
231 *label, options.video_type, StreamDeviceInfoArray( | 257 DevicesAccepted(*label, StreamDeviceInfoArray(1, |
232 1, StreamDeviceInfo(options.video_type, device_id, device_id, | 258 StreamDeviceInfo(options.video_type, device_id, device_id, false))); |
233 false))); | |
234 } | 259 } |
235 } | 260 } |
236 | 261 |
237 void MediaStreamManager::CancelGenerateStream(const std::string& label) { | 262 void MediaStreamManager::CancelGenerateStream(const std::string& label) { |
238 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 263 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
239 | 264 |
240 DeviceRequests::iterator it = requests_.find(label); | 265 DeviceRequests::iterator it = requests_.find(label); |
241 if (it != requests_.end()) { | 266 if (it != requests_.end()) { |
242 // The request isn't complete. | 267 // The request isn't complete. |
243 if (!RequestDone(it->second)) { | 268 if (!RequestDone(it->second)) { |
244 DeviceRequest& request = it->second; | 269 DeviceRequest& request = it->second; |
245 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; | 270 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; |
246 ++i) { | 271 ++i) { |
247 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); | 272 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); |
248 if (request.state[stream_type] != DeviceRequest::STATE_OPENING) { | 273 if (request.getState(stream_type) != |
| 274 MediaStreamRequest::STATE_OPENING) { |
249 continue; | 275 continue; |
250 } | 276 } |
251 for (StreamDeviceInfoArray::const_iterator device_it = | 277 for (StreamDeviceInfoArray::const_iterator device_it = |
252 request.devices.begin(); | 278 request.devices.begin(); |
253 device_it != request.devices.end(); ++device_it) { | 279 device_it != request.devices.end(); ++device_it) { |
254 if (device_it->stream_type == stream_type) { | 280 if (device_it->stream_type == stream_type) { |
255 GetDeviceManager(stream_type)->Close(device_it->session_id); | 281 GetDeviceManager(stream_type)->Close(device_it->session_id); |
256 } | 282 } |
257 } | 283 } |
258 } | 284 } |
(...skipping 14 matching lines...) Expand all Loading... |
273 StopEnumerateDevices(label); | 299 StopEnumerateDevices(label); |
274 return; | 300 return; |
275 } | 301 } |
276 for (StreamDeviceInfoArray::const_iterator device_it = | 302 for (StreamDeviceInfoArray::const_iterator device_it = |
277 it->second.devices.begin(); | 303 it->second.devices.begin(); |
278 device_it != it->second.devices.end(); ++device_it) { | 304 device_it != it->second.devices.end(); ++device_it) { |
279 GetDeviceManager(device_it->stream_type)->Close(device_it->session_id); | 305 GetDeviceManager(device_it->stream_type)->Close(device_it->session_id); |
280 } | 306 } |
281 if (it->second.type == DeviceRequest::GENERATE_STREAM && | 307 if (it->second.type == DeviceRequest::GENERATE_STREAM && |
282 RequestDone(it->second)) { | 308 RequestDone(it->second)) { |
| 309 // Notify observers that this device is being closed. |
| 310 for (MediaStreamType i = content::MEDIA_NO_SERVICE; |
| 311 i != content::NUM_MEDIA_TYPES; ++i) { |
| 312 if (it->second.getState(i) != MediaStreamRequest::STATE_NOT_REQUESTED) |
| 313 UpdateRequestState(&it->second, i, MediaStreamRequest::STATE_CLOSING); |
| 314 } |
283 NotifyObserverDevicesClosed(&(it->second)); | 315 NotifyObserverDevicesClosed(&(it->second)); |
284 } | 316 } |
285 requests_.erase(it); | 317 requests_.erase(it); |
286 } | 318 } |
287 } | 319 } |
288 | 320 |
289 void MediaStreamManager::EnumerateDevices( | 321 void MediaStreamManager::EnumerateDevices( |
290 MediaStreamRequester* requester, | 322 MediaStreamRequester* requester, |
291 int render_process_id, | 323 int render_process_id, |
292 int render_view_id, | 324 int render_view_id, |
(...skipping 19 matching lines...) Expand all Loading... |
312 } | 344 } |
313 | 345 |
314 DeviceRequest new_request(requester, options, | 346 DeviceRequest new_request(requester, options, |
315 render_process_id, | 347 render_process_id, |
316 render_view_id, | 348 render_view_id, |
317 security_origin); | 349 security_origin); |
318 new_request.type = DeviceRequest::ENUMERATE_DEVICES; | 350 new_request.type = DeviceRequest::ENUMERATE_DEVICES; |
319 | 351 |
320 if (cache->valid) { | 352 if (cache->valid) { |
321 // Cached device list of this type exists. Just send it out. | 353 // Cached device list of this type exists. Just send it out. |
322 new_request.state[type] = DeviceRequest::STATE_REQUESTED; | 354 UpdateRequestState(&new_request, type, |
| 355 MediaStreamRequest::STATE_REQUESTED); |
323 AddRequest(new_request, label); | 356 AddRequest(new_request, label); |
324 // Need to post a task since the requester won't have label till | 357 // Need to post a task since the requester won't have label till |
325 // this function returns. | 358 // this function returns. |
326 BrowserThread::PostTask(BrowserThread::IO, | 359 BrowserThread::PostTask(BrowserThread::IO, |
327 FROM_HERE, | 360 FROM_HERE, |
328 base::Bind(&MediaStreamManager::SendCachedDeviceList, | 361 base::Bind(&MediaStreamManager::SendCachedDeviceList, |
329 base::Unretained(this), cache, *label)); | 362 base::Unretained(this), cache, *label)); |
330 } else { | 363 } else { |
331 StartEnumeration(&new_request, label); | 364 StartEnumeration(&new_request, label); |
332 StartMonitoring(); | 365 StartMonitoring(); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
416 | 449 |
417 void MediaStreamManager::StartEnumeration( | 450 void MediaStreamManager::StartEnumeration( |
418 DeviceRequest* new_request, | 451 DeviceRequest* new_request, |
419 std::string* label) { | 452 std::string* label) { |
420 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 453 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
421 | 454 |
422 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; | 455 for (int i = content::MEDIA_NO_SERVICE + 1; i < content::NUM_MEDIA_TYPES; |
423 ++i) { | 456 ++i) { |
424 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); | 457 const MediaStreamType stream_type = static_cast<MediaStreamType>(i); |
425 if (Requested(new_request->options, stream_type)) { | 458 if (Requested(new_request->options, stream_type)) { |
426 new_request->state[stream_type] = DeviceRequest::STATE_REQUESTED; | 459 UpdateRequestState(new_request, stream_type, |
| 460 MediaStreamRequest::STATE_REQUESTED); |
427 DCHECK_GE(active_enumeration_ref_count_[stream_type], 0); | 461 DCHECK_GE(active_enumeration_ref_count_[stream_type], 0); |
428 if (active_enumeration_ref_count_[stream_type] == 0) { | 462 if (active_enumeration_ref_count_[stream_type] == 0) { |
429 ++active_enumeration_ref_count_[stream_type]; | 463 ++active_enumeration_ref_count_[stream_type]; |
430 GetDeviceManager(stream_type)->EnumerateDevices(); | 464 GetDeviceManager(stream_type)->EnumerateDevices(); |
431 } | 465 } |
432 } | 466 } |
433 } | 467 } |
434 | 468 |
435 AddRequest(*new_request, label); | 469 AddRequest(*new_request, label); |
436 } | 470 } |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
495 request = &(request_it->second); | 529 request = &(request_it->second); |
496 break; | 530 break; |
497 } | 531 } |
498 } | 532 } |
499 } | 533 } |
500 if (request == NULL) { | 534 if (request == NULL) { |
501 // The request doesn't exist. | 535 // The request doesn't exist. |
502 return; | 536 return; |
503 } | 537 } |
504 | 538 |
505 DCHECK_NE(request->state[stream_type], DeviceRequest::STATE_REQUESTED); | 539 DCHECK_NE(request->getState(stream_type), |
| 540 MediaStreamRequest::STATE_REQUESTED); |
506 | 541 |
507 // Check if all devices for this stream type are opened. Update the state if | 542 // Check if all devices for this stream type are opened. Update the state if |
508 // they are. | 543 // they are. |
509 for (StreamDeviceInfoArray::iterator device_it = devices->begin(); | 544 for (StreamDeviceInfoArray::iterator device_it = devices->begin(); |
510 device_it != devices->end(); ++device_it) { | 545 device_it != devices->end(); ++device_it) { |
511 if (device_it->stream_type != stream_type) { | 546 if (device_it->stream_type != stream_type) { |
512 continue; | 547 continue; |
513 } | 548 } |
514 if (device_it->in_use == false) { | 549 if (device_it->in_use == false) { |
515 // Wait for more devices to be opened before we're done. | 550 // Wait for more devices to be opened before we're done. |
516 return; | 551 return; |
517 } | 552 } |
518 } | 553 } |
519 request->state[stream_type] = DeviceRequest::STATE_DONE; | 554 |
| 555 UpdateRequestState(request, stream_type, MediaStreamRequest::STATE_DONE); |
520 | 556 |
521 if (!RequestDone(*request)) { | 557 if (!RequestDone(*request)) { |
522 // This stream_type is done, but not the other type. | 558 // This stream_type is done, but not the other type. |
523 return; | 559 return; |
524 } | 560 } |
525 | 561 |
526 switch (request->type) { | 562 switch (request->type) { |
527 case DeviceRequest::OPEN_DEVICE: | 563 case DeviceRequest::OPEN_DEVICE: |
528 request->requester->DeviceOpened(label, devices->front()); | 564 request->requester->DeviceOpened(label, devices->front()); |
529 break; | 565 break; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
576 need_update_clients = true; | 612 need_update_clients = true; |
577 } | 613 } |
578 | 614 |
579 // Publish the result for all requests waiting for device list(s). | 615 // Publish the result for all requests waiting for device list(s). |
580 // Find the requests waiting for this device list, store their labels and | 616 // 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 | 617 // release the iterator before calling device settings. We might get a call |
582 // back from device_settings that will need to iterate through devices. | 618 // back from device_settings that will need to iterate through devices. |
583 std::list<std::string> label_list; | 619 std::list<std::string> label_list; |
584 for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end(); | 620 for (DeviceRequests::iterator it = requests_.begin(); it != requests_.end(); |
585 ++it) { | 621 ++it) { |
586 if (it->second.state[stream_type] == DeviceRequest::STATE_REQUESTED && | 622 if (it->second.getState(stream_type) == |
| 623 MediaStreamRequest::STATE_REQUESTED && |
587 Requested(it->second.options, stream_type)) { | 624 Requested(it->second.options, stream_type)) { |
588 if (it->second.type != DeviceRequest::ENUMERATE_DEVICES) | 625 if (it->second.type != DeviceRequest::ENUMERATE_DEVICES) |
589 it->second.state[stream_type] = DeviceRequest::STATE_PENDING_APPROVAL; | 626 UpdateRequestState(&it->second, stream_type, |
| 627 MediaStreamRequest::STATE_PENDING_APPROVAL); |
590 label_list.push_back(it->first); | 628 label_list.push_back(it->first); |
591 } | 629 } |
592 } | 630 } |
593 for (std::list<std::string>::iterator it = label_list.begin(); | 631 for (std::list<std::string>::iterator it = label_list.begin(); |
594 it != label_list.end(); ++it) { | 632 it != label_list.end(); ++it) { |
595 DeviceRequest& request = requests_[*it]; | 633 DeviceRequest& request = requests_[*it]; |
596 switch (request.type) { | 634 switch (request.type) { |
597 case DeviceRequest::ENUMERATE_DEVICES: | 635 case DeviceRequest::ENUMERATE_DEVICES: |
598 if (need_update_clients) | 636 if (need_update_clients) |
599 request.requester->DevicesEnumerated(*it, devices); | 637 request.requester->DevicesEnumerated(*it, devices); |
600 break; | 638 break; |
601 case DeviceRequest::OPEN_DEVICE: | 639 case DeviceRequest::OPEN_DEVICE: |
602 DCHECK(!request.requested_device_id.empty()); | 640 DCHECK(!request.requested_device_id.empty()); |
603 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); | 641 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); |
604 device_it != devices.end(); ++device_it) { | 642 device_it != devices.end(); ++device_it) { |
605 if (request.requested_device_id == device_it->device_id) { | 643 if (request.requested_device_id == device_it->device_id) { |
606 StreamDeviceInfo device = *device_it; | 644 StreamDeviceInfo device = *device_it; |
607 device.in_use = false; | 645 device.in_use = false; |
608 device.session_id = | 646 device.session_id = |
609 GetDeviceManager(device_it->stream_type)->Open(device); | 647 GetDeviceManager(device_it->stream_type)->Open(device); |
610 request.state[device_it->stream_type] = | 648 UpdateRequestState(&request, device_it->stream_type, |
611 DeviceRequest::STATE_OPENING; | 649 MediaStreamRequest::STATE_OPENING); |
612 request.devices.push_back(device); | 650 request.devices.push_back(device); |
613 break; | 651 break; |
614 } | 652 } |
615 } | 653 } |
616 break; | 654 break; |
617 default: | 655 default: |
618 device_settings_->AvailableDevices(*it, stream_type, devices); | 656 device_settings_->AvailableDevices(*it, stream_type, devices); |
619 break; | 657 break; |
620 } | 658 } |
621 } | 659 } |
(...skipping 27 matching lines...) Expand all Loading... |
649 NOTREACHED(); | 687 NOTREACHED(); |
650 continue; | 688 continue; |
651 } | 689 } |
652 if (device_it->stream_type != stream_type || | 690 if (device_it->stream_type != stream_type || |
653 device_it->session_id != capture_session_id) { | 691 device_it->session_id != capture_session_id) { |
654 continue; | 692 continue; |
655 } | 693 } |
656 // We've found the failing device. Find the error case: | 694 // We've found the failing device. Find the error case: |
657 // An error should only be reported to the MediaStreamManager if | 695 // An error should only be reported to the MediaStreamManager if |
658 // the request has not been fulfilled yet. | 696 // the request has not been fulfilled yet. |
659 DCHECK(it->second.state[stream_type] != DeviceRequest::STATE_DONE); | 697 DCHECK(it->second.getState(stream_type) |
660 if (it->second.state[stream_type] != DeviceRequest::STATE_DONE) { | 698 != MediaStreamRequest::STATE_DONE); |
| 699 if (it->second.getState(stream_type) != MediaStreamRequest::STATE_DONE) { |
661 // Request is not done, devices are not opened in this case. | 700 // Request is not done, devices are not opened in this case. |
662 if (devices.size() <= 1) { | 701 if (devices.size() <= 1) { |
663 // 1. Device not opened and no other devices for this request -> | 702 // 1. Device not opened and no other devices for this request -> |
664 // signal stream error and remove the request. | 703 // signal stream error and remove the request. |
665 it->second.requester->StreamGenerationFailed(it->first); | 704 it->second.requester->StreamGenerationFailed(it->first); |
666 requests_.erase(it); | 705 requests_.erase(it); |
667 } else { | 706 } else { |
668 // 2. Not opened but other devices exists for this request -> remove | 707 // 2. Not opened but other devices exists for this request -> remove |
669 // device from list, but don't signal an error. | 708 // device from list, but don't signal an error. |
670 devices.erase(device_it); // NOTE: This invalidates device_it! | 709 devices.erase(device_it); // NOTE: This invalidates device_it! |
(...skipping 23 matching lines...) Expand all Loading... |
694 | 733 |
695 // Process all newly-accepted devices for this request. | 734 // Process all newly-accepted devices for this request. |
696 bool found_audio = false, found_video = false; | 735 bool found_audio = false, found_video = false; |
697 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); | 736 for (StreamDeviceInfoArray::const_iterator device_it = devices.begin(); |
698 device_it != devices.end(); ++device_it) { | 737 device_it != devices.end(); ++device_it) { |
699 StreamDeviceInfo device_info = *device_it; // Make a copy. | 738 StreamDeviceInfo device_info = *device_it; // Make a copy. |
700 | 739 |
701 // Set in_use to false to be able to track if this device has been | 740 // 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 | 741 // opened. in_use might be true if the device type can be used in more |
703 // than one session. | 742 // than one session. |
704 DCHECK_EQ(request.state[device_it->stream_type], | 743 DCHECK_EQ(request.getState(device_it->stream_type), |
705 DeviceRequest::STATE_PENDING_APPROVAL); | 744 MediaStreamRequest::STATE_PENDING_APPROVAL); |
706 device_info.in_use = false; | 745 device_info.in_use = false; |
| 746 |
707 device_info.session_id = | 747 device_info.session_id = |
708 GetDeviceManager(device_info.stream_type)->Open(device_info); | 748 GetDeviceManager(device_info.stream_type)->Open(device_info); |
709 request.state[device_it->stream_type] = DeviceRequest::STATE_OPENING; | 749 UpdateRequestState(&request, device_it->stream_type, |
| 750 MediaStreamRequest::STATE_OPENING); |
710 request.devices.push_back(device_info); | 751 request.devices.push_back(device_info); |
711 | 752 |
712 if (device_info.stream_type == request.options.audio_type) { | 753 if (device_info.stream_type == request.options.audio_type) { |
713 found_audio = true; | 754 found_audio = true; |
714 } else if (device_info.stream_type == request.options.video_type) { | 755 } else if (device_info.stream_type == request.options.video_type) { |
715 found_video = true; | 756 found_video = true; |
716 } | 757 } |
717 } | 758 } |
718 | 759 |
719 // Check whether we've received all stream types requested. | 760 // Check whether we've received all stream types requested. |
720 if (!found_audio && content::IsAudioMediaType(request.options.audio_type)) { | 761 if (!found_audio && content::IsAudioMediaType(request.options.audio_type)) { |
721 request.state[request.options.audio_type] = DeviceRequest::STATE_ERROR; | 762 UpdateRequestState(&request, request.options.audio_type, |
| 763 MediaStreamRequest::STATE_ERROR); |
722 } | 764 } |
723 if (!found_video && content::IsVideoMediaType(request.options.video_type)) { | 765 if (!found_video && content::IsVideoMediaType(request.options.video_type)) { |
724 request.state[request.options.video_type] = DeviceRequest::STATE_ERROR; | 766 UpdateRequestState(&request, request.options.video_type, |
| 767 MediaStreamRequest::STATE_ERROR); |
725 } | 768 } |
726 } | 769 } |
727 | 770 |
728 void MediaStreamManager::SettingsError(const std::string& label) { | 771 void MediaStreamManager::SettingsError(const std::string& label) { |
729 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 772 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
730 // Erase this request and report an error. | 773 // Erase this request and report an error. |
731 DeviceRequests::iterator it = requests_.find(label); | 774 DeviceRequests::iterator it = requests_.find(label); |
732 if (it != requests_.end()) { | 775 if (it != requests_.end()) { |
733 DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM); | 776 DCHECK_EQ(it->second.type, DeviceRequest::GENERATE_STREAM); |
734 it->second.requester->StreamGenerationFailed(label); | 777 it->second.requester->StreamGenerationFailed(label); |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
798 | 841 |
799 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const { | 842 bool MediaStreamManager::RequestDone(const DeviceRequest& request) const { |
800 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 843 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
801 | 844 |
802 const bool requested_audio = | 845 const bool requested_audio = |
803 content::IsAudioMediaType(request.options.audio_type); | 846 content::IsAudioMediaType(request.options.audio_type); |
804 const bool requested_video = | 847 const bool requested_video = |
805 content::IsVideoMediaType(request.options.video_type); | 848 content::IsVideoMediaType(request.options.video_type); |
806 | 849 |
807 const bool audio_done = | 850 const bool audio_done = |
808 !requested_audio || | 851 !requested_audio || request.getState(request.options.audio_type) == |
809 request.state[request.options.audio_type] == DeviceRequest::STATE_DONE || | 852 MediaStreamRequest::STATE_DONE || |
810 request.state[request.options.audio_type] == DeviceRequest::STATE_ERROR; | 853 request.getState(request.options.audio_type) == |
| 854 MediaStreamRequest::STATE_ERROR; |
811 if (!audio_done) { | 855 if (!audio_done) { |
812 return false; | 856 return false; |
813 } | 857 } |
814 | 858 |
815 const bool video_done = | 859 const bool video_done = |
816 !requested_video || | 860 !requested_video || request.getState(request.options.video_type) == |
817 request.state[request.options.video_type] == DeviceRequest::STATE_DONE || | 861 MediaStreamRequest::STATE_DONE || |
818 request.state[request.options.video_type] == DeviceRequest::STATE_ERROR; | 862 request.getState(request.options.video_type) == |
| 863 MediaStreamRequest::STATE_ERROR; |
819 if (!video_done) { | 864 if (!video_done) { |
820 return false; | 865 return false; |
821 } | 866 } |
822 | 867 |
823 for (StreamDeviceInfoArray::const_iterator it = request.devices.begin(); | 868 for (StreamDeviceInfoArray::const_iterator it = request.devices.begin(); |
824 it != request.devices.end(); ++it) { | 869 it != request.devices.end(); ++it) { |
825 if (it->in_use == false) { | 870 if (it->in_use == false) { |
826 return false; | 871 return false; |
827 } | 872 } |
828 } | 873 } |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
892 it != requests_.end(); ++it) { | 937 it != requests_.end(); ++it) { |
893 if (it->second.type == DeviceRequest::ENUMERATE_DEVICES && | 938 if (it->second.type == DeviceRequest::ENUMERATE_DEVICES && |
894 Requested(it->second.options, stream_type)) { | 939 Requested(it->second.options, stream_type)) { |
895 return true; | 940 return true; |
896 } | 941 } |
897 } | 942 } |
898 return false; | 943 return false; |
899 } | 944 } |
900 | 945 |
901 } // namespace media_stream | 946 } // namespace media_stream |
OLD | NEW |