Add VideoTrackSink interface to content/public

content/renderer/media/rtc_video_renderer.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.
 
 #include "content/renderer/media/rtc_video_renderer.h"
 
-#include "base/bind.h"
 #include "base/debug/trace_event.h"
-#include "base/location.h"
-#include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "content/renderer/media/native_handle_impl.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
-#include "third_party/libjingle/source/talk/media/base/videoframe.h"
-
-using media::CopyYPlane;
-using media::CopyUPlane;
-using media::CopyVPlane;
 
 namespace content {
 
 RTCVideoRenderer::RTCVideoRenderer(
-    webrtc::VideoTrackInterface* video_track,
+    const blink::WebMediaStreamTrack& video_track,
     const base::Closure& error_cb,
     const RepaintCB& repaint_cb)
     : error_cb_(error_cb),
       repaint_cb_(repaint_cb),
       message_loop_proxy_(base::MessageLoopProxy::current()),
       state_(kStopped),
       video_track_(video_track) {
+  MaybeRenderSignalingFrame(video_track_.source().readyState());
 }
 
 RTCVideoRenderer::~RTCVideoRenderer() {
 }
 
 void RTCVideoRenderer::Start() {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopped);
 
-  if (video_track_.get()) {
-    video_track_->AddRenderer(this);
-    video_track_->RegisterObserver(this);
-  }
+  AddToVideoTrack(this, video_track_);

[Alpha Left Google, 2013/12/02 17:44:37]

I don't think you can stash a WebMediaStreamTrack object, see my comments in the
header file.

I think you'll need to use a URL and device ID to access the track similar to:
blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor().

[perkj_chrome, 2013/12/03 16:14:17]

See my comment in the header file.
We added the extra data field to avoid that since track ids are not guaranteed
to be globally unique. If stashing a Web object really is a problem we can
consider storing a weak ptr to the MediaStreamVideoTrack object here instead and
change MediaStreamVideoTrack to support weak ptrs.

The question is just how you would be able to deregister a sink from a video
track in chrome if you are not allowed to hold on to a WebMediaStreamTrack
object.... So I hope holding on to a WebMediaStreamTrack instance is ok. 

   state_ = kStarted;
-  MaybeRenderSignalingFrame();
 }
 
 void RTCVideoRenderer::Stop() {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  if (video_track_.get()) {
-    state_ = kStopped;
-    video_track_->RemoveRenderer(this);
-    video_track_->UnregisterObserver(this);
-    video_track_ = NULL;
-  }
+  RemoveFromVideoTrack(this, video_track_);
 }
 
 void RTCVideoRenderer::Play() {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  if (video_track_.get() && state_ == kPaused) {
+  if (state_ == kPaused) {
     state_ = kStarted;
   }
 }
 
 void RTCVideoRenderer::Pause() {
   DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  if (video_track_.get() && state_ == kStarted) {
+  if (state_ == kStarted) {
     state_ = kPaused;
   }
 }
 
-void RTCVideoRenderer::SetSize(int width, int height) {
+void RTCVideoRenderer::OnReadyStateChanged(
+    blink::WebMediaStreamSource::ReadyState state) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  MaybeRenderSignalingFrame(state);
 }
 
-void RTCVideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
-  base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
-      frame->GetTimeStamp() / talk_base::kNumNanosecsPerMillisec);
-
-  TRACE_EVENT_INSTANT2("rtc_video_renderer",
-                       "RenderFrame",
-                       TRACE_EVENT_SCOPE_THREAD,
-                       "elapsed time",
-                       frame->GetElapsedTime(),
-                       "timestamp_ms",
-                       timestamp.InMilliseconds());
-
-  scoped_refptr<media::VideoFrame> video_frame;
-  if (frame->GetNativeHandle() != NULL) {
-    NativeHandleImpl* handle =
-        static_cast<NativeHandleImpl*>(frame->GetNativeHandle());
-    video_frame = static_cast<media::VideoFrame*>(handle->GetHandle());
-    video_frame->SetTimestamp(timestamp);
-  } else {
-    gfx::Size size(frame->GetWidth(), frame->GetHeight());
-    video_frame = media::VideoFrame::CreateFrame(
-        media::VideoFrame::YV12, size, gfx::Rect(size), size, timestamp);
-
-    // Aspect ratio unsupported; DCHECK when there are non-square pixels.
-    DCHECK_EQ(frame->GetPixelWidth(), 1u);
-    DCHECK_EQ(frame->GetPixelHeight(), 1u);
-
-    int y_rows = frame->GetHeight();
-    int uv_rows = frame->GetHeight() / 2;  // YV12 format.
-    CopyYPlane(
-        frame->GetYPlane(), frame->GetYPitch(), y_rows, video_frame.get());
-    CopyUPlane(
-        frame->GetUPlane(), frame->GetUPitch(), uv_rows, video_frame.get());
-    CopyVPlane(
-        frame->GetVPlane(), frame->GetVPitch(), uv_rows, video_frame.get());
+void RTCVideoRenderer::OnVideoFrame(
+    const scoped_refptr<media::VideoFrame>& frame) {
+  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
+  if (state_ != kStarted) {
+    return;
   }
 
-  message_loop_proxy_->PostTask(
-      FROM_HERE, base::Bind(&RTCVideoRenderer::DoRenderFrameOnMainThread,
-                            this, video_frame));
+  TRACE_EVENT_INSTANT1("rtc_video_renderer",
+                       "OnVideoFrame",
+                       TRACE_EVENT_SCOPE_THREAD,
+                       "timestamp",
+                       frame->GetTimestamp().InMilliseconds());
+  repaint_cb_.Run(frame);
 }
 
-void RTCVideoRenderer::OnChanged() {
-  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  MaybeRenderSignalingFrame();
-}
-
-void RTCVideoRenderer::MaybeRenderSignalingFrame() {
+void RTCVideoRenderer::MaybeRenderSignalingFrame(
+    blink::WebMediaStreamSource::ReadyState state) {
   // Render a small black frame if the track transition to ended.
   // This is necessary to make sure audio can play if the video tag src is
   // a MediaStream video track that has been rejected or ended.
-  if (video_track_->state() == webrtc::MediaStreamTrackInterface::kEnded) {
+  if (state == blink::WebMediaStreamSource::ReadyStateEnded) {
     const int kMinFrameSize = 2;
     const gfx::Size size(kMinFrameSize, kMinFrameSize);
     scoped_refptr<media::VideoFrame> video_frame =
         media::VideoFrame::CreateBlackFrame(size);
-    DoRenderFrameOnMainThread(video_frame);
+    OnVideoFrame(video_frame);
   }
 }
 
-void RTCVideoRenderer::DoRenderFrameOnMainThread(
-    scoped_refptr<media::VideoFrame> video_frame) {
-  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-
-  if (state_ != kStarted) {
-    return;
-  }
-
-  TRACE_EVENT0("video", "DoRenderFrameOnMainThread");
-  repaint_cb_.Run(video_frame);
-}
-
 }  // namespace content