Moves video frame callbacks from VideoFrameCompositor to Renderer.

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"
 #include "media/base/video_frame.h"
 
 namespace media {
 
 // Amount of time to wait between UpdateCurrentFrame() callbacks before starting
 // background rendering to keep the Render() callbacks moving.
 const int kBackgroundRenderingTimeoutMs = 250;
 
 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)
+    const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner)
     : compositor_task_runner_(compositor_task_runner),
       tick_clock_(new base::DefaultTickClock()),
-      natural_size_changed_cb_(natural_size_changed_cb),
-      opacity_changed_cb_(opacity_changed_cb),
       background_rendering_enabled_(true),
       background_rendering_timer_(
           FROM_HERE,
           base::TimeDelta::FromMilliseconds(kBackgroundRenderingTimeoutMs),
           base::Bind(&VideoFrameCompositor::BackgroundRender,
                      base::Unretained(this)),
           // Task is not repeating, CallRender() will reset the task as needed.
           false),
       client_(nullptr),
       rendering_(false),
@@ skipping 149 matching lines @@
     const scoped_refptr<VideoFrame>& frame) {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
 
   if (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;
 
-  if (!current_frame_ ||
-      current_frame_->natural_size() != frame->natural_size()) {
-    natural_size_changed_cb_.Run(frame->natural_size());
-  }
-
-  if (!current_frame_ ||
-      IsOpaque(current_frame_->format()) != IsOpaque(frame->format()))
-    opacity_changed_cb_.Run(IsOpaque(frame->format()));
-
   current_frame_ = frame;
   return true;
 }
 
 void VideoFrameCompositor::BackgroundRender() {
   DCHECK(compositor_task_runner_->BelongsToCurrentThread());
   const base::TimeTicks now = tick_clock_->NowTicks();
   last_background_render_ = now;
   bool new_frame = CallRender(now, now + last_interval_, true);
   if (new_frame && client_)
@@ skipping 34 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