Make painting a single frame a permanent API on VideoRendererSink.

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 "base/time/default_tick_clock.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 113 matching lines @@
   // returning to avoid a pending UpdateCurrentFrame() call occurring before
   // the PostTask is processed.
   base::AutoLock lock(callback_lock_);
   DCHECK(callback_);
   callback_ = nullptr;
   compositor_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoFrameCompositor::OnRendererStateUpdate,
                             base::Unretained(this), false));
 }
 
-void VideoFrameCompositor::PaintFrameUsingOldRenderingPath(
+void VideoFrameCompositor::PaintSingleFrame(
     const scoped_refptr<VideoFrame>& frame) {
   if (!compositor_task_runner_->BelongsToCurrentThread()) {
     compositor_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&VideoFrameCompositor::PaintFrameUsingOldRenderingPath,
-                   base::Unretained(this), frame));
+        FROM_HERE, base::Bind(&VideoFrameCompositor::PaintSingleFrame,
+                              base::Unretained(this), frame));
     return;
   }
 
   if (ProcessNewFrame(frame) && client_)
     client_->DidReceiveFrame();
 }
 
 scoped_refptr<VideoFrame>
 VideoFrameCompositor::GetCurrentFrameAndUpdateIfStale() {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
@@ skipping 14 matching lines @@
   last_interval_ = interval;
   BackgroundRender();
 
   return current_frame_;
 }
 
 base::TimeDelta VideoFrameCompositor::GetCurrentFrameTimestamp() const {
   // When the VFC is stopped, |callback_| is cleared; this synchronously
   // prevents CallRender() from invoking ProcessNewFrame(), and so
   // |current_frame_| won't change again until after Start(). (Assuming that
-  // PaintFrameUsingOldRenderingPath() is not also called while stopped.)
+  // PaintSingleFrame() is not also called while stopped.)
   if (!current_frame_)
     return base::TimeDelta();
   return current_frame_->timestamp();
 }
 
 bool VideoFrameCompositor::ProcessNewFrame(
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
 
   if (frame == current_frame_)
@@ skipping 50 matching lines @@
   last_interval_ = deadline_max - deadline_min;
 
   // Restart the background rendering timer whether we're background rendering
   // or not; in either case we should wait for |kBackgroundRenderingTimeoutMs|.
   if (background_rendering_enabled_)
     background_rendering_timer_.Reset();
   return new_frame || had_new_background_frame;
 }
 
 }  // namespace media