cc: Remove retro frames from scheduler.

cc/scheduler/begin_frame_source_unittest.cc

 // Copyright 2011 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 "cc/scheduler/begin_frame_source.h"
 
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/test/test_simple_task_runner.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/begin_frame_source_test.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Mock;
 using testing::StrictMock;
 
 namespace cc {
 namespace {
 
-// BeginFrameObserverBase testing ---------------------------------------
-class MockMinimalBeginFrameObserverBase : public BeginFrameObserverBase {
- public:
-  MOCK_METHOD1(OnBeginFrameDerivedImpl, bool(const BeginFrameArgs&));
-  MOCK_METHOD1(OnBeginFrameSourcePausedChanged, void(bool));
-  int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
-};
-
-TEST(BeginFrameObserverBaseTest, OnBeginFrameImplementation) {
-  using ::testing::Return;
-  MockMinimalBeginFrameObserverBase obs;
-  ::testing::InSequence ordered;  // These calls should be ordered
-
-  // Initial conditions
-  EXPECT_EQ(BeginFrameArgs(), obs.LastUsedBeginFrameArgs());
-  EXPECT_EQ(0, obs.dropped_begin_frame_args());
-
-#ifndef NDEBUG
-  EXPECT_DEATH({ obs.OnBeginFrame(BeginFrameArgs()); }, "");
-#endif
-
-  BeginFrameArgs args1 =
-      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300);
-  EXPECT_CALL(obs, OnBeginFrameDerivedImpl(args1)).WillOnce(Return(true));
-  obs.OnBeginFrame(args1);
-  EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
-  EXPECT_EQ(0, obs.dropped_begin_frame_args());
-
-#ifndef NDEBUG
-  EXPECT_DEATH({
-                 obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
-                     BEGINFRAME_FROM_HERE, 50, 200, 300));
-               },
-               "");
-#endif
-
-  // Returning false shouldn't update the LastUsedBeginFrameArgs value.
-  BeginFrameArgs args2 =
-      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 200, 300, 400);
-  EXPECT_CALL(obs, OnBeginFrameDerivedImpl(args2)).WillOnce(Return(false));
-  obs.OnBeginFrame(args2);
-  EXPECT_EQ(args1, obs.LastUsedBeginFrameArgs());
-  EXPECT_EQ(1, obs.dropped_begin_frame_args());
-
-  BeginFrameArgs args3 =
-      CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 150, 300, 400);
-  EXPECT_CALL(obs, OnBeginFrameDerivedImpl(args3)).WillOnce(Return(true));
-  obs.OnBeginFrame(args3);
-  EXPECT_EQ(args3, obs.LastUsedBeginFrameArgs());
-  EXPECT_EQ(1, obs.dropped_begin_frame_args());
-}
-
 // BeginFrameSource testing ----------------------------------------------
 TEST(BeginFrameSourceBaseTest, ObserverManipulation) {
   MockBeginFrameObserver obs;
   MockBeginFrameObserver otherObs;
   FakeBeginFrameSource source;
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
   source.AddObserver(&obs);
   EXPECT_TRUE(source.has_observers());
 
@@ skipping 81 matching lines @@
 
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);
   source.SetBeginFrameSourcePaused(false);
 
   EXPECT_BEGIN_FRAME_USED(obs2, 300, 400, 100);
   SEND_BEGIN_FRAME_USED(source, 300, 400, 100);
 
   source.RemoveObserver(&obs2);
 }
 
-class LoopingBeginFrameObserver : public BeginFrameObserverBase {
+class LoopingBeginFrameObserver : public BeginFrameObserver {
  public:
   BeginFrameSource* source_;
 
   void AsValueInto(base::trace_event::TracedValue* dict) const override {
     dict->SetString("type", "LoopingBeginFrameObserver");
     dict->BeginDictionary("source");
     source_->AsValueInto(dict);
     dict->EndDictionary();
   }
 
  protected:
-  // BeginFrameObserverBase
-  bool OnBeginFrameDerivedImpl(const BeginFrameArgs& args) override {
-    return true;
+  // BeginFrameObserver
+  const BeginFrameArgs& LastUsedBeginFrameArgs() const override {
+    return dummy_begin_frame_args_;
   }
+  void OnBeginFrame(const BeginFrameArgs& args) override {}
+  void OnBeginFrameSourcePausedChanged(bool paused) override {}
 
-  void OnBeginFrameSourcePausedChanged(bool paused) override {}
+ private:
+  BeginFrameArgs dummy_begin_frame_args_;
 };
 
 TEST(BeginFrameSourceBaseTest, DetectAsValueIntoLoop) {
   LoopingBeginFrameObserver obs;
   FakeBeginFrameSource source;
 
   obs.source_ = &source;
   source.AddObserver(&obs);
 
   std::unique_ptr<base::trace_event::TracedValue> state(
@@ skipping 47 matching lines @@
 
 TEST_F(BackToBackBeginFrameSourceTest, AddObserverSendsBeginFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        DidFinishFrameThenRemoveObserverProducesNoFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   source_->RemoveObserver(obs_.get());
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
 
   EXPECT_FALSE(task_runner_->HasPendingTasks());
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        RemoveObserverThenDidFinishFrameProducesNoFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
   source_->RemoveObserver(obs_.get());
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        TogglingObserverThenDidFinishFrameProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
   source_->RemoveObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest,
        DidFinishFrameThenTogglingObserverProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   source_->RemoveObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(10));
   EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   source_->RemoveObserver(obs_.get());
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
   EXPECT_FALSE(task_runner_->RunPendingTasks());
 }
 
-TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {
-  EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
-  source_->AddObserver(obs_.get());
-  EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
-  task_runner_->RunPendingTasks();
-
-  now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-
-  source_->DidFinishFrame(3);
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-  source_->DidFinishFrame(2);
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-  source_->DidFinishFrame(1);
-  EXPECT_FALSE(task_runner_->HasPendingTasks());
-
-  EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
-  source_->DidFinishFrame(0);
-  EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime());
-  task_runner_->RunPendingTasks();
-}
-
 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(0);
-  source_->DidFinishFrame(0);
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
+  source_->DidFinishFrame(obs_.get());
+  source_->DidFinishFrame(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(0);
-  source_->DidFinishFrame(0);
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
+  source_->DidFinishFrame(obs_.get());
+  source_->DidFinishFrame(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1200, 1200 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 }
 
 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) {
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);
   source_->AddObserver(obs_.get());
   EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
   task_runner_->RunPendingTasks();
 
   now_src_->Advance(base::TimeDelta::FromMicroseconds(100));
-  source_->DidFinishFrame(0);
+  source_->DidFinishFrame(obs_.get());
   now_src_->Advance(base::TimeDelta::FromMicroseconds(50));
   EXPECT_BEGIN_FRAME_USED(*obs_, 1150, 1150 + kDeadline, kInterval);
 
   EXPECT_TRUE(task_runner_->HasPendingTasks());
   task_runner_->RunPendingTasks();
 }
 
 // SyntheticBeginFrameSource testing ------------------------------------------
 class SyntheticBeginFrameSourceTest : public ::testing::Test {
  public:
@@ skipping 149 matching lines @@
                                    base::TimeDelta::FromInternalValue(10000));
   now_src_->Advance(base::TimeDelta::FromInternalValue(5000));
   EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);
   EXPECT_BEGIN_FRAME_USED_MISSED(obs, 10000, 20000, 10000);
   source_->AddObserver(&obs);
   source_->RemoveObserver(&obs);
 }
 
 }  // namespace
 }  // namespace cc