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/video_capture_manager.h" | 5 #include "content/browser/renderer_host/media/video_capture_manager.h" |
6 | 6 |
7 #include <set> | 7 #include <set> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/command_line.h" | 10 #include "base/command_line.h" |
11 #include "base/logging.h" | 11 #include "base/logging.h" |
12 #include "base/message_loop/message_loop.h" | 12 #include "base/message_loop/message_loop.h" |
13 #include "base/stl_util.h" | 13 #include "base/stl_util.h" |
| 14 #include "base/task_runner_util.h" |
14 #include "base/threading/sequenced_worker_pool.h" | 15 #include "base/threading/sequenced_worker_pool.h" |
15 #include "content/browser/renderer_host/media/video_capture_controller.h" | 16 #include "content/browser/renderer_host/media/video_capture_controller.h" |
16 #include "content/browser/renderer_host/media/video_capture_controller_event_han
dler.h" | 17 #include "content/browser/renderer_host/media/video_capture_controller_event_han
dler.h" |
17 #include "content/browser/renderer_host/media/web_contents_video_capture_device.
h" | 18 #include "content/browser/renderer_host/media/web_contents_video_capture_device.
h" |
18 #include "content/public/browser/browser_thread.h" | 19 #include "content/public/browser/browser_thread.h" |
19 #include "content/public/common/content_switches.h" | 20 #include "content/public/common/content_switches.h" |
20 #include "content/public/common/desktop_media_id.h" | 21 #include "content/public/common/desktop_media_id.h" |
21 #include "content/public/common/media_stream_request.h" | 22 #include "content/public/common/media_stream_request.h" |
22 #include "media/base/media_switches.h" | 23 #include "media/base/media_switches.h" |
23 #include "media/base/scoped_histogram_timer.h" | 24 #include "media/base/scoped_histogram_timer.h" |
(...skipping 13 matching lines...) Expand all Loading... |
37 VideoCaptureManager::DeviceEntry::DeviceEntry( | 38 VideoCaptureManager::DeviceEntry::DeviceEntry( |
38 MediaStreamType stream_type, | 39 MediaStreamType stream_type, |
39 const std::string& id, | 40 const std::string& id, |
40 scoped_ptr<VideoCaptureController> controller) | 41 scoped_ptr<VideoCaptureController> controller) |
41 : stream_type(stream_type), | 42 : stream_type(stream_type), |
42 id(id), | 43 id(id), |
43 video_capture_controller(controller.Pass()) {} | 44 video_capture_controller(controller.Pass()) {} |
44 | 45 |
45 VideoCaptureManager::DeviceEntry::~DeviceEntry() {} | 46 VideoCaptureManager::DeviceEntry::~DeviceEntry() {} |
46 | 47 |
| 48 VideoCaptureManager::DeviceInfo::DeviceInfo() {} |
| 49 |
| 50 VideoCaptureManager::DeviceInfo::DeviceInfo( |
| 51 const media::VideoCaptureDevice::Name& name, |
| 52 const media::VideoCaptureFormats& supported_formats) |
| 53 : name(name), |
| 54 supported_formats(supported_formats) {} |
| 55 |
| 56 VideoCaptureManager::DeviceInfo::~DeviceInfo() {} |
| 57 |
47 VideoCaptureManager::VideoCaptureManager() | 58 VideoCaptureManager::VideoCaptureManager() |
48 : listener_(NULL), | 59 : listener_(NULL), |
49 new_capture_session_id_(1), | 60 new_capture_session_id_(1), |
50 artificial_device_source_for_testing_ (DISABLED) { | 61 artificial_device_source_for_testing_(DISABLED) { |
51 } | 62 } |
52 | 63 |
53 VideoCaptureManager::~VideoCaptureManager() { | 64 VideoCaptureManager::~VideoCaptureManager() { |
54 DCHECK(devices_.empty()); | 65 DCHECK(devices_.empty()); |
55 } | 66 } |
56 | 67 |
57 void VideoCaptureManager::Register(MediaStreamProviderListener* listener, | 68 void VideoCaptureManager::Register(MediaStreamProviderListener* listener, |
58 base::MessageLoopProxy* device_thread_loop) { | 69 base::MessageLoopProxy* device_thread_loop) { |
59 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 70 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
60 DCHECK(!listener_); | 71 DCHECK(!listener_); |
61 DCHECK(!device_loop_.get()); | 72 DCHECK(!device_loop_.get()); |
62 listener_ = listener; | 73 listener_ = listener; |
63 device_loop_ = device_thread_loop; | 74 device_loop_ = device_thread_loop; |
64 } | 75 } |
65 | 76 |
66 void VideoCaptureManager::Unregister() { | 77 void VideoCaptureManager::Unregister() { |
67 DCHECK(listener_); | 78 DCHECK(listener_); |
68 listener_ = NULL; | 79 listener_ = NULL; |
69 } | 80 } |
70 | 81 |
71 void VideoCaptureManager::EnumerateDevices(MediaStreamType stream_type) { | 82 void VideoCaptureManager::EnumerateDevices(MediaStreamType stream_type) { |
72 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 83 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
73 DVLOG(1) << "VideoCaptureManager::EnumerateDevices, type " << stream_type; | 84 DVLOG(1) << "VideoCaptureManager::EnumerateDevices, type " << stream_type; |
74 DCHECK(listener_); | 85 DCHECK(listener_); |
75 base::PostTaskAndReplyWithResult( | 86 base::PostTaskAndReplyWithResult( |
76 device_loop_, FROM_HERE, | 87 device_loop_, FROM_HERE, |
77 base::Bind(&VideoCaptureManager::GetAvailableDevicesOnDeviceThread, this, | 88 base::Bind(&VideoCaptureManager::GetAvailableDevicesInfoOnDeviceThread, |
78 stream_type), | 89 this, stream_type, devices_info_cache_), |
79 base::Bind(&VideoCaptureManager::OnDevicesEnumerated, this, stream_type)); | 90 base::Bind(&VideoCaptureManager::OnDevicesInfoEnumerated, this, |
| 91 stream_type)); |
80 } | 92 } |
81 | 93 |
82 int VideoCaptureManager::Open(const StreamDeviceInfo& device_info) { | 94 int VideoCaptureManager::Open(const StreamDeviceInfo& device_info) { |
83 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 95 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
84 DCHECK(listener_); | 96 DCHECK(listener_); |
85 | 97 |
86 // Generate a new id for the session being opened. | 98 // Generate a new id for the session being opened. |
87 const int capture_session_id = new_capture_session_id_++; | 99 const int capture_session_id = new_capture_session_id_++; |
88 | 100 |
89 DCHECK(sessions_.find(capture_session_id) == sessions_.end()); | 101 DCHECK(sessions_.find(capture_session_id) == sessions_.end()); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
147 scoped_ptr<media::VideoCaptureDevice::Client> device_client) { | 159 scoped_ptr<media::VideoCaptureDevice::Client> device_client) { |
148 SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime"); | 160 SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime"); |
149 DCHECK(IsOnDeviceThread()); | 161 DCHECK(IsOnDeviceThread()); |
150 | 162 |
151 scoped_ptr<media::VideoCaptureDevice> video_capture_device; | 163 scoped_ptr<media::VideoCaptureDevice> video_capture_device; |
152 switch (entry->stream_type) { | 164 switch (entry->stream_type) { |
153 case MEDIA_DEVICE_VIDEO_CAPTURE: { | 165 case MEDIA_DEVICE_VIDEO_CAPTURE: { |
154 // We look up the device id from the renderer in our local enumeration | 166 // We look up the device id from the renderer in our local enumeration |
155 // since the renderer does not have all the information that might be | 167 // since the renderer does not have all the information that might be |
156 // held in the browser-side VideoCaptureDevice::Name structure. | 168 // held in the browser-side VideoCaptureDevice::Name structure. |
157 media::VideoCaptureDevice::Name* found = | 169 DeviceInfo* found = FindDeviceInfoById(entry->id, devices_info_cache_); |
158 video_capture_devices_.FindById(entry->id); | |
159 if (found) { | 170 if (found) { |
160 switch (artificial_device_source_for_testing_) { | 171 switch (artificial_device_source_for_testing_) { |
161 case DISABLED: | 172 case DISABLED: |
162 video_capture_device.reset( | 173 video_capture_device.reset( |
163 media::VideoCaptureDevice::Create(*found)); | 174 media::VideoCaptureDevice::Create(found->name)); |
164 break; | 175 break; |
165 case TEST_PATTERN: | 176 case TEST_PATTERN: |
166 video_capture_device.reset( | 177 video_capture_device.reset( |
167 media::FakeVideoCaptureDevice::Create(*found)); | 178 media::FakeVideoCaptureDevice::Create(found->name)); |
168 break; | 179 break; |
169 case Y4M_FILE: | 180 case Y4M_FILE: |
170 video_capture_device.reset( | 181 video_capture_device.reset( |
171 media::FileVideoCaptureDevice::Create(*found)); | 182 media::FileVideoCaptureDevice::Create(found->name)); |
172 break; | 183 break; |
173 } | 184 } |
174 } | 185 } |
175 break; | 186 break; |
176 } | 187 } |
177 case MEDIA_TAB_VIDEO_CAPTURE: { | 188 case MEDIA_TAB_VIDEO_CAPTURE: { |
178 video_capture_device.reset( | 189 video_capture_device.reset( |
179 WebContentsVideoCaptureDevice::Create(entry->id)); | 190 WebContentsVideoCaptureDevice::Create(entry->id)); |
180 break; | 191 break; |
181 } | 192 } |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
264 | 275 |
265 // Detach client from controller. | 276 // Detach client from controller. |
266 int session_id = controller->RemoveClient(client_id, client_handler); | 277 int session_id = controller->RemoveClient(client_id, client_handler); |
267 DVLOG(1) << "VideoCaptureManager::StopCaptureForClient, session_id = " | 278 DVLOG(1) << "VideoCaptureManager::StopCaptureForClient, session_id = " |
268 << session_id; | 279 << session_id; |
269 | 280 |
270 // If controller has no more clients, delete controller and device. | 281 // If controller has no more clients, delete controller and device. |
271 DestroyDeviceEntryIfNoClients(entry); | 282 DestroyDeviceEntryIfNoClients(entry); |
272 } | 283 } |
273 | 284 |
| 285 void VideoCaptureManager::GetDeviceSupportedFormats( |
| 286 int capture_session_id, |
| 287 media::VideoCaptureFormats* supported_formats) { |
| 288 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| 289 supported_formats->clear(); |
| 290 |
| 291 std::map<int, MediaStreamDevice>::iterator it = |
| 292 sessions_.find(capture_session_id); |
| 293 DCHECK(it != sessions_.end()); |
| 294 DVLOG(1) << "GetDeviceSupportedFormats for device: " << it->second.name; |
| 295 |
| 296 DeviceInfo* device_in_use = |
| 297 FindDeviceInfoById(it->second.id, devices_info_cache_); |
| 298 if (device_in_use) { |
| 299 DeviceEntry* const existing_device = |
| 300 GetDeviceEntryForMediaStreamDevice(it->second); |
| 301 if (!existing_device) { |
| 302 // If the device is not in use, return all its cached supported formats. |
| 303 *supported_formats = device_in_use->supported_formats; |
| 304 return; |
| 305 } |
| 306 // Otherwise, get the video capture parameters in use from the controller |
| 307 // associated to the device. |
| 308 supported_formats->push_back( |
| 309 existing_device->video_capture_controller->GetVideoCaptureFormat()); |
| 310 } |
| 311 } |
| 312 |
274 void VideoCaptureManager::DoStopDeviceOnDeviceThread(DeviceEntry* entry) { | 313 void VideoCaptureManager::DoStopDeviceOnDeviceThread(DeviceEntry* entry) { |
275 SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StopDeviceTime"); | 314 SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StopDeviceTime"); |
276 DCHECK(IsOnDeviceThread()); | 315 DCHECK(IsOnDeviceThread()); |
277 if (entry->video_capture_device) { | 316 if (entry->video_capture_device) { |
278 entry->video_capture_device->StopAndDeAllocate(); | 317 entry->video_capture_device->StopAndDeAllocate(); |
279 } | 318 } |
280 entry->video_capture_device.reset(); | 319 entry->video_capture_device.reset(); |
281 } | 320 } |
282 | 321 |
283 void VideoCaptureManager::OnOpened(MediaStreamType stream_type, | 322 void VideoCaptureManager::OnOpened(MediaStreamType stream_type, |
284 int capture_session_id) { | 323 int capture_session_id) { |
285 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 324 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
286 if (!listener_) { | 325 if (!listener_) { |
287 // Listener has been removed. | 326 // Listener has been removed. |
288 return; | 327 return; |
289 } | 328 } |
290 listener_->Opened(stream_type, capture_session_id); | 329 listener_->Opened(stream_type, capture_session_id); |
291 } | 330 } |
292 | 331 |
293 void VideoCaptureManager::OnClosed(MediaStreamType stream_type, | 332 void VideoCaptureManager::OnClosed(MediaStreamType stream_type, |
294 int capture_session_id) { | 333 int capture_session_id) { |
295 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 334 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
296 if (!listener_) { | 335 if (!listener_) { |
297 // Listener has been removed. | 336 // Listener has been removed. |
298 return; | 337 return; |
299 } | 338 } |
300 listener_->Closed(stream_type, capture_session_id); | 339 listener_->Closed(stream_type, capture_session_id); |
301 } | 340 } |
302 | 341 |
303 void VideoCaptureManager::OnDevicesEnumerated( | 342 void VideoCaptureManager::OnDevicesInfoEnumerated( |
304 MediaStreamType stream_type, | 343 MediaStreamType stream_type, |
305 const media::VideoCaptureDevice::Names& device_names) { | 344 const DeviceInfos& new_devices_info_cache) { |
306 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 345 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
307 | 346 |
308 if (!listener_) { | 347 if (!listener_) { |
309 // Listener has been removed. | 348 // Listener has been removed. |
310 return; | 349 return; |
311 } | 350 } |
| 351 devices_info_cache_ = new_devices_info_cache; |
312 | 352 |
313 // Transform from VCD::Name to StreamDeviceInfo. | 353 // Walk the |devices_info_cache_| and transform from VCD::Name to |
| 354 // StreamDeviceInfo for return purposes. |
314 StreamDeviceInfoArray devices; | 355 StreamDeviceInfoArray devices; |
315 for (media::VideoCaptureDevice::Names::const_iterator it = | 356 for (DeviceInfos::const_iterator it = devices_info_cache_.begin(); |
316 device_names.begin(); it != device_names.end(); ++it) { | 357 it != devices_info_cache_.end(); ++it) { |
317 devices.push_back(StreamDeviceInfo( | 358 devices.push_back(StreamDeviceInfo( |
318 stream_type, it->GetNameAndModel(), it->id())); | 359 stream_type, it->name.GetNameAndModel(), it->name.id())); |
319 } | 360 } |
320 | |
321 listener_->DevicesEnumerated(stream_type, devices); | 361 listener_->DevicesEnumerated(stream_type, devices); |
322 } | 362 } |
323 | 363 |
324 bool VideoCaptureManager::IsOnDeviceThread() const { | 364 bool VideoCaptureManager::IsOnDeviceThread() const { |
325 return device_loop_->BelongsToCurrentThread(); | 365 return device_loop_->BelongsToCurrentThread(); |
326 } | 366 } |
327 | 367 |
328 media::VideoCaptureDevice::Names | 368 VideoCaptureManager::DeviceInfos |
329 VideoCaptureManager::GetAvailableDevicesOnDeviceThread( | 369 VideoCaptureManager::GetAvailableDevicesInfoOnDeviceThread( |
330 MediaStreamType stream_type) { | 370 MediaStreamType stream_type, |
| 371 const DeviceInfos& old_device_info_cache) { |
331 SCOPED_UMA_HISTOGRAM_TIMER( | 372 SCOPED_UMA_HISTOGRAM_TIMER( |
332 "Media.VideoCaptureManager.GetAvailableDevicesTime"); | 373 "Media.VideoCaptureManager.GetAvailableDevicesInfoOnDeviceThreadTime"); |
333 DCHECK(IsOnDeviceThread()); | 374 DCHECK(IsOnDeviceThread()); |
334 media::VideoCaptureDevice::Names result; | 375 media::VideoCaptureDevice::Names names_snapshot; |
335 | |
336 switch (stream_type) { | 376 switch (stream_type) { |
337 case MEDIA_DEVICE_VIDEO_CAPTURE: | 377 case MEDIA_DEVICE_VIDEO_CAPTURE: |
338 // Cache the latest enumeration of video capture devices. | 378 // Cache the latest enumeration of video capture devices. |
339 // We'll refer to this list again in OnOpen to avoid having to | 379 // We'll refer to this list again in OnOpen to avoid having to |
340 // enumerate the devices again. | 380 // enumerate the devices again. |
341 switch (artificial_device_source_for_testing_) { | 381 switch (artificial_device_source_for_testing_) { |
342 case DISABLED: | 382 case DISABLED: |
343 media::VideoCaptureDevice::GetDeviceNames(&result); | 383 media::VideoCaptureDevice::GetDeviceNames(&names_snapshot); |
344 break; | 384 break; |
345 case TEST_PATTERN: | 385 case TEST_PATTERN: |
346 media::FakeVideoCaptureDevice::GetDeviceNames(&result); | 386 media::FakeVideoCaptureDevice::GetDeviceNames(&names_snapshot); |
347 break; | 387 break; |
348 case Y4M_FILE: | 388 case Y4M_FILE: |
349 media::FileVideoCaptureDevice::GetDeviceNames(&result); | 389 media::FileVideoCaptureDevice::GetDeviceNames(&names_snapshot); |
350 break; | 390 break; |
351 } | 391 } |
352 | |
353 // TODO(nick): The correctness of device start depends on this cache being | |
354 // maintained, but it seems a little odd to keep a cache here. Can we | |
355 // eliminate it? | |
356 video_capture_devices_ = result; | |
357 break; | 392 break; |
358 | 393 |
359 case MEDIA_DESKTOP_VIDEO_CAPTURE: | 394 case MEDIA_DESKTOP_VIDEO_CAPTURE: |
360 // Do nothing. | 395 // Do nothing. |
361 break; | 396 break; |
362 | 397 |
363 default: | 398 default: |
364 NOTREACHED(); | 399 NOTREACHED(); |
365 break; | 400 break; |
366 } | 401 } |
367 return result; | 402 |
| 403 // Construct |new_devices_info_cache| with the cached devices that are still |
| 404 // present in the system, and remove their names from |names_snapshot|, so we |
| 405 // keep there the truly new devices. |
| 406 DeviceInfos new_devices_info_cache; |
| 407 for (DeviceInfos::const_iterator it_device_info = |
| 408 old_device_info_cache.begin(); |
| 409 it_device_info != old_device_info_cache.end(); ++it_device_info) { |
| 410 for (media::VideoCaptureDevice::Names::iterator it = |
| 411 names_snapshot.begin(); |
| 412 it != names_snapshot.end(); ++it) { |
| 413 if (it_device_info->name.id() == it->id()) { |
| 414 new_devices_info_cache.push_back(*it_device_info); |
| 415 names_snapshot.erase(it); |
| 416 break; |
| 417 } |
| 418 } |
| 419 } |
| 420 |
| 421 // Get the supported capture formats for the new devices in |names_snapshot|. |
| 422 for (media::VideoCaptureDevice::Names::const_iterator it = |
| 423 names_snapshot.begin(); |
| 424 it != names_snapshot.end(); ++it) { |
| 425 media::VideoCaptureFormats supported_formats; |
| 426 DeviceInfo device_info(*it, media::VideoCaptureFormats()); |
| 427 switch (artificial_device_source_for_testing_) { |
| 428 case DISABLED: |
| 429 media::VideoCaptureDevice::GetDeviceSupportedFormats( |
| 430 *it, &(device_info.supported_formats)); |
| 431 break; |
| 432 case TEST_PATTERN: |
| 433 media::FakeVideoCaptureDevice::GetDeviceSupportedFormats( |
| 434 *it, &(device_info.supported_formats)); |
| 435 break; |
| 436 case Y4M_FILE: |
| 437 media::FileVideoCaptureDevice::GetDeviceSupportedFormats( |
| 438 *it, &(device_info.supported_formats)); |
| 439 break; |
| 440 } |
| 441 new_devices_info_cache.push_back(device_info); |
| 442 } |
| 443 return new_devices_info_cache; |
368 } | 444 } |
369 | 445 |
370 VideoCaptureManager::DeviceEntry* | 446 VideoCaptureManager::DeviceEntry* |
371 VideoCaptureManager::GetDeviceEntryForMediaStreamDevice( | 447 VideoCaptureManager::GetDeviceEntryForMediaStreamDevice( |
372 const MediaStreamDevice& device_info) { | 448 const MediaStreamDevice& device_info) { |
373 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 449 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
374 | 450 |
375 for (DeviceEntries::iterator it = devices_.begin(); | 451 for (DeviceEntries::iterator it = devices_.begin(); |
376 it != devices_.end(); ++it) { | 452 it != devices_.end(); ++it) { |
377 DeviceEntry* device = *it; | 453 DeviceEntry* device = *it; |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
423 std::map<int, MediaStreamDevice>::iterator session_it = | 499 std::map<int, MediaStreamDevice>::iterator session_it = |
424 sessions_.find(capture_session_id); | 500 sessions_.find(capture_session_id); |
425 if (session_it == sessions_.end()) { | 501 if (session_it == sessions_.end()) { |
426 return NULL; | 502 return NULL; |
427 } | 503 } |
428 const MediaStreamDevice& device_info = session_it->second; | 504 const MediaStreamDevice& device_info = session_it->second; |
429 | 505 |
430 // Check if another session has already opened this device. If so, just | 506 // Check if another session has already opened this device. If so, just |
431 // use that opened device. | 507 // use that opened device. |
432 DeviceEntry* const existing_device = | 508 DeviceEntry* const existing_device = |
433 GetDeviceEntryForMediaStreamDevice(device_info); | 509 GetDeviceEntryForMediaStreamDevice(device_info); |
434 if (existing_device) { | 510 if (existing_device) { |
435 DCHECK_EQ(device_info.type, existing_device->stream_type); | 511 DCHECK_EQ(device_info.type, existing_device->stream_type); |
436 return existing_device; | 512 return existing_device; |
437 } | 513 } |
438 | 514 |
439 scoped_ptr<VideoCaptureController> video_capture_controller( | 515 scoped_ptr<VideoCaptureController> video_capture_controller( |
440 new VideoCaptureController()); | 516 new VideoCaptureController()); |
441 DeviceEntry* new_device = new DeviceEntry(device_info.type, | 517 DeviceEntry* new_device = new DeviceEntry(device_info.type, |
442 device_info.id, | 518 device_info.id, |
443 video_capture_controller.Pass()); | 519 video_capture_controller.Pass()); |
444 devices_.insert(new_device); | 520 devices_.insert(new_device); |
445 return new_device; | 521 return new_device; |
446 } | 522 } |
447 | 523 |
| 524 VideoCaptureManager::DeviceInfo* VideoCaptureManager::FindDeviceInfoById( |
| 525 const std::string& id, |
| 526 DeviceInfos& device_vector) { |
| 527 for (DeviceInfos::iterator it = device_vector.begin(); |
| 528 it != device_vector.end(); ++it) { |
| 529 if (it->name.id() == id) |
| 530 return &(*it); |
| 531 } |
| 532 return NULL; |
| 533 } |
| 534 |
448 } // namespace content | 535 } // namespace content |
OLD | NEW |