Deliver video frames on libjingle worker thread to WebRtcVideoCapturerAdapter.

content/renderer/media/webrtc/webrtc_video_capturer_adapter.cc

 // Copyright 2014 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.
 
 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/aligned_memory.h"
 #include "media/base/video_frame.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
 
 namespace content {
 
-WebRtcVideoCapturerAdapter::WebRtcVideoCapturerAdapter(bool is_screencast)
-    : is_screencast_(is_screencast),
+WebRtcVideoCapturerAdapter::WebRtcVideoCapturerAdapter(
+    const scoped_refptr<base::MessageLoopProxy>& worker_thread_proxy,
+    bool is_screencast)
+    : worker_thread_proxy_(worker_thread_proxy),

[Ami GONE FROM CHROMIUM, 2014/05/12 18:13:33]

AFAICT worker_thread_proxy_ is only ever used to assert being on a particular
thread, which sounds like a thread_checker_ to me.  But thread_checker_'s
DetachFromThread() is never called, meaning you could drop w_t_p_ and just use
DCHECK(thread_checker_.CalledOnValidThread()); at each use-site of w_t_p_,
right?

[perkj_chrome, 2014/05/12 19:28:26]

yes- that would be cleaner I think, I used thread_checker to make sure
WebRtcVideoCapturerAdapter was deleted on the same thread that created it. But I
will skip that and only check the usage here. 

+      is_screencast_(is_screencast),
       running_(false),
       buffer_(NULL),
       buffer_size_(0) {
 }
 
 WebRtcVideoCapturerAdapter::~WebRtcVideoCapturerAdapter() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(3) << " WebRtcVideoCapturerAdapter::dtor";
   base::AlignedFree(buffer_);
 }
 
 cricket::CaptureState WebRtcVideoCapturerAdapter::Start(
     const cricket::VideoFormat& capture_format) {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   DCHECK(!running_);
   DVLOG(3) << " WebRtcVideoCapturerAdapter::Start w = " << capture_format.width
            << " h = " << capture_format.height;
 
   running_ = true;
   return cricket::CS_RUNNING;
 }
 
 void WebRtcVideoCapturerAdapter::Stop() {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   DVLOG(3) << " WebRtcVideoCapturerAdapter::Stop ";
   DCHECK(running_);
   running_ = false;
   SetCaptureFormat(NULL);
   SignalStateChange(this, cricket::CS_STOPPED);
 }
 
 bool WebRtcVideoCapturerAdapter::IsRunning() {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   return running_;
 }
 
 bool WebRtcVideoCapturerAdapter::GetPreferredFourccs(
     std::vector<uint32>* fourccs) {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   if (!fourccs)
     return false;
   fourccs->push_back(cricket::FOURCC_I420);
   return true;
 }
 
 bool WebRtcVideoCapturerAdapter::IsScreencast() const {
   return is_screencast_;
 }
 
 bool WebRtcVideoCapturerAdapter::GetBestCaptureFormat(
     const cricket::VideoFormat& desired,
     cricket::VideoFormat* best_format) {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   DVLOG(3) << " GetBestCaptureFormat:: "
            << " w = " << desired.width
            << " h = " << desired.height;
 
   // Capability enumeration is done in MediaStreamVideoSource. The adapter can
   // just use what is provided.
   // Use the desired format as the best format.
   best_format->width = desired.width;
   best_format->height = desired.height;
   best_format->fourcc = cricket::FOURCC_I420;
   best_format->interval = desired.interval;
   return true;
 }
 
 void WebRtcVideoCapturerAdapter::OnFrameCaptured(
     const scoped_refptr<media::VideoFrame>& frame) {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   DCHECK(media::VideoFrame::I420 == frame->format() ||
          media::VideoFrame::YV12 == frame->format());
   if (first_frame_timestamp_ == media::kNoTimestamp())
     first_frame_timestamp_ = frame->timestamp();
 
   cricket::CapturedFrame captured_frame;
   captured_frame.width = frame->visible_rect().width();
   captured_frame.height = frame->visible_rect().height();
   // cricket::CapturedFrame time is in nanoseconds.
   captured_frame.elapsed_time =
@@ skipping 23 matching lines @@
         media::VideoFrame::AllocationSize(frame->format(), frame->coded_size());
   }
 
   // This signals to libJingle that a new VideoFrame is available.
   // libJingle have no assumptions on what thread this signal come from.
   SignalFrameCaptured(this, &captured_frame);
 }
 
 void WebRtcVideoCapturerAdapter::UpdateI420Buffer(
     const scoped_refptr<media::VideoFrame>& src) {
+  DCHECK(worker_thread_proxy_->BelongsToCurrentThread());
   const int src_width = src->coded_size().width();
   const int src_height = src->coded_size().height();
   const int dst_width = src->visible_rect().width();
   const int dst_height = src->visible_rect().height();
   DCHECK(src_width >= dst_width && src_height >= dst_height);
 
   const int horiz_crop = src->visible_rect().x();
   const int vert_crop = src->visible_rect().y();
 
   const uint8* src_y = src->data(media::VideoFrame::kYPlane) +
@@ skipping 33 matching lines @@
                    dst_stride_y,
                    dst_u,
                    dst_halfwidth,
                    dst_v,
                    dst_halfwidth,
                    dst_width,
                    dst_height);
 }
 
 }  // namespace content