Move Renderer permanent callbacks into RendererClient interface.

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 33 matching lines @@
 
 ACTION_P(RunClosure, closure) {
   closure.Run();
 }
 
 MATCHER_P(HasTimestamp, ms, "") {
   *result_listener << "has timestamp " << arg->timestamp().InMilliseconds();
   return arg->timestamp().InMilliseconds() == ms;
 }
 
-class VideoRendererImplTest
-    : public testing::Test {
+class VideoRendererImplTest : public testing::Test {
  public:
   VideoRendererImplTest()
       : tick_clock_(new base::SimpleTestTickClock()),
         decoder_(new NiceMock<MockVideoDecoder>()),
         demuxer_stream_(DemuxerStream::VIDEO) {
     ScopedVector<VideoDecoder> decoders;
     decoders.push_back(decoder_);
 
     null_video_sink_.reset(new NullVideoSink(
         false, base::TimeDelta::FromSecondsD(1.0 / 60),
@@ skipping 47 matching lines @@
   }
 
   void CallInitialize(const PipelineStatusCB& status_cb,
                       bool low_delay,
                       bool expect_success) {
     if (low_delay)
       demuxer_stream_.set_liveness(DemuxerStream::LIVENESS_LIVE);
     EXPECT_CALL(*decoder_, Initialize(_, _, _, _, _))
         .WillOnce(
             DoAll(SaveArg<4>(&output_cb_), RunCallback<3>(expect_success)));
-    EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
-    renderer_->Initialize(
-        &demuxer_stream_, status_cb, nullptr,
-        base::Bind(&VideoRendererImplTest::OnStatisticsUpdate,
-                   base::Unretained(this)),
-        base::Bind(&StrictMock<MockCB>::BufferingStateChange,
-                   base::Unretained(&mock_cb_)),
-        ended_event_.GetClosure(), error_event_.GetPipelineStatusCB(),
-        base::Bind(&WallClockTimeSource::GetWallClockTimes,
-                   base::Unretained(&time_source_)),
-        base::Bind(&VideoRendererImplTest::OnWaitingForDecryptionKey,
-                   base::Unretained(this)));
+    EXPECT_CALL(mock_cb_, OnWaitingForDecryptionKey()).Times(0);
+    renderer_->Initialize(&demuxer_stream_, nullptr, &mock_cb_,
+                          base::Bind(&WallClockTimeSource::GetWallClockTimes,
+                                     base::Unretained(&time_source_)),
+                          status_cb);
   }
 
   void StartPlayingFrom(int milliseconds) {
     SCOPED_TRACE(base::StringPrintf("StartPlayingFrom(%d)", milliseconds));
     const base::TimeDelta media_time =
         base::TimeDelta::FromMilliseconds(milliseconds);
     time_source_.SetMediaTime(media_time);
     renderer_->StartPlayingFrom(media_time);
     message_loop_.RunUntilIdle();
   }
@@ skipping 53 matching lines @@
       CHECK(false) << "Unrecognized decoder buffer token: " << token;
     }
   }
 
   bool IsReadPending() {
     return !decode_cb_.is_null();
   }
 
   void WaitForError(PipelineStatus expected) {
     SCOPED_TRACE(base::StringPrintf("WaitForError(%d)", expected));
-    error_event_.RunAndWaitForStatus(expected);
+
+    WaitableMessageLoopEvent event;
+    PipelineStatusCB error_cb = event.GetPipelineStatusCB();
+    EXPECT_CALL(mock_cb_, OnError(_))
+        .WillOnce(Invoke(&error_cb, &PipelineStatusCB::Run));
+    event.RunAndWaitForStatus(expected);
   }
 
   void WaitForEnded() {
     SCOPED_TRACE("WaitForEnded()");
-    ended_event_.RunAndWait();
+
+    WaitableMessageLoopEvent event;
+    EXPECT_CALL(mock_cb_, OnEnded()).WillOnce(RunClosure(event.GetClosure()));
+    event.RunAndWait();
   }
 
   void WaitForPendingRead() {
     SCOPED_TRACE("WaitForPendingRead()");
     if (!decode_cb_.is_null())
       return;
 
     DCHECK(wait_for_pending_decode_cb_.is_null());
 
     WaitableMessageLoopEvent event;
@@ skipping 46 matching lines @@
 
   void AdvanceTimeInMs(int time_ms) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     base::AutoLock l(lock_);
     time_ += base::TimeDelta::FromMilliseconds(time_ms);
     time_source_.StopTicking();
     time_source_.SetMediaTime(time_);
     time_source_.StartTicking();
   }
 
-  bool has_ended() const {
-    return ended_event_.is_signaled();
-  }
-
   enum class UnderflowTestType {
     NORMAL,
     LOW_DELAY,
     CANT_READ_WITHOUT_STALLING
   };
   void BasicUnderflowTest(UnderflowTestType type) {
     InitializeWithLowDelay(type == UnderflowTestType::LOW_DELAY);
     if (type == UnderflowTestType::CANT_READ_WITHOUT_STALLING)
       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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+      EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
+      EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
       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.
     {
       SCOPED_TRACE("Waiting for frame drops");
       WaitableMessageLoopEvent event;
 
       // Note: Starting the TimeSource will cause the old VideoRendererImpl to
       // start rendering frames on its own thread, so the first frame may be
       // received.
       time_source_.StartTicking();
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(30))).Times(0);
 
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(60))).Times(0);
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(90)))
           .WillOnce(RunClosure(event.GetClosure()));
