Remove requirement of compositing a video frame for dropped frame count.

content/renderer/media/video_frame_compositor_unittest.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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/layers/video_frame_provider.h"
 #include "content/renderer/media/video_frame_compositor.h"
 #include "media/base/video_frame.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 48 matching lines @@
   int did_receive_frame_count_;
   int natural_size_changed_count_;
   gfx::Size natural_size_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameCompositorTest);
 };
 
 TEST_F(VideoFrameCompositorTest, InitialValues) {
   EXPECT_TRUE(compositor()->GetVideoFrameProvider());
   EXPECT_FALSE(compositor()->GetCurrentFrame());
-  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeComposite());
+  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeCompositorWasNotified());
 }
 
 TEST_F(VideoFrameCompositorTest, UpdateCurrentFrame) {
   scoped_refptr<VideoFrame> expected = VideoFrame::CreateEOSFrame();
 
   compositor()->UpdateCurrentFrame(expected);
   scoped_refptr<VideoFrame> actual = compositor()->GetCurrentFrame();
   EXPECT_EQ(expected, actual);
 
   // Should notify compositor asynchronously.
@@ skipping 38 matching lines @@
   EXPECT_EQ(initial_size.width(), natural_size().width());
   EXPECT_EQ(initial_size.height(), natural_size().height());
   EXPECT_EQ(2, natural_size_changed_count());
 
   compositor()->UpdateCurrentFrame(initial_frame);
   EXPECT_EQ(initial_size.width(), natural_size().width());
   EXPECT_EQ(initial_size, natural_size());
   EXPECT_EQ(2, natural_size_changed_count());
 }
 
-TEST_F(VideoFrameCompositorTest, GetFramesDroppedBeforeComposite) {
+TEST_F(VideoFrameCompositorTest, GetFramesDroppedBeforeCompositorWasNotified) {
   scoped_refptr<VideoFrame> frame = VideoFrame::CreateEOSFrame();
 
   compositor()->UpdateCurrentFrame(frame);
   EXPECT_EQ(0, did_receive_frame_count());
-  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeComposite());
+  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeCompositorWasNotified());
 
-  // Should not increment if we finished notifying the compositor but didn't
-  // composite the frame.
+  // Should not increment if we finished notifying the compositor.
   //
-  // This covers the scenario where the region we're rendering isn't
-  // visible so there wasn't a need to composite.
+  // This covers the normal scenario where the compositor is getting
+  // notifications in a timely manner.
   message_loop()->RunUntilIdle();
   compositor()->UpdateCurrentFrame(frame);
   EXPECT_EQ(1, did_receive_frame_count());
-  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeComposite());
+  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeCompositorWasNotified());
 
-  // Should not increment if we didn't finish notifying the compositor but still
-  // managed to composite the frame.
+  // Should increment if we didn't notify the compositor.
   //
-  // This covers the scenario where something else may have notified the
-  // compositor and managed to composite the current frame.
-  message_loop()->RunUntilIdle();
-  provider()->GetCurrentFrame();
-  provider()->PutCurrentFrame(NULL);
-  compositor()->UpdateCurrentFrame(frame);
-  EXPECT_EQ(2, did_receive_frame_count());
-  EXPECT_EQ(0u, compositor()->GetFramesDroppedBeforeComposite());
-
-  // Should increment if we didn't notify the compositor and didn't composite
-  // the frame.
-  //
-  // This covers the scenario where we didn't even finish notifying nor
-  // compositing the current frame before updating. Consider it dropped.
+  // This covers the scenario where the compositor is falling behind.
+  // Consider it dropped.
   message_loop()->RunUntilIdle();
   compositor()->UpdateCurrentFrame(frame);
   compositor()->UpdateCurrentFrame(frame);
-  EXPECT_EQ(3, did_receive_frame_count());
-  EXPECT_EQ(1u, compositor()->GetFramesDroppedBeforeComposite());
+  EXPECT_EQ(2, did_receive_frame_count());
+  EXPECT_EQ(1u, compositor()->GetFramesDroppedBeforeCompositorWasNotified());
 
   // Shouldn't overflow.
-  compositor()->SetFramesDroppedBeforeCompositeForTesting(kuint32max);
+  compositor()->SetFramesDroppedBeforeCompositorWasNotifiedForTesting(
+      kuint32max);
   compositor()->UpdateCurrentFrame(frame);
-  EXPECT_EQ(kuint32max, compositor()->GetFramesDroppedBeforeComposite());
+  EXPECT_EQ(kuint32max,
+            compositor()->GetFramesDroppedBeforeCompositorWasNotified());
 }
 
 }  // namespace content