Changed thread_checker on VideoCaptureImpl and VideoCaptureImplManager.

content/renderer/media/video_capture_impl.cc

 // 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.
@@ skipping 34 matching lines @@
 VideoCaptureImpl::VideoCaptureImpl(
     const media::VideoCaptureSessionId session_id,
     VideoCaptureMessageFilter* filter)
     : message_filter_(filter),
       device_id_(0),
       session_id_(session_id),
       suspended_(false),
       state_(VIDEO_CAPTURE_STATE_STOPPED),
       weak_factory_(this) {
   DCHECK(filter);
-  render_io_thread_checker_.DetachFromThread();
 }
 
 VideoCaptureImpl::~VideoCaptureImpl() {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 }
 
 void VideoCaptureImpl::Init() {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  // For creating callbacks in unittest, this class may be constructed from a
+  // different thread than the IO thread, e.g. wherever unittest runs on.
+  // Therefore, this function should define the thread ownership.
+#if DCHECK_IS_ON()
+  io_message_loop_ = base::MessageLoopProxy::current();
+#endif
   message_filter_->AddDelegate(this);
 }
 
 void VideoCaptureImpl::DeInit() {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   if (state_ == VIDEO_CAPTURE_STATE_STARTED)
     Send(new VideoCaptureHostMsg_Stop(device_id_));
   message_filter_->RemoveDelegate(this);
 }
 
 void VideoCaptureImpl::SuspendCapture(bool suspend) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   Send(suspend ?
        static_cast<IPC::Message*>(new VideoCaptureHostMsg_Pause(device_id_)) :
        static_cast<IPC::Message*>(
            new VideoCaptureHostMsg_Resume(device_id_, session_id_, params_)));
 }
 
 void VideoCaptureImpl::StartCapture(
     int client_id,
     const media::VideoCaptureParams& params,
     const VideoCaptureStateUpdateCB& state_update_cb,
     const VideoCaptureDeliverFrameCB& deliver_frame_cb) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   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) {
     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)) {
@@ skipping 27 matching lines @@
       }
       DVLOG(1) << "StartCapture: starting with first resolution "
                << params_.requested_format.frame_size.ToString();
       first_frame_timestamp_ = base::TimeTicks();
       StartCaptureInternal();
     }
   }
 }
 
 void VideoCaptureImpl::StopCapture(int client_id) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   // 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().
   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_factory_.InvalidateWeakPtrs();
   }
 }
 
 void VideoCaptureImpl::GetDeviceSupportedFormats(
     const VideoCaptureDeviceFormatsCB& callback) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   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(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   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(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   // In case client calls StopCapture before the arrival of created buffer,
   // just close this buffer and return.
   if (state_ != VIDEO_CAPTURE_STATE_STARTED) {
     base::SharedMemory::CloseHandle(handle);
     return;
   }
 
   scoped_ptr<base::SharedMemory> shm(new base::SharedMemory(handle, false));
   if (!shm->Map(length)) {
     DLOG(ERROR) << "OnBufferCreated: Map failed.";
     return;
   }
 
   bool inserted =
       client_buffers_.insert(std::make_pair(
                                  buffer_id,
                                  new ClientBuffer(shm.Pass(),
                                                   length))).second;
   DCHECK(inserted);
 }
 
 void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   const ClientBufferMap::iterator iter = client_buffers_.find(buffer_id);
   if (iter == client_buffers_.end())
     return;
 
   DCHECK(!iter->second.get() || iter->second->HasOneRef())
       << "Instructed to delete buffer we are still using.";
   client_buffers_.erase(iter);
 }
 
 void VideoCaptureImpl::OnBufferReceived(int buffer_id,
                                         const gfx::Size& coded_size,
                                         const gfx::Rect& visible_rect,
                                         base::TimeTicks timestamp,
                                         const base::DictionaryValue& metadata) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
     return;
   }
 
   if (first_frame_timestamp_.is_null())
     first_frame_timestamp_ = timestamp;
 
   // Used by chrome/browser/extension/api/cast_streaming/performance_test.cc