+      EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
       AdvanceTimeInMs(91);
 
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     // Advance time more. Now we should signal having nothing. And put
     // the last frame up for display.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
       WaitableMessageLoopEvent event;
-      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+      EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
           .WillOnce(RunClosure(event.GetClosure()));
       AdvanceTimeInMs(30);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     // Simulate delayed buffering state callbacks.
     renderer_->OnTimeStateChanged(false);
     renderer_->OnTimeStateChanged(true);
 
     // Receiving end of stream should signal having enough.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
       WaitableMessageLoopEvent event;
-      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+      EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
+      EXPECT_CALL(mock_cb_, OnEnded());
       SatisfyPendingReadWithEndOfStream();
       event.RunAndWait();
     }
 
-    WaitForEnded();
     Destroy();
   }
 
   void UnderflowRecoveryTest(UnderflowTestType type) {
     InitializeWithLowDelay(type == UnderflowTestType::LOW_DELAY);
     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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+      EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
+      EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
       StartPlayingFrom(0);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     renderer_->OnTimeStateChanged(true);
     time_source_.StartTicking();
 
     // Advance time, this should cause have nothing to be signaled.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_NOTHING");
       WaitableMessageLoopEvent event;
-      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+      EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(20))).Times(1);
+      EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
       AdvanceTimeInMs(20);
       event.RunAndWait();
       Mock::VerifyAndClearExpectations(&mock_cb_);
     }
 
     AdvanceTimeInMs(59);
     EXPECT_EQ(3u, renderer_->frames_queued_for_testing());
     time_source_.StopTicking();
     renderer_->OnTimeStateChanged(false);
     EXPECT_EQ(0u, renderer_->frames_queued_for_testing());
     ASSERT_TRUE(IsReadPending());
 
     // Queue some frames, satisfy reads, and make sure expired frames are gone
     // when the renderer paints the first frame.
     {
       SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
       WaitableMessageLoopEvent event;
       EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(80))).Times(1);
-      EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+      EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       if (type == UnderflowTestType::NORMAL)
         QueueFrames("80 100 120 140 160");
       else
         QueueFrames("40 60 80");
       SatisfyPendingRead();
       event.RunAndWait();
     }
 
     Destroy();
   }
 
  protected:
   // Fixture members.
   std::unique_ptr<VideoRendererImpl> renderer_;
   base::SimpleTestTickClock* tick_clock_;  // Owned by |renderer_|.
   NiceMock<MockVideoDecoder>* decoder_;    // Owned by |renderer_|.
   NiceMock<MockDemuxerStream> demuxer_stream_;
 
   // Use StrictMock<T> to catch missing/extra callbacks.
-  class MockCB {
+  class MockCB : public MockRendererClient {
    public:
     MOCK_METHOD1(FrameReceived, void(const scoped_refptr<VideoFrame>&));
-    MOCK_METHOD1(BufferingStateChange, void(BufferingState));
   };
   StrictMock<MockCB> mock_cb_;
 
   // Must be destroyed before |renderer_| since they share |tick_clock_|.
   std::unique_ptr<NullVideoSink> null_video_sink_;
 
-  PipelineStatistics last_pipeline_statistics_;
-
   WallClockTimeSource time_source_;
 
   base::MessageLoop message_loop_;
 
  private:
   void DecodeRequested(const scoped_refptr<DecoderBuffer>& buffer,
                        const VideoDecoder::DecodeCB& decode_cb) {
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     CHECK(decode_cb_.is_null());
     decode_cb_ = decode_cb;
@@ skipping 12 matching lines @@
     DCHECK_EQ(&message_loop_, base::MessageLoop::current());
     decode_results_.clear();
     if (!decode_cb_.is_null()) {
       QueueFrames("abort");
       SatisfyPendingRead();
     }
 
     message_loop_.PostTask(FROM_HERE, callback);
   }
 
-  void OnStatisticsUpdate(const PipelineStatistics& stats) {
-    last_pipeline_statistics_ = stats;
-  }
-
-  MOCK_METHOD0(OnWaitingForDecryptionKey, void(void));
-
   // Used to protect |time_|.
   base::Lock lock_;
   base::TimeDelta time_;
 
   // Used for satisfying reads.
   VideoDecoder::OutputCB output_cb_;
   VideoDecoder::DecodeCB decode_cb_;
   base::TimeDelta next_frame_timestamp_;
 
-  WaitableMessageLoopEvent error_event_;
-  WaitableMessageLoopEvent ended_event_;
-
   // Run during DecodeRequested() to unblock WaitForPendingRead().
   base::Closure wait_for_pending_decode_cb_;
 
   std::deque<std::pair<DecodeStatus, scoped_refptr<VideoFrame>>>
       decode_results_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoRendererImplTest);
 };
 
 TEST_F(VideoRendererImplTest, DoNothing) {
   // Test that creation and deletion doesn't depend on calls to Initialize()
   // and/or Destroy().
 }
 
 TEST_F(VideoRendererImplTest, DestroyWithoutInitialize) {
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, Initialize) {
   Initialize();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, InitializeAndStartPlayingFrom) {
   Initialize();
   QueueFrames("0 10 20 30");
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   StartPlayingFrom(0);
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, InitializeAndEndOfStream) {
   Initialize();
   StartPlayingFrom(0);
   WaitForPendingRead();
   {
     SCOPED_TRACE("Waiting for BUFFERING_HAVE_ENOUGH");
     WaitableMessageLoopEvent event;
-    EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+    EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
         .WillOnce(RunClosure(event.GetClosure()));
+    EXPECT_CALL(mock_cb_, OnEnded());
     SatisfyPendingReadWithEndOfStream();
     event.RunAndWait();
   }
   // Firing a time state changed to true should be ignored...
   renderer_->OnTimeStateChanged(true);
   EXPECT_FALSE(null_video_sink_->is_started());
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, DestroyWhileInitializing) {
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   StartPlayingFrom(0);
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING));
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+  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());
 
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(AnyNumber());
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(AnyNumber());
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   StartPlayingFrom(0);
 
   // Check that there is an outstanding Read() request.
   EXPECT_TRUE(IsReadPending());
 
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, VideoDecoder_InitFailure) {
   InitializeRenderer(false, false);
@@ skipping 24 matching lines @@
   UnderflowRecoveryTest(UnderflowTestType::CANT_READ_WITHOUT_STALLING);
 }
 
 // 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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
