diff options
Diffstat (limited to 'chromium/content/renderer/media/video_capture_impl.cc')
| -rw-r--r-- | chromium/content/renderer/media/video_capture_impl.cc | 423 |
1 files changed, 218 insertions, 205 deletions
diff --git a/chromium/content/renderer/media/video_capture_impl.cc b/chromium/content/renderer/media/video_capture_impl.cc index 30b43ddfcf4..a9d6240ea1c 100644 --- a/chromium/content/renderer/media/video_capture_impl.cc +++ b/chromium/content/renderer/media/video_capture_impl.cc @@ -1,6 +1,13 @@ // Copyright (c) 2012 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. +// +// Notes about usage of this object by VideoCaptureImplManager. +// +// VideoCaptureImplManager access this object by using a Unretained() +// binding and tasks on the IO thread. It is then important that +// VideoCaptureImpl never post task to itself. All operations must be +// synchronous. #include "content/renderer/media/video_capture_impl.h" @@ -8,7 +15,7 @@ #include "base/stl_util.h" #include "content/child/child_process.h" #include "content/common/media/video_capture_messages.h" -#include "media/base/bind_to_loop.h" +#include "media/base/bind_to_current_loop.h" #include "media/base/limits.h" #include "media/base/video_frame.h" @@ -32,143 +39,81 @@ class VideoCaptureImpl::ClientBuffer DISALLOW_COPY_AND_ASSIGN(ClientBuffer); }; -bool VideoCaptureImpl::CaptureStarted() { - return state_ == VIDEO_CAPTURE_STATE_STARTED; -} - -int VideoCaptureImpl::CaptureFrameRate() { - return last_frame_format_.frame_rate; -} +VideoCaptureImpl::ClientInfo::ClientInfo() {} +VideoCaptureImpl::ClientInfo::~ClientInfo() {} VideoCaptureImpl::VideoCaptureImpl( const media::VideoCaptureSessionId session_id, - base::MessageLoopProxy* capture_message_loop_proxy, VideoCaptureMessageFilter* filter) - : VideoCapture(), - message_filter_(filter), - capture_message_loop_proxy_(capture_message_loop_proxy), - io_message_loop_proxy_(ChildProcess::current()->io_message_loop_proxy()), + : message_filter_(filter), device_id_(0), session_id_(session_id), suspended_(false), state_(VIDEO_CAPTURE_STATE_STOPPED), - weak_this_factory_(this) { + weak_factory_(this) { DCHECK(filter); + thread_checker_.DetachFromThread(); } -VideoCaptureImpl::~VideoCaptureImpl() {} - -void VideoCaptureImpl::Init() { - if (!io_message_loop_proxy_->BelongsToCurrentThread()) { - io_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::AddDelegateOnIOThread, - base::Unretained(this))); - } else { - AddDelegateOnIOThread(); - } -} - -void VideoCaptureImpl::DeInit(base::Closure task) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoDeInitOnCaptureThread, - base::Unretained(this), task)); -} - -void VideoCaptureImpl::StartCapture( - media::VideoCapture::EventHandler* handler, - const media::VideoCaptureParams& params) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoStartCaptureOnCaptureThread, - base::Unretained(this), handler, params)); -} - -void VideoCaptureImpl::StopCapture(media::VideoCapture::EventHandler* handler) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoStopCaptureOnCaptureThread, - base::Unretained(this), handler)); -} - -void VideoCaptureImpl::OnBufferCreated( - base::SharedMemoryHandle handle, - int length, int buffer_id) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoBufferCreatedOnCaptureThread, - base::Unretained(this), handle, length, buffer_id)); -} - -void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoBufferDestroyedOnCaptureThread, - base::Unretained(this), buffer_id)); -} - -void VideoCaptureImpl::OnBufferReceived( - int buffer_id, - base::Time timestamp, - const media::VideoCaptureFormat& format) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoBufferReceivedOnCaptureThread, - base::Unretained(this), buffer_id, timestamp, format)); +VideoCaptureImpl::~VideoCaptureImpl() { + DCHECK(thread_checker_.CalledOnValidThread()); } -void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoStateChangedOnCaptureThread, - base::Unretained(this), state)); -} - -void VideoCaptureImpl::OnDelegateAdded(int32 device_id) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoDelegateAddedOnCaptureThread, - base::Unretained(this), device_id)); -} - -void VideoCaptureImpl::SuspendCapture(bool suspend) { - capture_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::DoSuspendCaptureOnCaptureThread, - base::Unretained(this), suspend)); +void VideoCaptureImpl::Init() { + DCHECK(thread_checker_.CalledOnValidThread()); + message_filter_->AddDelegate(this); } -void VideoCaptureImpl::DoDeInitOnCaptureThread(base::Closure task) { +void VideoCaptureImpl::DeInit() { + DCHECK(thread_checker_.CalledOnValidThread()); if (state_ == VIDEO_CAPTURE_STATE_STARTED) Send(new VideoCaptureHostMsg_Stop(device_id_)); + message_filter_->RemoveDelegate(this); +} - io_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(&VideoCaptureImpl::RemoveDelegateOnIOThread, - base::Unretained(this), task)); +void VideoCaptureImpl::SuspendCapture(bool suspend) { + DCHECK(thread_checker_.CalledOnValidThread()); + suspended_ = suspend; } -void VideoCaptureImpl::DoStartCaptureOnCaptureThread( - media::VideoCapture::EventHandler* handler, - const media::VideoCaptureParams& params) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +void VideoCaptureImpl::StartCapture( + int client_id, + const media::VideoCaptureParams& params, + const VideoCaptureStateUpdateCB& state_update_cb, + const VideoCaptureDeliverFrameCB& deliver_frame_cb) { + DCHECK(thread_checker_.CalledOnValidThread()); + ClientInfo client_info; + client_info.params = params; + client_info.state_update_cb = state_update_cb; + client_info.deliver_frame_cb = deliver_frame_cb; if (state_ == VIDEO_CAPTURE_STATE_ERROR) { - handler->OnError(this, 1); - handler->OnRemoved(this); - } else if ((clients_pending_on_filter_.find(handler) != - clients_pending_on_filter_.end()) || - (clients_pending_on_restart_.find(handler) != - clients_pending_on_restart_.end()) || - clients_.find(handler) != clients_.end() ) { - // This client has started. + state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR); + } else if (clients_pending_on_filter_.count(client_id) || + clients_pending_on_restart_.count(client_id) || + clients_.count(client_id)) { + LOG(FATAL) << "This client has already started."; } else if (!device_id_) { - clients_pending_on_filter_[handler] = params; + clients_pending_on_filter_[client_id] = client_info; } else { - handler->OnStarted(this); + // Note: |state_| might not be started at this point. But we tell + // client that we have started. + state_update_cb.Run(VIDEO_CAPTURE_STATE_STARTED); if (state_ == VIDEO_CAPTURE_STATE_STARTED) { - clients_[handler] = params; + clients_[client_id] = client_info; + // TODO(sheu): Allowing resolution change will require that all + // outstanding clients of a capture session support resolution change. + DCHECK_EQ(params_.allow_resolution_change, + params.allow_resolution_change); } else if (state_ == VIDEO_CAPTURE_STATE_STOPPING) { - clients_pending_on_restart_[handler] = params; + clients_pending_on_restart_[client_id] = client_info; DVLOG(1) << "StartCapture: Got new resolution " << params.requested_format.frame_size.ToString() << " during stopping."; } else { - // TODO(sheu): Allowing resolution change will require that all - // outstanding clients of a capture session support resolution change. - DCHECK(!params.allow_resolution_change); - clients_[handler] = params; - DCHECK_EQ(1ul, clients_.size()); + clients_[client_id] = client_info; + if (state_ == VIDEO_CAPTURE_STATE_STARTED) + return; params_ = params; if (params_.requested_format.frame_rate > media::limits::kMaxFramesPerSecond) { @@ -177,35 +122,54 @@ void VideoCaptureImpl::DoStartCaptureOnCaptureThread( } DVLOG(1) << "StartCapture: starting with first resolution " << params_.requested_format.frame_size.ToString(); - + first_frame_timestamp_ = base::TimeTicks(); StartCaptureInternal(); } } } -void VideoCaptureImpl::DoStopCaptureOnCaptureThread( - media::VideoCapture::EventHandler* handler) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +void VideoCaptureImpl::StopCapture(int client_id) { + DCHECK(thread_checker_.CalledOnValidThread()); - // A handler can be in only one client list. - // If this handler is in any client list, we can just remove it from + // A client ID can be in only one client list. + // If this ID is in any client list, we can just remove it from // that client list and don't have to run the other following RemoveClient(). - RemoveClient(handler, &clients_pending_on_filter_) || - RemoveClient(handler, &clients_pending_on_restart_) || - RemoveClient(handler, &clients_); + if (!RemoveClient(client_id, &clients_pending_on_filter_)) { + if (!RemoveClient(client_id, &clients_pending_on_restart_)) { + RemoveClient(client_id, &clients_); + } + } if (clients_.empty()) { DVLOG(1) << "StopCapture: No more client, stopping ..."; StopDevice(); client_buffers_.clear(); - weak_this_factory_.InvalidateWeakPtrs(); + weak_factory_.InvalidateWeakPtrs(); } } -void VideoCaptureImpl::DoBufferCreatedOnCaptureThread( +void VideoCaptureImpl::GetDeviceSupportedFormats( + const VideoCaptureDeviceFormatsCB& callback) { + DCHECK(thread_checker_.CalledOnValidThread()); + device_formats_cb_queue_.push_back(callback); + if (device_formats_cb_queue_.size() == 1) + Send(new VideoCaptureHostMsg_GetDeviceSupportedFormats(device_id_, + session_id_)); +} + +void VideoCaptureImpl::GetDeviceFormatsInUse( + const VideoCaptureDeviceFormatsCB& callback) { + DCHECK(thread_checker_.CalledOnValidThread()); + device_formats_in_use_cb_queue_.push_back(callback); + if (device_formats_in_use_cb_queue_.size() == 1) + Send( + new VideoCaptureHostMsg_GetDeviceFormatsInUse(device_id_, session_id_)); +} + +void VideoCaptureImpl::OnBufferCreated( base::SharedMemoryHandle handle, int length, int buffer_id) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); + DCHECK(thread_checker_.CalledOnValidThread()); // In case client calls StopCapture before the arrival of created buffer, // just close this buffer and return. @@ -216,7 +180,7 @@ void VideoCaptureImpl::DoBufferCreatedOnCaptureThread( scoped_ptr<base::SharedMemory> shm(new base::SharedMemory(handle, false)); if (!shm->Map(length)) { - DLOG(ERROR) << "DoBufferCreatedOnCaptureThread: Map() failed."; + DLOG(ERROR) << "OnBufferCreated: Map failed."; return; } @@ -228,8 +192,8 @@ void VideoCaptureImpl::DoBufferCreatedOnCaptureThread( DCHECK(inserted); } -void VideoCaptureImpl::DoBufferDestroyedOnCaptureThread(int buffer_id) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) { + DCHECK(thread_checker_.CalledOnValidThread()); ClientBufferMap::iterator iter = client_buffers_.find(buffer_id); if (iter == client_buffers_.end()) @@ -240,18 +204,30 @@ void VideoCaptureImpl::DoBufferDestroyedOnCaptureThread(int buffer_id) { client_buffers_.erase(iter); } -void VideoCaptureImpl::DoBufferReceivedOnCaptureThread( - int buffer_id, - base::Time timestamp, - const media::VideoCaptureFormat& format) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +void VideoCaptureImpl::OnBufferReceived(int buffer_id, + const media::VideoCaptureFormat& format, + base::TimeTicks timestamp) { + DCHECK(thread_checker_.CalledOnValidThread()); + + // The capture pipeline supports only I420 for now. + DCHECK_EQ(format.pixel_format, media::PIXEL_FORMAT_I420); if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) { - Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id)); + Send(new VideoCaptureHostMsg_BufferReady( + device_id_, buffer_id, std::vector<uint32>())); return; } last_frame_format_ = format; + if (first_frame_timestamp_.is_null()) + first_frame_timestamp_ = timestamp; + + // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc + TRACE_EVENT_INSTANT2( + "cast_perf_test", "OnBufferReceived", + TRACE_EVENT_SCOPE_THREAD, + "timestamp", timestamp.ToInternalValue(), + "time_delta", (timestamp - first_frame_timestamp_).ToInternalValue()); ClientBufferMap::iterator iter = client_buffers_.find(buffer_id); DCHECK(iter != client_buffers_.end()); @@ -265,64 +241,104 @@ void VideoCaptureImpl::DoBufferReceivedOnCaptureThread( reinterpret_cast<uint8*>(buffer->buffer->memory()), buffer->buffer_size, buffer->buffer->handle(), - // TODO(sheu): convert VideoCaptureMessageFilter::Delegate to use - // base::TimeTicks instead of base::Time. http://crbug.com/249215 - timestamp - base::Time::UnixEpoch(), - media::BindToLoop( - capture_message_loop_proxy_, - base::Bind( - &VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread, - weak_this_factory_.GetWeakPtr(), - buffer_id, - buffer))); - - for (ClientInfo::iterator it = clients_.begin(); it != clients_.end(); ++it) - it->first->OnFrameReady(this, frame); + timestamp - first_frame_timestamp_, + media::BindToCurrentLoop( + base::Bind(&VideoCaptureImpl::OnClientBufferFinished, + weak_factory_.GetWeakPtr(), + buffer_id, + buffer, + std::vector<uint32>()))); + + for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end(); + ++it) { + it->second.deliver_frame_cb.Run(frame, format, timestamp); + } +} + +static void NullReadPixelsCB(const SkBitmap& bitmap) { NOTIMPLEMENTED(); } + +void VideoCaptureImpl::OnMailboxBufferReceived( + int buffer_id, + const gpu::MailboxHolder& mailbox_holder, + const media::VideoCaptureFormat& format, + base::TimeTicks timestamp) { + DCHECK(thread_checker_.CalledOnValidThread()); + + if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) { + Send(new VideoCaptureHostMsg_BufferReady( + device_id_, buffer_id, std::vector<uint32>())); + return; + } + + last_frame_format_ = format; + if (first_frame_timestamp_.is_null()) + first_frame_timestamp_ = timestamp; + + scoped_refptr<media::VideoFrame> frame = media::VideoFrame::WrapNativeTexture( + make_scoped_ptr(new gpu::MailboxHolder(mailbox_holder)), + media::BindToCurrentLoop( + base::Bind(&VideoCaptureImpl::OnClientBufferFinished, + weak_factory_.GetWeakPtr(), + buffer_id, + scoped_refptr<ClientBuffer>())), + last_frame_format_.frame_size, + gfx::Rect(last_frame_format_.frame_size), + last_frame_format_.frame_size, + timestamp - first_frame_timestamp_, + base::Bind(&NullReadPixelsCB)); + + for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end(); + ++it) { + it->second.deliver_frame_cb.Run(frame, format, timestamp); + } } -void VideoCaptureImpl::DoClientBufferFinishedOnCaptureThread( +void VideoCaptureImpl::OnClientBufferFinished( int buffer_id, - const scoped_refptr<ClientBuffer>& buffer) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); - Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id)); + const scoped_refptr<ClientBuffer>& /* ignored_buffer */, + const std::vector<uint32>& release_sync_points) { + DCHECK(thread_checker_.CalledOnValidThread()); + Send(new VideoCaptureHostMsg_BufferReady( + device_id_, buffer_id, release_sync_points)); } -void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) { + DCHECK(thread_checker_.CalledOnValidThread()); switch (state) { case VIDEO_CAPTURE_STATE_STARTED: + // Camera has started in the browser process. Since we have already + // told all clients that we have started there's nothing to do. break; case VIDEO_CAPTURE_STATE_STOPPED: state_ = VIDEO_CAPTURE_STATE_STOPPED; DVLOG(1) << "OnStateChanged: stopped!, device_id = " << device_id_; client_buffers_.clear(); - weak_this_factory_.InvalidateWeakPtrs(); + weak_factory_.InvalidateWeakPtrs(); if (!clients_.empty() || !clients_pending_on_restart_.empty()) RestartCapture(); break; case VIDEO_CAPTURE_STATE_PAUSED: - for (ClientInfo::iterator it = clients_.begin(); + for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end(); ++it) { - it->first->OnPaused(this); + it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_PAUSED); } break; case VIDEO_CAPTURE_STATE_ERROR: DVLOG(1) << "OnStateChanged: error!, device_id = " << device_id_; - for (ClientInfo::iterator it = clients_.begin(); + for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end(); ++it) { - // TODO(wjia): browser process would send error code. - it->first->OnError(this, 1); - it->first->OnRemoved(this); + it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_ERROR); } clients_.clear(); state_ = VIDEO_CAPTURE_STATE_ERROR; break; case VIDEO_CAPTURE_STATE_ENDED: DVLOG(1) << "OnStateChanged: ended!, device_id = " << device_id_; - for (ClientInfo::iterator it = clients_.begin(); + for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end(); ++it) { - it->first->OnRemoved(this); + // We'll only notify the client that the stream has stopped. + it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED); } clients_.clear(); state_ = VIDEO_CAPTURE_STATE_ENDED; @@ -332,29 +348,43 @@ void VideoCaptureImpl::DoStateChangedOnCaptureThread(VideoCaptureState state) { } } -void VideoCaptureImpl::DoDelegateAddedOnCaptureThread(int32 device_id) { - DVLOG(1) << "DoDelegateAdded: device_id " << device_id; - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +void VideoCaptureImpl::OnDeviceSupportedFormatsEnumerated( + const media::VideoCaptureFormats& supported_formats) { + DCHECK(thread_checker_.CalledOnValidThread()); + for (size_t i = 0; i < device_formats_cb_queue_.size(); ++i) + device_formats_cb_queue_[i].Run(supported_formats); + device_formats_cb_queue_.clear(); +} + +void VideoCaptureImpl::OnDeviceFormatsInUseReceived( + const media::VideoCaptureFormats& formats_in_use) { + DCHECK(thread_checker_.CalledOnValidThread()); + for (size_t i = 0; i < device_formats_in_use_cb_queue_.size(); ++i) + device_formats_in_use_cb_queue_[i].Run(formats_in_use); + device_formats_in_use_cb_queue_.clear(); +} + +void VideoCaptureImpl::OnDelegateAdded(int32 device_id) { + DCHECK(thread_checker_.CalledOnValidThread()); + DVLOG(1) << "OnDelegateAdded: device_id " << device_id; device_id_ = device_id; - for (ClientInfo::iterator it = clients_pending_on_filter_.begin(); + for (ClientInfoMap::iterator it = clients_pending_on_filter_.begin(); it != clients_pending_on_filter_.end(); ) { - media::VideoCapture::EventHandler* handler = it->first; - const media::VideoCaptureParams params = it->second; + int client_id = it->first; + VideoCaptureStateUpdateCB state_update_cb = + it->second.state_update_cb; + VideoCaptureDeliverFrameCB deliver_frame_cb = + it->second.deliver_frame_cb; + const media::VideoCaptureParams params = it->second.params; clients_pending_on_filter_.erase(it++); - StartCapture(handler, params); + StartCapture(client_id, params, state_update_cb, + deliver_frame_cb); } } -void VideoCaptureImpl::DoSuspendCaptureOnCaptureThread(bool suspend) { - DVLOG(1) << "DoSuspendCapture: suspend " << (suspend ? "yes" : "no"); - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); - - suspended_ = suspend; -} - void VideoCaptureImpl::StopDevice() { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); + DCHECK(thread_checker_.CalledOnValidThread()); if (state_ == VIDEO_CAPTURE_STATE_STARTED) { state_ = VIDEO_CAPTURE_STATE_STOPPING; @@ -364,22 +394,20 @@ void VideoCaptureImpl::StopDevice() { } void VideoCaptureImpl::RestartCapture() { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); + DCHECK(thread_checker_.CalledOnValidThread()); DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPED); int width = 0; int height = 0; - for (ClientInfo::iterator it = clients_.begin(); + clients_.insert(clients_pending_on_restart_.begin(), + clients_pending_on_restart_.end()); + clients_pending_on_restart_.clear(); + for (ClientInfoMap::iterator it = clients_.begin(); it != clients_.end(); ++it) { - width = std::max(width, it->second.requested_format.frame_size.width()); - height = std::max(height, it->second.requested_format.frame_size.height()); - } - for (ClientInfo::iterator it = clients_pending_on_restart_.begin(); - it != clients_pending_on_restart_.end(); ) { - width = std::max(width, it->second.requested_format.frame_size.width()); - height = std::max(height, it->second.requested_format.frame_size.height()); - clients_[it->first] = it->second; - clients_pending_on_restart_.erase(it++); + width = std::max(width, + it->second.params.requested_format.frame_size.width()); + height = std::max(height, + it->second.params.requested_format.frame_size.height()); } params_.requested_format.frame_size.SetSize(width, height); DVLOG(1) << "RestartCapture, " @@ -388,40 +416,25 @@ void VideoCaptureImpl::RestartCapture() { } void VideoCaptureImpl::StartCaptureInternal() { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); + DCHECK(thread_checker_.CalledOnValidThread()); DCHECK(device_id_); Send(new VideoCaptureHostMsg_Start(device_id_, session_id_, params_)); state_ = VIDEO_CAPTURE_STATE_STARTED; } -void VideoCaptureImpl::AddDelegateOnIOThread() { - DCHECK(io_message_loop_proxy_->BelongsToCurrentThread()); - message_filter_->AddDelegate(this); -} - -void VideoCaptureImpl::RemoveDelegateOnIOThread(base::Closure task) { - DCHECK(io_message_loop_proxy_->BelongsToCurrentThread()); - message_filter_->RemoveDelegate(this); - capture_message_loop_proxy_->PostTask(FROM_HERE, task); -} - void VideoCaptureImpl::Send(IPC::Message* message) { - io_message_loop_proxy_->PostTask(FROM_HERE, - base::Bind(base::IgnoreResult(&VideoCaptureMessageFilter::Send), - message_filter_.get(), message)); + DCHECK(thread_checker_.CalledOnValidThread()); + message_filter_->Send(message); } -bool VideoCaptureImpl::RemoveClient( - media::VideoCapture::EventHandler* handler, - ClientInfo* clients) { - DCHECK(capture_message_loop_proxy_->BelongsToCurrentThread()); +bool VideoCaptureImpl::RemoveClient(int client_id, ClientInfoMap* clients) { + DCHECK(thread_checker_.CalledOnValidThread()); bool found = false; - ClientInfo::iterator it = clients->find(handler); + ClientInfoMap::iterator it = clients->find(client_id); if (it != clients->end()) { - handler->OnStopped(this); - handler->OnRemoved(this); + it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED); clients->erase(it); found = true; } |