Add "repaint" option to PaintSingleFrame

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 114 matching lines @@
   // 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::PaintSingleFrame(
-    const scoped_refptr<VideoFrame>& frame) {
+    const scoped_refptr<VideoFrame>& frame,
+    bool repaint_duplicate_frame) {
   if (!compositor_task_runner_->BelongsToCurrentThread()) {
     compositor_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VideoFrameCompositor::PaintSingleFrame,
-                              base::Unretained(this), frame));
+        FROM_HERE,
+        base::Bind(&VideoFrameCompositor::PaintSingleFrame,
+                   base::Unretained(this), frame, repaint_duplicate_frame));
     return;
   }
 
-  if (ProcessNewFrame(frame) && client_)
+  if (ProcessNewFrame(frame, repaint_duplicate_frame) && client_)
     client_->DidReceiveFrame();
 }
 
 scoped_refptr<VideoFrame>
 VideoFrameCompositor::GetCurrentFrameAndUpdateIfStale() {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   if (client_ || !rendering_ || !is_background_rendering_)
     return current_frame_;
 
   DCHECK(!last_background_render_.is_null());
@@ skipping 17 matching lines @@
   // 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
   // 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) {
+    const scoped_refptr<VideoFrame>& frame,
+    bool repaint_duplicate_frame) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
 
-  if (frame == current_frame_)
+  if (!repaint_duplicate_frame && frame == current_frame_)
     return false;
 
   // Set the flag indicating that the current frame is unrendered, if we get a
   // subsequent PutCurrentFrame() call it will mark it as rendered.
   rendered_last_frame_ = false;
 
   current_frame_ = frame;
   return true;
 }
 
@@ skipping 21 matching lines @@
   DCHECK(rendering_);
 
   // If the previous frame was never rendered and we're not in background
   // rendering mode (nor have just exited it), let the client know.
   if (!rendered_last_frame_ && current_frame_ && !background_rendering &&
       !is_background_rendering_) {
     callback_->OnFrameDropped();
   }
 
   const bool new_frame = ProcessNewFrame(
-      callback_->Render(deadline_min, deadline_max, background_rendering));
+      callback_->Render(deadline_min, deadline_max, background_rendering),
+      false);
 
   // We may create a new frame here with background rendering, but the provider
   // has no way of knowing that a new frame had been processed, so keep track of
   // the new frame, and return true on the next call to |CallRender|.
   const bool had_new_background_frame = new_background_frame_;
   new_background_frame_ = background_rendering && new_frame;
 
   is_background_rendering_ = background_rendering;
   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