Moves video frame callbacks from VideoFrameCompositor to Renderer.

media/renderers/video_renderer_impl_unittest.cc

 // Copyright 2013 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 <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 147 matching lines @@
   //
   // Examples:
   //   A clip that is four frames long: "0 10 20 30"
   //   A clip that has a decode error: "60 70 error"
   void QueueFrames(const std::string& str) {
     for (const std::string& token :
          base::SplitString(str, " ", base::TRIM_WHITESPACE,
                            base::SPLIT_WANT_ALL)) {
       if (token == "abort") {
         scoped_refptr<VideoFrame> null_frame;
-        decode_results_.push_back(
-            std::make_pair(DecodeStatus::ABORTED, null_frame));
+        QueueFrame(DecodeStatus::ABORTED, null_frame);
         continue;
       }
 
       if (token == "error") {
         scoped_refptr<VideoFrame> null_frame;
-        decode_results_.push_back(
-            std::make_pair(DecodeStatus::DECODE_ERROR, null_frame));
+        QueueFrame(DecodeStatus::DECODE_ERROR, null_frame);
         continue;
       }
 
       int timestamp_in_ms = 0;
       if (base::StringToInt(token, &timestamp_in_ms)) {
         gfx::Size natural_size = TestVideoConfig::NormalCodedSize();
         scoped_refptr<VideoFrame> frame = VideoFrame::CreateFrame(
             PIXEL_FORMAT_YV12, natural_size, gfx::Rect(natural_size),
             natural_size, base::TimeDelta::FromMilliseconds(timestamp_in_ms));
-        decode_results_.push_back(std::make_pair(DecodeStatus::OK, frame));
+        QueueFrame(DecodeStatus::OK, frame);
         continue;
       }
 
       CHECK(false) << "Unrecognized decoder buffer token: " << token;
     }
   }
 
+  // Queues video frames to be served by the decoder during rendering.
+  void QueueFrame(DecodeStatus status, scoped_refptr<VideoFrame> frame) {
+    decode_results_.push_back(std::make_pair(status, frame));
+  }
+
   bool IsReadPending() {
     return !decode_cb_.is_null();
   }
 
   void WaitForError(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("WaitForError(%d)", expected));
 
     WaitableMessageLoopEvent event;
     PipelineStatusCB error_cb = event.GetPipelineStatusCB();
     EXPECT_CALL(mock_cb_, OnError(_))
