Prime the landing pad for the new video rendering pipeline.

media/blink/video_frame_compositor.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 "media/blink/video_frame_compositor.h"
 
+#include "base/bind.h"
+#include "base/message_loop/message_loop.h"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 static bool IsOpaque(const scoped_refptr<VideoFrame>& frame) {
   switch (frame->format()) {
     case VideoFrame::UNKNOWN:
     case VideoFrame::YV12:
     case VideoFrame::YV12J:
     case VideoFrame::YV12HD:
     case VideoFrame::YV16:
     case VideoFrame::I420:
     case VideoFrame::YV24:
     case VideoFrame::NV12:
       return true;
 
     case VideoFrame::YV12A:
 #if defined(VIDEO_HOLE)
     case VideoFrame::HOLE:
 #endif  // defined(VIDEO_HOLE)
     case VideoFrame::NATIVE_TEXTURE:
     case VideoFrame::ARGB:
       break;
   }
   return false;
 }
 
 VideoFrameCompositor::VideoFrameCompositor(
+    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
     const base::Callback<void(gfx::Size)>& natural_size_changed_cb,
     const base::Callback<void(bool)>& opacity_changed_cb)
-    : natural_size_changed_cb_(natural_size_changed_cb),
+    : compositor_task_runner_(compositor_task_runner),
+      natural_size_changed_cb_(natural_size_changed_cb),
       opacity_changed_cb_(opacity_changed_cb),
-      client_(NULL) {
+      client_(nullptr),
+      callback_(nullptr),
+      rendering_(false) {
 }
 
 VideoFrameCompositor::~VideoFrameCompositor() {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  DCHECK(!callback_);
+  DCHECK(!rendering_);
   if (client_)
     client_->StopUsingProvider();
 }
 
+void VideoFrameCompositor::StartRendering() {
+  if (!compositor_task_runner_->BelongsToCurrentThread()) {
+    compositor_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VideoFrameCompositor::StartRendering,
+                              base::Unretained(this)));
+    return;
+  }
+
+  base::AutoLock lock(lock_);
+  if (client_ && !rendering_ && callback_)
+    client_->StartRendering();
+  rendering_ = true;
+}
+
+void VideoFrameCompositor::OnRendererStateUpdate() {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  if (!client_)
+    return;
+
+  base::AutoLock lock(lock_);
+  if (callback_) {
+    if (rendering_)
+      client_->StartRendering();
+
+    // TODO(dalecurtis): This will need to request the first frame so we have
+    // something to show, even if playback hasn't started yet.
+  } else if (rendering_) {
+    client_->StopRendering();
+  }
+}
+
+void VideoFrameCompositor::StopRendering() {
+  if (!compositor_task_runner_->BelongsToCurrentThread()) {
+    compositor_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&VideoFrameCompositor::StopRendering,
+                              base::Unretained(this)));
+    return;
+  }
+
+  if (client_ && rendering_)
+    client_->StopRendering();
+  rendering_ = false;
+}
+
 void VideoFrameCompositor::SetVideoFrameProviderClient(
     cc::VideoFrameProvider::Client* client) {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   if (client_)
     client_->StopUsingProvider();
   client_ = client;
+  OnRendererStateUpdate();
 }
 
 scoped_refptr<VideoFrame> VideoFrameCompositor::GetCurrentFrame() {
+  base::AutoLock lock(lock_);
   return current_frame_;
 }
 
-void VideoFrameCompositor::PutCurrentFrame(
-    const scoped_refptr<VideoFrame>& frame) {
+void VideoFrameCompositor::PutCurrentFrame() {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  // TODO(dalecurtis): Wire up a flag for RenderCallback::OnFrameDropped().
 }
 
-void VideoFrameCompositor::UpdateCurrentFrame(
+void VideoFrameCompositor::SetVisible(bool visible) {
+  DCHECK(compositor_task_runner_->BelongsToCurrentThread());
+  // TODO(dalecurtis): Schedule intermittent render callbacks when visilibity is
+  // turned off. Perhaps once every 100ms?
+}
+
+bool VideoFrameCompositor::Render(base::TimeTicks deadline_min,
+                                  base::TimeTicks deadline_max) {
+  // TODO(dalecurtis): Wire this up to RenderCallback::Render().
+  base::AutoLock lock(lock_);
+  return false;
+}
+
+void VideoFrameCompositor::Start(RenderCallback* callback) {
+  NOTREACHED();
+
+  // Called from the media thread.
+  base::AutoLock lock(lock_);
+  callback_ = callback;
+  compositor_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate,
+                            base::Unretained(this)));
+}
+
+void VideoFrameCompositor::Stop() {
+  NOTREACHED();
+
+  base::AutoLock lock(lock_);
+  callback_ = nullptr;
+  compositor_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate,
+                            base::Unretained(this)));
+}
+
+void VideoFrameCompositor::PaintFrameUsingOldRenderingPath(
     const scoped_refptr<VideoFrame>& frame) {
+  if (!compositor_task_runner_->BelongsToCurrentThread()) {
+    compositor_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&VideoFrameCompositor::PaintFrameUsingOldRenderingPath,
+                   base::Unretained(this), frame));
+    return;
+  }
+
   if (current_frame_.get() &&
       current_frame_->natural_size() != frame->natural_size()) {
     natural_size_changed_cb_.Run(frame->natural_size());
   }
 
   if (!current_frame_.get() || IsOpaque(current_frame_) != IsOpaque(frame)) {
     opacity_changed_cb_.Run(IsOpaque(frame));
   }
 
   current_frame_ = frame;
 
   if (client_)
     client_->DidReceiveFrame();
 }
 
 }  // namespace media