Add video-rendering to mojo media pipeline.

media/blink/video_frame_compositor.h

 // 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.
 
 #ifndef MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_
 #define MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_
 
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 36 matching lines @@
 //
 // VideoFrameCompositor must live on the same thread as the compositor, though
 // it may be constructed on any thread.
 class MEDIA_BLINK_EXPORT VideoFrameCompositor
     : public VideoRendererSink,
       NON_EXPORTED_BASE(public cc::VideoFrameProvider) {
  public:
   // |compositor_task_runner| is the task runner on which this class will live,
   // though it may be constructed on any thread.
   //
-  // |natural_size_changed_cb| is run with the new natural size of the video
-  // frame whenever a change in natural size is detected. It is not called the
-  // first time UpdateCurrentFrame() is called. Run on the same thread as the
-  // caller of UpdateCurrentFrame().
-  //
   // |opacity_changed_cb| is run when a change in opacity is detected. It *is*
   // called the first time UpdateCurrentFrame() is called. Run on the same
   // thread as the caller of UpdateCurrentFrame().
-  //
-  // TODO(dalecurtis): Investigate the inconsistency between the callbacks with
-  // respect to why we don't call |natural_size_changed_cb| on the first frame.
-  // I suspect it was for historical reasons that no longer make sense.
+  // TODO(alokp): Move |opacity_changed_cb| to Renderer.
   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);
 
   // Destruction must happen on the compositor thread; Stop() must have been
   // called before destruction starts.
   ~VideoFrameCompositor() override;
 
   // cc::VideoFrameProvider implementation. These methods must be called on the
   // |compositor_task_runner_|.
   void SetVideoFrameProviderClient(
       cc::VideoFrameProvider::Client* client) override;
@@ skipping 41 matching lines @@
   // rendering call issues when a sink is started.
   void set_background_rendering_for_testing(bool enabled) {
     background_rendering_enabled_ = enabled;
   }
 
  private:
   // Called on the compositor thread in response to Start() or Stop() calls;
   // must be used to change |rendering_| state.
   void OnRendererStateUpdate(bool new_state);
 
-  // Handles setting of |current_frame_| and fires |natural_size_changed_cb_|
-  // and |opacity_changed_cb_| when the frame properties changes.
+  // Handles setting of |current_frame_| and fires |opacity_changed_cb_|
+  // when the frame properties changes.
   bool ProcessNewFrame(const scoped_refptr<VideoFrame>& frame);
 
   // Called by |background_rendering_timer_| when enough time elapses where we
   // haven't seen a Render() call.
   void BackgroundRender();
 
   // If |callback_| is available, calls Render() with the provided properties.
   // Updates |is_background_rendering_|, |last_interval_|, and resets
-  // |background_rendering_timer_|.  Ensures that natural size and opacity
+  // |background_rendering_timer_|.  Ensures that opacity
   // changes are correctly fired.  Returns true if there's a new frame available
   // via GetCurrentFrame().
   bool CallRender(base::TimeTicks deadline_min,
                   base::TimeTicks deadline_max,
                   bool background_rendering);
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner_;
   scoped_ptr<base::TickClock> tick_clock_;
 
-  // These callbacks are executed on the compositor thread.
-  const base::Callback<void(gfx::Size)> natural_size_changed_cb_;
+  // This callback is executed on the compositor thread.
   const base::Callback<void(bool)> opacity_changed_cb_;
 
   // Allows tests to disable the background rendering task.
   bool background_rendering_enabled_;
 
   // Manages UpdateCurrentFrame() callbacks if |client_| has stopped sending
   // them for various reasons.  Runs on |compositor_task_runner_| and is reset
   // after each successful UpdateCurrentFrame() call.
   base::Timer background_rendering_timer_;
 
@@ skipping 13 matching lines @@
   // These values are updated and read from the media and compositor threads.
   base::Lock callback_lock_;
   VideoRendererSink::RenderCallback* callback_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCompositor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BLINK_VIDEO_FRAME_COMPOSITOR_H_