@@ skipping 84 matching lines @@
       ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
 
     QueueFrames("0 30 60 90");
 
     {
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+      EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+      EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
       StartPlayingFrom(0);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     renderer_->OnTimeStateChanged(true);
 
     // Advance time slightly, but enough to exceed the duration of the last
     // frame.
     // Frames should be dropped and we should NOT signal having nothing.
@@ skipping 52 matching lines @@
     if (type == UnderflowTestType::CANT_READ_WITHOUT_STALLING)
       ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
 
     QueueFrames("0 20 40 60");
     {
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+      EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+      EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
       StartPlayingFrom(0);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     renderer_->OnTimeStateChanged(true);
     time_source_.StartTicking();
 
     // Advance time, this should cause have nothing to be signaled.
     {
@@ skipping 114 matching lines @@
   Initialize();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, InitializeAndStartPlayingFrom) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, InitializeAndEndOfStream) {
   Initialize();
   StartPlayingFrom(0);
   WaitForPendingRead();
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
@@ skipping 14 matching lines @@
   CallInitialize(NewExpectedStatusCB(PIPELINE_ERROR_ABORT), false, PIPELINE_OK);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileFlushing) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   renderer_->Flush(NewExpectedClosure());
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, Play) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, FlushWithNothingBuffered) {
   Initialize();
   StartPlayingFrom(0);
 
   // We shouldn't expect a buffering state change since we never reached
   // BUFFERING_HAVE_ENOUGH.
   Flush();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DecodeError_Playing) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(_)).Times(testing::AtLeast(1));
 
   // Consider the case that rendering is faster than we setup the test event.
   // In that case, when we run out of the frames, BUFFERING_HAVE_NOTHING will
   // be called.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(testing::AtMost(1));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
 
   StartPlayingFrom(0);
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
   AdvanceTimeInMs(10);
 
   QueueFrames("error");
   SatisfyPendingRead();
   WaitForError(PIPELINE_ERROR_DECODE);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DecodeError_DuringStartPlayingFrom) {
   Initialize();
   QueueFrames("error");
   EXPECT_CALL(mock_cb_, OnError(PIPELINE_ERROR_DECODE));
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_Exact) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(60);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_RightBefore) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(50)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(59);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_RightAfter) {
   Initialize();
   QueueFrames("50 60 70 80 90");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(61);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFrom_LowDelay) {
   // In low-delay mode only one frame is required to finish preroll. But frames
   // prior to the start time will not be used.
   InitializeWithLowDelay(true);
   QueueFrames("0 10");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)));
   // Expect some amount of have enough/nothing due to only requiring one frame.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(AnyNumber());
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(10);
 
   QueueFrames("20");
   SatisfyPendingRead();
 
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
 
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20)))
       .WillOnce(RunClosure(event.GetClosure()));
   AdvanceTimeInMs(20);
   event.RunAndWait();
 
   Destroy();
 }
 
 // Verify that a late decoder response doesn't break invariants in the renderer.
 TEST_F(VideoRendererImplTest, DestroyDuringOutstandingRead) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
 
   // Check that there is an outstanding Read() request.
   EXPECT_TRUE(IsReadPending());
 
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, VideoDecoder_InitFailure) {
   InitializeRenderer(false, false);
@@ skipping 26 matching lines @@
 
 // Verifies that the sink is stopped after rendering the first frame if
 // playback hasn't started.
 TEST_F(VideoRendererImplTest, RenderingStopsAfterFirstFrame) {
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   EXPECT_CALL(mock_cb_, OnEnded()).Times(0);
 
   {
     SCOPED_TRACE("Waiting for sink to stop.");
     WaitableMessageLoopEvent event;
 
     null_video_sink_->set_background_render(true);
     null_video_sink_->set_stop_cb(event.GetClosure());
     StartPlayingFrom(0);
 
     EXPECT_TRUE(IsReadPending());
     SatisfyPendingReadWithEndOfStream();
 
     event.RunAndWait();
   }
 
   Destroy();
 }
 
 // Verifies that the sink is stopped after rendering the first frame if
 // playback ha started.
 TEST_F(VideoRendererImplTest, RenderingStopsAfterOneFrameWithEOS) {
   InitializeWithLowDelay(true);
   QueueFrames("0");
 
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
 
   {
     SCOPED_TRACE("Waiting for sink to stop.");
     WaitableMessageLoopEvent event;
 
     null_video_sink_->set_stop_cb(event.GetClosure());
     StartPlayingFrom(0);
     renderer_->OnTimeStateChanged(true);
 
     EXPECT_TRUE(IsReadPending());
@@ skipping 17 matching lines @@
   // zero value, once we have some decoded frames they should be overwritten.
   PipelineStatistics last_pipeline_statistics;
   last_pipeline_statistics.video_frames_dropped = 1;
   {
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)))
         .WillOnce(RunClosure(event.GetClosure()));
     EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_))
         .WillRepeatedly(SaveArg<0>(&last_pipeline_statistics));
+    EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+    EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
     StartPlayingFrom(0);
     event.RunAndWait();
     Mock::VerifyAndClearExpectations(&mock_cb_);
     EXPECT_EQ(0u, last_pipeline_statistics.video_frames_dropped);
     EXPECT_EQ(460800, last_pipeline_statistics.video_memory_usage);
   }
 
   // Consider the case that rendering is faster than we setup the test event.
   // In that case, when we run out of the frames, BUFFERING_HAVE_NOTHING will
   // be called. And then during SatisfyPendingReadWithEndOfStream,
@@ skipping 28 matching lines @@
 
 TEST_F(VideoRendererImplTest, StartPlayingFromThenFlushThenEOS) {
   Initialize();
   QueueFrames("0 30 60 90");
 
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .WillOnce(RunClosure(event.GetClosure()));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   event.RunAndWait();
 
   // Cycle ticking so that we get a non-null reference time.
   time_source_.StartTicking();
   time_source_.StopTicking();
 
   // Flush and simulate a seek past EOS, where some error prevents the decoder
   // from returning any frames.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
@@ skipping 13 matching lines @@
   // after the first frame.
   ON_CALL(*decoder_, CanReadWithoutStalling()).WillByDefault(Return(false));
   // Set background rendering to simulate the first couple of Render() calls
   // by VFC.
   null_video_sink_->set_background_render(true);
   QueueFrames("0 10 20");
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(testing::AtMost(1));
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
 
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
 
   WaitableMessageLoopEvent event;
   // Frame "10" should not have been expired.
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)))
       .WillOnce(RunClosure(event.GetClosure()));
   AdvanceTimeInMs(10);
   event.RunAndWait();
 
   Destroy();
 }
 