+  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();
   }
 
-  EXPECT_FALSE(has_ended());
   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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
 
   {
     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());
     SatisfyPendingReadWithEndOfStream();
     WaitForEnded();
 
     renderer_->OnTimeStateChanged(false);
     event.RunAndWait();
   }
 
   Destroy();
 }
 
 // Tests the case where the video started and received a single Render() call,
 // then the video was put into the background.
 TEST_F(VideoRendererImplTest, RenderingStartedThenStopped) {
   Initialize();
   QueueFrames("0 30 60 90");
 
   // Start the sink and wait for the first callback.  Set statistics to a non
   // zero value, once we have some decoded frames they should be overwritten.
-  last_pipeline_statistics_.video_frames_dropped = 1;
+  PipelineStatistics last_pipeline_statistics;
+  last_pipeline_statistics.video_frames_dropped = 1;
   {
     WaitableMessageLoopEvent event;
-    EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+    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));
     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);
+    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,
   // BUFFER_HAVE_ENOUGH will be called again.
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(testing::AtMost(1));
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_NOTHING))
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(testing::AtMost(1));
   renderer_->OnTimeStateChanged(true);
   time_source_.StartTicking();
 
   // Suspend all future callbacks and synthetically advance the media time,
   // because this is a background render, we won't underflow by waiting until
   // a pending read is ready.
   null_video_sink_->set_background_render(true);
   AdvanceTimeInMs(91);
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(90)));
   WaitForPendingRead();
   SatisfyPendingReadWithEndOfStream();
 
   // If this wasn't background rendering mode, this would result in two frames
   // being dropped, but since we set background render to true, none should be
   // reported
-  EXPECT_EQ(0u, last_pipeline_statistics_.video_frames_dropped);
-  EXPECT_EQ(4u, last_pipeline_statistics_.video_frames_decoded);
-  EXPECT_EQ(460800, last_pipeline_statistics_.video_memory_usage);
+  EXPECT_EQ(0u, last_pipeline_statistics.video_frames_dropped);
+  EXPECT_EQ(4u, last_pipeline_statistics.video_frames_decoded);
+  EXPECT_EQ(460800, last_pipeline_statistics.video_memory_usage);
 
   AdvanceTimeInMs(30);
   WaitForEnded();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, StartPlayingFromThenFlushThenEOS) {
   Initialize();
   QueueFrames("0 30 60 90");
 
   WaitableMessageLoopEvent event;
   EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .WillOnce(RunClosure(event.GetClosure()));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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_, BufferingStateChange(BUFFERING_HAVE_NOTHING));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING));
   Flush();
 
   StartPlayingFrom(200);
   WaitForPendingRead();
   SatisfyPendingReadWithEndOfStream();
-  EXPECT_CALL(mock_cb_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
   WaitForEnded();
   Destroy();
 }
 
 TEST_F(VideoRendererImplTest, FramesAreNotExpiredDuringPreroll) {
   Initialize();
   // !CanReadWithoutStalling() puts the renderer in state BUFFERING_HAVE_ENOUGH
   // 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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH))
+  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());
   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);
@@ skipping 12 matching lines @@
   }
 
  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_, BufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH));
+  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_)).Times(AnyNumber());
   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