Update decoded frame counts when the sink isn't running.

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 335 matching lines @@
     }
 
     // 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_, OnStatisticsUpdate(_)).Times(AnyNumber());
       EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
           .WillOnce(RunClosure(event.GetClosure()));
       EXPECT_CALL(mock_cb_, OnEnded());
       SatisfyPendingDecodeWithEndOfStream();
       event.RunAndWait();
     }
 
     Destroy();
   }
 
@@ skipping 38 matching lines @@
     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_, OnStatisticsUpdate(_)).Times(AnyNumber());
       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 90");
       SatisfyPendingDecode();
       event.RunAndWait();
     }
 
@@ skipping 394 matching lines @@
   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.
   PipelineStatistics last_pipeline_statistics;
   last_pipeline_statistics.video_frames_dropped = 1;
   {
     WaitableMessageLoopEvent event;
     EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
         .WillOnce(RunClosure(event.GetClosure()));
+    EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_))
+        .Times(4)
+        .WillRepeatedly(SaveArg<0>(&last_pipeline_statistics));
     EXPECT_CALL(mock_cb_, FrameReceived(HasTimestamp(0)));
     EXPECT_CALL(mock_cb_, OnVideoNaturalSizeChange(_)).Times(1);
     EXPECT_CALL(mock_cb_, OnVideoOpacityChange(_)).Times(1);
     StartPlayingFrom(0);
     event.RunAndWait();
     Mock::VerifyAndClearExpectations(&mock_cb_);
   }
 
+  // Four calls to update statistics should have been made, each reporting a
+  // single decoded frame and one frame worth of memory usage. No dropped frames
+  // should be reported later since we're in background rendering mode. These
+  // calls must all have occurred before playback starts.
+  EXPECT_EQ(0u, last_pipeline_statistics.video_frames_dropped);
+  EXPECT_EQ(1u, last_pipeline_statistics.video_frames_decoded);
+  EXPECT_EQ(115200, 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 SatisfyPendingDecodeWithEndOfStream,
   // BUFFER_HAVE_ENOUGH will be called again.
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_ENOUGH))
       .Times(testing::AtMost(1));
   EXPECT_CALL(mock_cb_, OnBufferingStateChange(BUFFERING_HAVE_NOTHING))
       .Times(testing::AtMost(1));
-  EXPECT_CALL(mock_cb_, OnStatisticsUpdate(_))
-      .WillRepeatedly(SaveArg<0>(&last_pipeline_statistics));
   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)));
   WaitForPendingDecode();
   SatisfyPendingDecodeWithEndOfStream();
 
-  // 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(115200, last_pipeline_statistics.video_memory_usage);
-
   AdvanceTimeInMs(30);
   WaitForEnded();
   Destroy();
 }
 
 // Tests the case where underflow evicts all frames before EOS.
 TEST_F(VideoRendererImplTest, UnderflowEvictionBeforeEOS) {
   Initialize();
   QueueFrames("0 30 60 90 100");
 
@@ skipping 262 matching lines @@
   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