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