+TEST_F(VideoRendererImplTest, NaturalSizeChange) {
+  Initialize();
+
+  gfx::Size initial_size(8, 8);
+  gfx::Size larger_size(16, 16);
+
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(PIXEL_FORMAT_YV12, initial_size,
+                                     gfx::Rect(initial_size), initial_size,
+                                     base::TimeDelta::FromMilliseconds(0)));
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(PIXEL_FORMAT_YV12, larger_size,
+                                     gfx::Rect(larger_size), larger_size,
+                                     base::TimeDelta::FromMilliseconds(10)));
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(PIXEL_FORMAT_YV12, larger_size,
+                                     gfx::Rect(larger_size), larger_size,
+                                     base::TimeDelta::FromMilliseconds(20)));
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(PIXEL_FORMAT_YV12, initial_size,
+                                     gfx::Rect(initial_size), initial_size,
+                                     base::TimeDelta::FromMilliseconds(30)));
+
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
+
+  {
+    // Callback is fired for the first frame.
+    EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(initial_size));
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
+    StartPlayingFrom(0);
+    renderer_->OnTimeStateChanged(true);
+    time_source_.StartTicking();
+  }
+  {
+    // Callback should be fired once when switching to the larger size.
+    EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(larger_size));
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)))
+        .WillOnce(RunClosure(event.GetClosure()));
+    AdvanceTimeInMs(10);
+    event.RunAndWait();
+  }
+  {
+    // Called is not fired because frame size does not change.
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20)))
+        .WillOnce(RunClosure(event.GetClosure()));
+    AdvanceTimeInMs(10);
+    event.RunAndWait();
+  }
+  {
+    // Callback is fired once when switching to the larger size.
+    EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(initial_size));
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30)))
+        .WillOnce(RunClosure(event.GetClosure()));
+    AdvanceTimeInMs(10);
+    event.RunAndWait();
+  }
+
+  Destroy();
+}
+
+TEST_F(VideoRendererImplTest, OpacityChange) {
+  Initialize();
+
+  gfx::Size frame_size(8, 8);
+  VideoPixelFormat opaque_format = PIXEL_FORMAT_YV12;
+  VideoPixelFormat non_opaque_format = PIXEL_FORMAT_YV12A;
+
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(non_opaque_format, frame_size,
+                                     gfx::Rect(frame_size), frame_size,
+                                     base::TimeDelta::FromMilliseconds(0)));
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(non_opaque_format, frame_size,
+                                     gfx::Rect(frame_size), frame_size,
+                                     base::TimeDelta::FromMilliseconds(10)));
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(opaque_format, frame_size,
+                                     gfx::Rect(frame_size), frame_size,
+                                     base::TimeDelta::FromMilliseconds(20)));
+  QueueFrame(DecodeStatus::OK,
+             VideoFrame::CreateFrame(opaque_format, frame_size,
+                                     gfx::Rect(frame_size), frame_size,
+                                     base::TimeDelta::FromMilliseconds(30)));
+
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(frame_size)).Times(1);
+
+  {
+    // Callback is fired for the first frame.
+    EXPECT_CALL(mock_cb_, OnVideoOpacityChange(false));
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
+    StartPlayingFrom(0);
+    renderer_->OnTimeStateChanged(true);
+    time_source_.StartTicking();
+  }
+  {
+    // Callback is not fired because opacity does not change.
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(10)))
+        .WillOnce(RunClosure(event.GetClosure()));
+    AdvanceTimeInMs(10);
+    event.RunAndWait();
+  }
+  {
+    // Called is fired when opacity changes.
+    EXPECT_CALL(mock_cb_, OnVideoOpacityChange(true));
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20)))
+        .WillOnce(RunClosure(event.GetClosure()));
+    AdvanceTimeInMs(10);
+    event.RunAndWait();
+  }
+  {
+    // Callback is not fired because opacity does not change.
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30)))
+        .WillOnce(RunClosure(event.GetClosure()));
+    AdvanceTimeInMs(10);
+    event.RunAndWait();
+  }
+
+  Destroy();
+}
+
 class VideoRendererImplAsyncAddFrameReadyTest : public VideoRendererImplTest {
  public:
   VideoRendererImplAsyncAddFrameReadyTest() {
     std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool(
         new MockGpuMemoryBufferVideoFramePool(&frame_ready_cbs_));
     renderer_->SetGpuMemoryBufferVideoForTesting(
         std::move(gpu_memory_buffer_pool));
   }
 
  protected:
   std::vector<base::Closure> frame_ready_cbs_;
 };
 
 TEST_F(VideoRendererImplAsyncAddFrameReadyTest, InitializeAndStartPlayingFrom) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
+  EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
   StartPlayingFrom(0);
   ASSERT_EQ(1u, frame_ready_cbs_.size());
 
   uint32_t frame_ready_index = 0;
   while (frame_ready_index < frame_ready_cbs_.size()) {
     frame_ready_cbs_[frame_ready_index++].Run();
     message_loop_.RunUntilIdle();
   }
   Destroy();
 }
 
 TEST_F(VideoRendererImplAsyncAddFrameReadyTest, SequenceTokenDiscardOneFrame) {
   Initialize();
   QueueFrames("0 10 20 30");
   StartPlayingFrom(0);
   Flush();
   ASSERT_EQ(1u, frame_ready_cbs_.size());
   // This frame will be discarded.
   frame_ready_cbs_.front().Run();
   Destroy();
 }
 
 }  // namespace media