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/stl_util.h" | 10 #include "base/stl_util.h" |
(...skipping 21 matching lines...) Expand all Loading... |
32 handlers.push_front(handler); | 32 handlers.push_front(handler); |
33 } | 33 } |
34 ~Controller() {} | 34 ~Controller() {} |
35 | 35 |
36 scoped_refptr<VideoCaptureController> controller; | 36 scoped_refptr<VideoCaptureController> controller; |
37 bool ready_to_delete; | 37 bool ready_to_delete; |
38 Handlers handlers; | 38 Handlers handlers; |
39 }; | 39 }; |
40 | 40 |
41 VideoCaptureManager::VideoCaptureManager() | 41 VideoCaptureManager::VideoCaptureManager() |
42 : vc_device_thread_("VideoCaptureManagerThread"), | 42 : listener_(NULL), |
43 listener_(NULL), | 43 new_capture_session_id_(kFirstSessionId), |
44 new_capture_session_id_(kFirstSessionId), | 44 use_fake_device_(false) { |
45 use_fake_device_(false) { | |
46 vc_device_thread_.Start(); | |
47 } | 45 } |
48 | 46 |
49 VideoCaptureManager::~VideoCaptureManager() { | 47 VideoCaptureManager::~VideoCaptureManager() { |
50 vc_device_thread_.Stop(); | |
51 DCHECK(devices_.empty()); | 48 DCHECK(devices_.empty()); |
52 DCHECK(controllers_.empty()); | 49 DCHECK(controllers_.empty()); |
53 } | 50 } |
54 | 51 |
55 void VideoCaptureManager::Register(MediaStreamProviderListener* listener) { | 52 void VideoCaptureManager::Register(MediaStreamProviderListener* listener, |
| 53 base::MessageLoopProxy* device_thread_loop) { |
56 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 54 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
57 DCHECK(!listener_); | 55 DCHECK(!listener_); |
| 56 DCHECK(!device_loop_); |
58 listener_ = listener; | 57 listener_ = listener; |
| 58 device_loop_ = device_thread_loop; |
59 } | 59 } |
60 | 60 |
61 void VideoCaptureManager::Unregister() { | 61 void VideoCaptureManager::Unregister() { |
62 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 62 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
63 DCHECK(listener_); | 63 DCHECK(listener_); |
64 listener_ = NULL; | 64 listener_ = NULL; |
65 } | 65 } |
66 | 66 |
67 void VideoCaptureManager::EnumerateDevices() { | 67 void VideoCaptureManager::EnumerateDevices() { |
68 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 68 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
69 DCHECK(listener_); | 69 DCHECK(listener_); |
70 | 70 device_loop_->PostTask( |
71 vc_device_thread_.message_loop()->PostTask( | |
72 FROM_HERE, | 71 FROM_HERE, |
73 base::Bind(&VideoCaptureManager::OnEnumerateDevices, this)); | 72 base::Bind(&VideoCaptureManager::OnEnumerateDevices, this)); |
74 } | 73 } |
75 | 74 |
76 int VideoCaptureManager::Open(const StreamDeviceInfo& device) { | 75 int VideoCaptureManager::Open(const StreamDeviceInfo& device) { |
77 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 76 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
78 DCHECK(listener_); | 77 DCHECK(listener_); |
79 | 78 |
80 // Generate a new id for this device. | 79 // Generate a new id for this device. |
81 int video_capture_session_id = new_capture_session_id_++; | 80 int video_capture_session_id = new_capture_session_id_++; |
82 | 81 |
83 vc_device_thread_.message_loop()->PostTask( | 82 device_loop_->PostTask( |
84 FROM_HERE, | 83 FROM_HERE, |
85 base::Bind(&VideoCaptureManager::OnOpen, this, video_capture_session_id, | 84 base::Bind(&VideoCaptureManager::OnOpen, this, video_capture_session_id, |
86 device)); | 85 device)); |
87 | 86 |
88 return video_capture_session_id; | 87 return video_capture_session_id; |
89 } | 88 } |
90 | 89 |
91 void VideoCaptureManager::Close(int capture_session_id) { | 90 void VideoCaptureManager::Close(int capture_session_id) { |
92 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 91 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
93 DCHECK(listener_); | 92 DCHECK(listener_); |
94 | 93 device_loop_->PostTask( |
95 vc_device_thread_.message_loop()->PostTask( | |
96 FROM_HERE, | 94 FROM_HERE, |
97 base::Bind(&VideoCaptureManager::OnClose, this, capture_session_id)); | 95 base::Bind(&VideoCaptureManager::OnClose, this, capture_session_id)); |
98 } | 96 } |
99 | 97 |
100 void VideoCaptureManager::Start( | 98 void VideoCaptureManager::Start( |
101 const media::VideoCaptureParams& capture_params, | 99 const media::VideoCaptureParams& capture_params, |
102 media::VideoCaptureDevice::EventHandler* video_capture_receiver) { | 100 media::VideoCaptureDevice::EventHandler* video_capture_receiver) { |
103 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 101 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
104 | 102 device_loop_->PostTask( |
105 vc_device_thread_.message_loop()->PostTask( | |
106 FROM_HERE, | 103 FROM_HERE, |
107 base::Bind(&VideoCaptureManager::OnStart, this, capture_params, | 104 base::Bind(&VideoCaptureManager::OnStart, this, capture_params, |
108 video_capture_receiver)); | 105 video_capture_receiver)); |
109 } | 106 } |
110 | 107 |
111 void VideoCaptureManager::Stop( | 108 void VideoCaptureManager::Stop( |
112 const media::VideoCaptureSessionId& capture_session_id, | 109 const media::VideoCaptureSessionId& capture_session_id, |
113 base::Closure stopped_cb) { | 110 base::Closure stopped_cb) { |
114 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 111 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
115 | 112 device_loop_->PostTask( |
116 vc_device_thread_.message_loop()->PostTask( | |
117 FROM_HERE, | 113 FROM_HERE, |
118 base::Bind(&VideoCaptureManager::OnStop, this, capture_session_id, | 114 base::Bind(&VideoCaptureManager::OnStop, this, capture_session_id, |
119 stopped_cb)); | 115 stopped_cb)); |
120 } | 116 } |
121 | 117 |
122 void VideoCaptureManager::Error( | 118 void VideoCaptureManager::Error( |
123 const media::VideoCaptureSessionId& capture_session_id) { | 119 const media::VideoCaptureSessionId& capture_session_id) { |
124 PostOnError(capture_session_id, kDeviceNotAvailable); | 120 PostOnError(capture_session_id, kDeviceNotAvailable); |
125 } | 121 } |
126 | 122 |
127 void VideoCaptureManager::UseFakeDevice() { | 123 void VideoCaptureManager::UseFakeDevice() { |
128 use_fake_device_ = true; | 124 use_fake_device_ = true; |
129 } | 125 } |
130 | 126 |
131 MessageLoop* VideoCaptureManager::GetMessageLoop() { | |
132 return vc_device_thread_.message_loop(); | |
133 } | |
134 | |
135 void VideoCaptureManager::OnEnumerateDevices() { | 127 void VideoCaptureManager::OnEnumerateDevices() { |
136 DCHECK(IsOnCaptureDeviceThread()); | 128 DCHECK(IsOnDeviceThread()); |
137 | 129 |
138 media::VideoCaptureDevice::Names device_names; | 130 media::VideoCaptureDevice::Names device_names; |
139 GetAvailableDevices(&device_names); | 131 GetAvailableDevices(&device_names); |
140 | 132 |
141 StreamDeviceInfoArray devices; | 133 StreamDeviceInfoArray devices; |
142 for (media::VideoCaptureDevice::Names::iterator it = | 134 for (media::VideoCaptureDevice::Names::iterator it = |
143 device_names.begin(); it != device_names.end(); ++it) { | 135 device_names.begin(); it != device_names.end(); ++it) { |
144 bool opened = DeviceOpened(*it); | 136 bool opened = DeviceOpened(*it); |
145 devices.push_back(StreamDeviceInfo( | 137 devices.push_back(StreamDeviceInfo( |
146 content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, it->device_name, | 138 content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, it->device_name, |
147 it->unique_id, opened)); | 139 it->unique_id, opened)); |
148 } | 140 } |
149 | 141 |
150 PostOnDevicesEnumerated(devices); | 142 PostOnDevicesEnumerated(devices); |
151 } | 143 } |
152 | 144 |
153 void VideoCaptureManager::OnOpen(int capture_session_id, | 145 void VideoCaptureManager::OnOpen(int capture_session_id, |
154 const StreamDeviceInfo& device) { | 146 const StreamDeviceInfo& device) { |
155 DCHECK(IsOnCaptureDeviceThread()); | 147 DCHECK(IsOnDeviceThread()); |
156 DCHECK(devices_.find(capture_session_id) == devices_.end()); | 148 DCHECK(devices_.find(capture_session_id) == devices_.end()); |
157 DVLOG(1) << "VideoCaptureManager::OnOpen, id " << capture_session_id; | 149 DVLOG(1) << "VideoCaptureManager::OnOpen, id " << capture_session_id; |
158 | 150 |
159 // Check if another session has already opened this device. If so, just | 151 // Check if another session has already opened this device. If so, just |
160 // use that opened device. | 152 // use that opened device. |
161 media::VideoCaptureDevice* video_capture_device = GetOpenedDevice(device); | 153 media::VideoCaptureDevice* video_capture_device = GetOpenedDevice(device); |
162 if (video_capture_device) { | 154 if (video_capture_device) { |
163 devices_[capture_session_id] = video_capture_device; | 155 devices_[capture_session_id] = video_capture_device; |
164 PostOnOpened(capture_session_id); | 156 PostOnOpened(capture_session_id); |
165 return; | 157 return; |
(...skipping 13 matching lines...) Expand all Loading... |
179 if (!video_capture_device) { | 171 if (!video_capture_device) { |
180 PostOnError(capture_session_id, kDeviceNotAvailable); | 172 PostOnError(capture_session_id, kDeviceNotAvailable); |
181 return; | 173 return; |
182 } | 174 } |
183 | 175 |
184 devices_[capture_session_id] = video_capture_device; | 176 devices_[capture_session_id] = video_capture_device; |
185 PostOnOpened(capture_session_id); | 177 PostOnOpened(capture_session_id); |
186 } | 178 } |
187 | 179 |
188 void VideoCaptureManager::OnClose(int capture_session_id) { | 180 void VideoCaptureManager::OnClose(int capture_session_id) { |
189 DCHECK(IsOnCaptureDeviceThread()); | 181 DCHECK(IsOnDeviceThread()); |
190 DVLOG(1) << "VideoCaptureManager::OnClose, id " << capture_session_id; | 182 DVLOG(1) << "VideoCaptureManager::OnClose, id " << capture_session_id; |
191 | 183 |
192 media::VideoCaptureDevice* video_capture_device = NULL; | 184 media::VideoCaptureDevice* video_capture_device = NULL; |
193 VideoCaptureDevices::iterator device_it = devices_.find(capture_session_id); | 185 VideoCaptureDevices::iterator device_it = devices_.find(capture_session_id); |
194 if (device_it != devices_.end()) { | 186 if (device_it != devices_.end()) { |
195 video_capture_device = device_it->second; | 187 video_capture_device = device_it->second; |
196 devices_.erase(device_it); | 188 devices_.erase(device_it); |
197 | 189 |
198 Controllers::iterator cit = controllers_.find(video_capture_device); | 190 Controllers::iterator cit = controllers_.find(video_capture_device); |
199 if (cit != controllers_.end()) { | 191 if (cit != controllers_.end()) { |
(...skipping 15 matching lines...) Expand all Loading... |
215 } | 207 } |
216 delete video_capture_device; | 208 delete video_capture_device; |
217 } | 209 } |
218 } | 210 } |
219 PostOnClosed(capture_session_id); | 211 PostOnClosed(capture_session_id); |
220 } | 212 } |
221 | 213 |
222 void VideoCaptureManager::OnStart( | 214 void VideoCaptureManager::OnStart( |
223 const media::VideoCaptureParams capture_params, | 215 const media::VideoCaptureParams capture_params, |
224 media::VideoCaptureDevice::EventHandler* video_capture_receiver) { | 216 media::VideoCaptureDevice::EventHandler* video_capture_receiver) { |
225 DCHECK(IsOnCaptureDeviceThread()); | 217 DCHECK(IsOnDeviceThread()); |
226 DCHECK(video_capture_receiver != NULL); | 218 DCHECK(video_capture_receiver != NULL); |
227 DVLOG(1) << "VideoCaptureManager::OnStart, (" << capture_params.width | 219 DVLOG(1) << "VideoCaptureManager::OnStart, (" << capture_params.width |
228 << ", " << capture_params.height | 220 << ", " << capture_params.height |
229 << ", " << capture_params.frame_per_second | 221 << ", " << capture_params.frame_per_second |
230 << ", " << capture_params.session_id | 222 << ", " << capture_params.session_id |
231 << ")"; | 223 << ")"; |
232 | 224 |
233 media::VideoCaptureDevice* video_capture_device = | 225 media::VideoCaptureDevice* video_capture_device = |
234 GetDeviceInternal(capture_params.session_id); | 226 GetDeviceInternal(capture_params.session_id); |
235 if (!video_capture_device) { | 227 if (!video_capture_device) { |
(...skipping 10 matching lines...) Expand all Loading... |
246 // video_capture_device. video_capture_receiver to perform actions. | 238 // video_capture_device. video_capture_receiver to perform actions. |
247 video_capture_device->Allocate(capture_params.width, capture_params.height, | 239 video_capture_device->Allocate(capture_params.width, capture_params.height, |
248 capture_params.frame_per_second, | 240 capture_params.frame_per_second, |
249 video_capture_receiver); | 241 video_capture_receiver); |
250 video_capture_device->Start(); | 242 video_capture_device->Start(); |
251 } | 243 } |
252 | 244 |
253 void VideoCaptureManager::OnStop( | 245 void VideoCaptureManager::OnStop( |
254 const media::VideoCaptureSessionId capture_session_id, | 246 const media::VideoCaptureSessionId capture_session_id, |
255 base::Closure stopped_cb) { | 247 base::Closure stopped_cb) { |
256 DCHECK(IsOnCaptureDeviceThread()); | 248 DCHECK(IsOnDeviceThread()); |
257 DVLOG(1) << "VideoCaptureManager::OnStop, id " << capture_session_id; | 249 DVLOG(1) << "VideoCaptureManager::OnStop, id " << capture_session_id; |
258 | 250 |
259 VideoCaptureDevices::iterator it = devices_.find(capture_session_id); | 251 VideoCaptureDevices::iterator it = devices_.find(capture_session_id); |
260 if (it != devices_.end()) { | 252 if (it != devices_.end()) { |
261 media::VideoCaptureDevice* video_capture_device = it->second; | 253 media::VideoCaptureDevice* video_capture_device = it->second; |
262 // Possible errors are signaled to video_capture_receiver by | 254 // Possible errors are signaled to video_capture_receiver by |
263 // video_capture_device. video_capture_receiver to perform actions. | 255 // video_capture_device. video_capture_receiver to perform actions. |
264 video_capture_device->Stop(); | 256 video_capture_device->Stop(); |
265 video_capture_device->DeAllocate(); | 257 video_capture_device->DeAllocate(); |
266 Controllers::iterator cit = controllers_.find(video_capture_device); | 258 Controllers::iterator cit = controllers_.find(video_capture_device); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
318 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); | 310 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
319 if (!listener_) { | 311 if (!listener_) { |
320 // Listener has been removed. | 312 // Listener has been removed. |
321 return; | 313 return; |
322 } | 314 } |
323 listener_->Error(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, | 315 listener_->Error(content::MEDIA_STREAM_DEVICE_TYPE_VIDEO_CAPTURE, |
324 capture_session_id, error); | 316 capture_session_id, error); |
325 } | 317 } |
326 | 318 |
327 void VideoCaptureManager::PostOnOpened(int capture_session_id) { | 319 void VideoCaptureManager::PostOnOpened(int capture_session_id) { |
328 DCHECK(IsOnCaptureDeviceThread()); | 320 DCHECK(IsOnDeviceThread()); |
329 BrowserThread::PostTask(BrowserThread::IO, | 321 BrowserThread::PostTask(BrowserThread::IO, |
330 FROM_HERE, | 322 FROM_HERE, |
331 base::Bind(&VideoCaptureManager::OnOpened, this, | 323 base::Bind(&VideoCaptureManager::OnOpened, this, |
332 capture_session_id)); | 324 capture_session_id)); |
333 } | 325 } |
334 | 326 |
335 void VideoCaptureManager::PostOnClosed(int capture_session_id) { | 327 void VideoCaptureManager::PostOnClosed(int capture_session_id) { |
336 DCHECK(IsOnCaptureDeviceThread()); | 328 DCHECK(IsOnDeviceThread()); |
337 BrowserThread::PostTask(BrowserThread::IO, | 329 BrowserThread::PostTask(BrowserThread::IO, |
338 FROM_HERE, | 330 FROM_HERE, |
339 base::Bind(&VideoCaptureManager::OnClosed, this, | 331 base::Bind(&VideoCaptureManager::OnClosed, this, |
340 capture_session_id)); | 332 capture_session_id)); |
341 } | 333 } |
342 | 334 |
343 void VideoCaptureManager::PostOnDevicesEnumerated( | 335 void VideoCaptureManager::PostOnDevicesEnumerated( |
344 const StreamDeviceInfoArray& devices) { | 336 const StreamDeviceInfoArray& devices) { |
345 DCHECK(IsOnCaptureDeviceThread()); | 337 DCHECK(IsOnDeviceThread()); |
346 BrowserThread::PostTask(BrowserThread::IO, | 338 BrowserThread::PostTask(BrowserThread::IO, |
347 FROM_HERE, | 339 FROM_HERE, |
348 base::Bind(&VideoCaptureManager::OnDevicesEnumerated, | 340 base::Bind(&VideoCaptureManager::OnDevicesEnumerated, |
349 this, devices)); | 341 this, devices)); |
350 } | 342 } |
351 | 343 |
352 void VideoCaptureManager::PostOnError(int capture_session_id, | 344 void VideoCaptureManager::PostOnError(int capture_session_id, |
353 MediaStreamProviderError error) { | 345 MediaStreamProviderError error) { |
354 // Don't check thread here, can be called from both IO thread and device | 346 // Don't check thread here, can be called from both IO thread and device |
355 // thread. | 347 // thread. |
356 BrowserThread::PostTask(BrowserThread::IO, | 348 BrowserThread::PostTask(BrowserThread::IO, |
357 FROM_HERE, | 349 FROM_HERE, |
358 base::Bind(&VideoCaptureManager::OnError, this, | 350 base::Bind(&VideoCaptureManager::OnError, this, |
359 capture_session_id, error)); | 351 capture_session_id, error)); |
360 } | 352 } |
361 | 353 |
362 bool VideoCaptureManager::IsOnCaptureDeviceThread() const { | 354 bool VideoCaptureManager::IsOnDeviceThread() const { |
363 return MessageLoop::current() == vc_device_thread_.message_loop(); | 355 return device_loop_->BelongsToCurrentThread(); |
364 } | 356 } |
365 | 357 |
366 void VideoCaptureManager::GetAvailableDevices( | 358 void VideoCaptureManager::GetAvailableDevices( |
367 media::VideoCaptureDevice::Names* device_names) { | 359 media::VideoCaptureDevice::Names* device_names) { |
368 DCHECK(IsOnCaptureDeviceThread()); | 360 DCHECK(IsOnDeviceThread()); |
369 | 361 |
370 if (!use_fake_device_) { | 362 if (!use_fake_device_) { |
371 media::VideoCaptureDevice::GetDeviceNames(device_names); | 363 media::VideoCaptureDevice::GetDeviceNames(device_names); |
372 } else { | 364 } else { |
373 media::FakeVideoCaptureDevice::GetDeviceNames(device_names); | 365 media::FakeVideoCaptureDevice::GetDeviceNames(device_names); |
374 } | 366 } |
375 } | 367 } |
376 | 368 |
377 bool VideoCaptureManager::DeviceOpened( | 369 bool VideoCaptureManager::DeviceOpened( |
378 const media::VideoCaptureDevice::Name& device_name) { | 370 const media::VideoCaptureDevice::Name& device_name) { |
379 DCHECK(IsOnCaptureDeviceThread()); | 371 DCHECK(IsOnDeviceThread()); |
380 | 372 |
381 for (VideoCaptureDevices::iterator it = devices_.begin(); | 373 for (VideoCaptureDevices::iterator it = devices_.begin(); |
382 it != devices_.end(); ++it) { | 374 it != devices_.end(); ++it) { |
383 if (device_name.unique_id == it->second->device_name().unique_id) { | 375 if (device_name.unique_id == it->second->device_name().unique_id) { |
384 // We've found the device! | 376 // We've found the device! |
385 return true; | 377 return true; |
386 } | 378 } |
387 } | 379 } |
388 return false; | 380 return false; |
389 } | 381 } |
390 | 382 |
391 media::VideoCaptureDevice* VideoCaptureManager::GetOpenedDevice( | 383 media::VideoCaptureDevice* VideoCaptureManager::GetOpenedDevice( |
392 const StreamDeviceInfo& device_info) { | 384 const StreamDeviceInfo& device_info) { |
393 DCHECK(IsOnCaptureDeviceThread()); | 385 DCHECK(IsOnDeviceThread()); |
394 | 386 |
395 for (VideoCaptureDevices::iterator it = devices_.begin(); | 387 for (VideoCaptureDevices::iterator it = devices_.begin(); |
396 it != devices_.end(); it++) { | 388 it != devices_.end(); it++) { |
397 if (device_info.device_id == it->second->device_name().unique_id) { | 389 if (device_info.device_id == it->second->device_name().unique_id) { |
398 return it->second; | 390 return it->second; |
399 } | 391 } |
400 } | 392 } |
401 return NULL; | 393 return NULL; |
402 } | 394 } |
403 | 395 |
404 bool VideoCaptureManager::DeviceInUse( | 396 bool VideoCaptureManager::DeviceInUse( |
405 const media::VideoCaptureDevice* video_capture_device) { | 397 const media::VideoCaptureDevice* video_capture_device) { |
406 DCHECK(IsOnCaptureDeviceThread()); | 398 DCHECK(IsOnDeviceThread()); |
407 | 399 |
408 for (VideoCaptureDevices::iterator it = devices_.begin(); | 400 for (VideoCaptureDevices::iterator it = devices_.begin(); |
409 it != devices_.end(); ++it) { | 401 it != devices_.end(); ++it) { |
410 if (video_capture_device == it->second) { | 402 if (video_capture_device == it->second) { |
411 // We've found the device! | 403 // We've found the device! |
412 return true; | 404 return true; |
413 } | 405 } |
414 } | 406 } |
415 return false; | 407 return false; |
416 } | 408 } |
417 | 409 |
418 void VideoCaptureManager::AddController( | 410 void VideoCaptureManager::AddController( |
419 const media::VideoCaptureParams& capture_params, | 411 const media::VideoCaptureParams& capture_params, |
420 VideoCaptureControllerEventHandler* handler, | 412 VideoCaptureControllerEventHandler* handler, |
421 base::Callback<void(VideoCaptureController*)> added_cb) { | 413 base::Callback<void(VideoCaptureController*)> added_cb) { |
422 DCHECK(handler); | 414 DCHECK(handler); |
423 vc_device_thread_.message_loop()->PostTask( | 415 device_loop_->PostTask( |
424 FROM_HERE, | 416 FROM_HERE, |
425 base::Bind(&VideoCaptureManager::DoAddControllerOnDeviceThread, | 417 base::Bind(&VideoCaptureManager::DoAddControllerOnDeviceThread, |
426 this, capture_params, handler, added_cb)); | 418 this, capture_params, handler, added_cb)); |
427 } | 419 } |
428 | 420 |
429 void VideoCaptureManager::DoAddControllerOnDeviceThread( | 421 void VideoCaptureManager::DoAddControllerOnDeviceThread( |
430 const media::VideoCaptureParams capture_params, | 422 const media::VideoCaptureParams capture_params, |
431 VideoCaptureControllerEventHandler* handler, | 423 VideoCaptureControllerEventHandler* handler, |
432 base::Callback<void(VideoCaptureController*)> added_cb) { | 424 base::Callback<void(VideoCaptureController*)> added_cb) { |
433 DCHECK(IsOnCaptureDeviceThread()); | 425 DCHECK(IsOnDeviceThread()); |
434 | 426 |
435 media::VideoCaptureDevice* video_capture_device = | 427 media::VideoCaptureDevice* video_capture_device = |
436 GetDeviceInternal(capture_params.session_id); | 428 GetDeviceInternal(capture_params.session_id); |
437 scoped_refptr<VideoCaptureController> controller; | 429 scoped_refptr<VideoCaptureController> controller; |
438 if (video_capture_device) { | 430 if (video_capture_device) { |
439 Controllers::iterator cit = controllers_.find(video_capture_device); | 431 Controllers::iterator cit = controllers_.find(video_capture_device); |
440 if (cit == controllers_.end()) { | 432 if (cit == controllers_.end()) { |
441 controller = new VideoCaptureController(this); | 433 controller = new VideoCaptureController(this); |
442 controllers_[video_capture_device] = new Controller(controller, handler); | 434 controllers_[video_capture_device] = new Controller(controller, handler); |
443 } else { | 435 } else { |
444 controllers_[video_capture_device]->handlers.push_front(handler); | 436 controllers_[video_capture_device]->handlers.push_front(handler); |
445 controller = controllers_[video_capture_device]->controller; | 437 controller = controllers_[video_capture_device]->controller; |
446 } | 438 } |
447 } | 439 } |
448 added_cb.Run(controller); | 440 added_cb.Run(controller); |
449 } | 441 } |
450 | 442 |
451 void VideoCaptureManager::RemoveController( | 443 void VideoCaptureManager::RemoveController( |
452 VideoCaptureController* controller, | 444 VideoCaptureController* controller, |
453 VideoCaptureControllerEventHandler* handler) { | 445 VideoCaptureControllerEventHandler* handler) { |
454 DCHECK(handler); | 446 DCHECK(handler); |
455 vc_device_thread_.message_loop()->PostTask( | 447 device_loop_->PostTask( |
456 FROM_HERE, | 448 FROM_HERE, |
457 base::Bind(&VideoCaptureManager::DoRemoveControllerOnDeviceThread, this, | 449 base::Bind(&VideoCaptureManager::DoRemoveControllerOnDeviceThread, this, |
458 make_scoped_refptr(controller), handler)); | 450 make_scoped_refptr(controller), handler)); |
459 } | 451 } |
460 | 452 |
461 void VideoCaptureManager::DoRemoveControllerOnDeviceThread( | 453 void VideoCaptureManager::DoRemoveControllerOnDeviceThread( |
462 VideoCaptureController* controller, | 454 VideoCaptureController* controller, |
463 VideoCaptureControllerEventHandler* handler) { | 455 VideoCaptureControllerEventHandler* handler) { |
464 DCHECK(IsOnCaptureDeviceThread()); | 456 DCHECK(IsOnDeviceThread()); |
465 | 457 |
466 for (Controllers::iterator cit = controllers_.begin(); | 458 for (Controllers::iterator cit = controllers_.begin(); |
467 cit != controllers_.end(); ++cit) { | 459 cit != controllers_.end(); ++cit) { |
468 if (controller == cit->second->controller) { | 460 if (controller == cit->second->controller) { |
469 Handlers& handlers = cit->second->handlers; | 461 Handlers& handlers = cit->second->handlers; |
470 for (Handlers::iterator hit = handlers.begin(); | 462 for (Handlers::iterator hit = handlers.begin(); |
471 hit != handlers.end(); ++hit) { | 463 hit != handlers.end(); ++hit) { |
472 if ((*hit) == handler) { | 464 if ((*hit) == handler) { |
473 handlers.erase(hit); | 465 handlers.erase(hit); |
474 break; | 466 break; |
475 } | 467 } |
476 } | 468 } |
477 if (handlers.empty() && cit->second->ready_to_delete) { | 469 if (handlers.empty() && cit->second->ready_to_delete) { |
478 delete cit->second; | 470 delete cit->second; |
479 controllers_.erase(cit); | 471 controllers_.erase(cit); |
480 } | 472 } |
481 return; | 473 return; |
482 } | 474 } |
483 } | 475 } |
484 } | 476 } |
485 | 477 |
486 media::VideoCaptureDevice* VideoCaptureManager::GetDeviceInternal( | 478 media::VideoCaptureDevice* VideoCaptureManager::GetDeviceInternal( |
487 int capture_session_id) { | 479 int capture_session_id) { |
488 DCHECK(IsOnCaptureDeviceThread()); | 480 DCHECK(IsOnDeviceThread()); |
489 VideoCaptureDevices::iterator dit = devices_.find(capture_session_id); | 481 VideoCaptureDevices::iterator dit = devices_.find(capture_session_id); |
490 if (dit != devices_.end()) { | 482 if (dit != devices_.end()) { |
491 return dit->second; | 483 return dit->second; |
492 } | 484 } |
493 | 485 |
494 // Solution for not using MediaStreamManager. | 486 // Solution for not using MediaStreamManager. |
495 // This session id won't be returned by Open(). | 487 // This session id won't be returned by Open(). |
496 if (capture_session_id == kStartOpenSessionId) { | 488 if (capture_session_id == kStartOpenSessionId) { |
497 media::VideoCaptureDevice::Names device_names; | 489 media::VideoCaptureDevice::Names device_names; |
498 GetAvailableDevices(&device_names); | 490 GetAvailableDevices(&device_names); |
(...skipping 10 matching lines...) Expand all Loading... |
509 | 501 |
510 VideoCaptureDevices::iterator dit = devices_.find(capture_session_id); | 502 VideoCaptureDevices::iterator dit = devices_.find(capture_session_id); |
511 if (dit != devices_.end()) { | 503 if (dit != devices_.end()) { |
512 return dit->second; | 504 return dit->second; |
513 } | 505 } |
514 } | 506 } |
515 return NULL; | 507 return NULL; |
516 } | 508 } |
517 | 509 |
518 } // namespace media_stream | 510 } // namespace media_stream |
OLD | NEW |