@@ skipping 28 matching lines @@
   for (const auto& client : clients_)
     client.second.deliver_frame_cb.Run(frame, timestamp);
 }
 
 void VideoCaptureImpl::OnMailboxBufferReceived(
     int buffer_id,
     const gpu::MailboxHolder& mailbox_holder,
     const gfx::Size& packed_frame_size,
     base::TimeTicks timestamp,
     const base::DictionaryValue& metadata) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_) {
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id, 0));
     return;
   }
 
   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>())),
       packed_frame_size, gfx::Rect(packed_frame_size), packed_frame_size,
       timestamp - first_frame_timestamp_, false);
   frame->metadata()->MergeInternalValuesFrom(metadata);
 
   for (const auto& client : clients_)
     client.second.deliver_frame_cb.Run(frame, timestamp);
 }
 
 void VideoCaptureImpl::OnClientBufferFinished(
     int buffer_id,
     const scoped_refptr<ClientBuffer>& /* ignored_buffer */,
     uint32 release_sync_point) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   Send(new VideoCaptureHostMsg_BufferReady(
       device_id_, buffer_id, release_sync_point));
 }
 
 void VideoCaptureImpl::OnStateChanged(VideoCaptureState state) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   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();
@@ skipping 21 matching lines @@
       clients_.clear();
       state_ = VIDEO_CAPTURE_STATE_ENDED;
       break;
     default:
       break;
   }
 }
 
 void VideoCaptureImpl::OnDeviceSupportedFormatsEnumerated(
     const media::VideoCaptureFormats& supported_formats) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   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(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   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(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   DVLOG(1) << "OnDelegateAdded: device_id " << device_id;
 
   device_id_ = device_id;
   ClientInfoMap::iterator it = clients_pending_on_filter_.begin();
   while (it != clients_pending_on_filter_.end()) {
     const int client_id = it->first;
     const ClientInfo client_info = it->second;
     clients_pending_on_filter_.erase(it++);
     StartCapture(client_id, client_info.params, client_info.state_update_cb,
                  client_info.deliver_frame_cb);
   }
 }
 
 void VideoCaptureImpl::StopDevice() {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     state_ = VIDEO_CAPTURE_STATE_STOPPING;
     Send(new VideoCaptureHostMsg_Stop(device_id_));
     params_.requested_format.frame_size.SetSize(0, 0);
   }
 }
 
 void VideoCaptureImpl::RestartCapture() {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, VIDEO_CAPTURE_STATE_STOPPED);
 
   int width = 0;
   int height = 0;
   clients_.insert(clients_pending_on_restart_.begin(),
                   clients_pending_on_restart_.end());
   clients_pending_on_restart_.clear();
   for (const auto& client : clients_) {
     width = std::max(width,
                      client.second.params.requested_format.frame_size.width());
     height = std::max(
         height, client.second.params.requested_format.frame_size.height());
   }
   params_.requested_format.frame_size.SetSize(width, height);
   DVLOG(1) << "RestartCapture, "
            << params_.requested_format.frame_size.ToString();
   StartCaptureInternal();
 }
 
 void VideoCaptureImpl::StartCaptureInternal() {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   DCHECK(device_id_);
 
   Send(new VideoCaptureHostMsg_Start(device_id_, session_id_, params_));
   state_ = VIDEO_CAPTURE_STATE_STARTED;
 }
 
 void VideoCaptureImpl::Send(IPC::Message* message) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   message_filter_->Send(message);
 }
 
 bool VideoCaptureImpl::RemoveClient(int client_id, ClientInfoMap* clients) {
-  DCHECK(render_io_thread_checker_.CalledOnValidThread());
+  DCHECK(io_message_loop_->BelongsToCurrentThread());
   bool found = false;
 
   const ClientInfoMap::iterator it = clients->find(client_id);
   if (it != clients->end()) {
     it->second.state_update_cb.Run(VIDEO_CAPTURE_STATE_STOPPED);
     clients->erase(it);
     found = true;
   }
   return found;
 }
 
 }  // namespace content