Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1399)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/scheduler/begin_frame_source_unittest.cc

Issue 1533773002: Delete CC. (Closed) Base URL: git@github.com:domokit/mojo.git@cl-2e
Patch Set: rebase Created 5 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « cc/scheduler/begin_frame_source.cc ('k') | cc/scheduler/commit_earlyout_reason.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/scheduler/begin_frame_source_unittest.cc
diff --git a/cc/scheduler/begin_frame_source_unittest.cc b/cc/scheduler/begin_frame_source_unittest.cc
deleted file mode 100644
index 22126bead4504af443d585740c491a68710833a9..0000000000000000000000000000000000000000
--- a/cc/scheduler/begin_frame_source_unittest.cc
+++ /dev/null
@@ -1,775 +0,0 @@
-// 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 <deque>
-#include <string>
-
-#include "base/basictypes.h"
-#include "base/gtest_prod_util.h"
-#include "base/test/test_simple_task_runner.h"
-#include "cc/scheduler/begin_frame_source.h"
-#include "cc/test/begin_frame_args_test.h"
-#include "cc/test/scheduler_test_common.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-// Macros to help set up expected calls on the MockBeginFrameObserver.
-#define EXPECT_BEGIN_FRAME_DROP(obs, frame_time, deadline, interval) \
- { \
- ::testing::Expectation exp = \
- EXPECT_CALL((obs), OnBeginFrame(CreateBeginFrameArgsForTesting( \
- BEGINFRAME_FROM_HERE, frame_time, deadline, \
- interval))).InSequence((obs).sequence); \
- }
-
-#define EXPECT_BEGIN_FRAME_USED(obs, frame_time, deadline, interval) \
- { \
- BeginFrameArgs args = CreateBeginFrameArgsForTesting( \
- BEGINFRAME_FROM_HERE, frame_time, deadline, interval); \
- ::testing::Expectation exp = \
- EXPECT_CALL((obs), OnBeginFrame(args)).InSequence((obs).sequence); \
- EXPECT_CALL((obs), LastUsedBeginFrameArgs()) \
- .Times(::testing::AnyNumber()) \
- .After(exp) \
- .WillRepeatedly(::testing::Return(args)); \
- }
-
-// Macros to send BeginFrameArgs on a FakeBeginFrameSink (and verify resulting
-// observer behaviour).
-#define SEND_BEGIN_FRAME(args_equal_to, source, frame_time, deadline, \
- interval) \
- { \
- BeginFrameArgs old_args = (source).TestLastUsedBeginFrameArgs(); \
- BeginFrameArgs new_args = CreateBeginFrameArgsForTesting( \
- BEGINFRAME_FROM_HERE, frame_time, deadline, interval); \
- ASSERT_FALSE(old_args == new_args); \
- (source).TestOnBeginFrame(new_args); \
- EXPECT_EQ(args_equal_to, (source).TestLastUsedBeginFrameArgs()); \
- }
-
-// When dropping LastUsedBeginFrameArgs **shouldn't** change.
-#define SEND_BEGIN_FRAME_DROP(source, frame_time, deadline, interval) \
- SEND_BEGIN_FRAME(old_args, source, frame_time, deadline, interval);
-
-// When used LastUsedBeginFrameArgs **should** be updated.
-#define SEND_BEGIN_FRAME_USED(source, frame_time, deadline, interval) \
- SEND_BEGIN_FRAME(new_args, source, frame_time, deadline, interval);
-
-namespace cc {
-namespace {
-
-class MockBeginFrameObserver : public BeginFrameObserver {
- public:
- MOCK_METHOD1(OnBeginFrame, void(const BeginFrameArgs&));
- MOCK_CONST_METHOD0(LastUsedBeginFrameArgs, const BeginFrameArgs());
-
- virtual void AsValueInto(base::trace_event::TracedValue* dict) const {
- dict->SetString("type", "MockBeginFrameObserver");
- dict->BeginDictionary("last_begin_frame_args");
- LastUsedBeginFrameArgs().AsValueInto(dict);
- dict->EndDictionary();
- }
-
- // A value different from the normal default returned by a BeginFrameObserver
- // so it is easiable traced back here.
- static const BeginFrameArgs kDefaultBeginFrameArgs;
-
- MockBeginFrameObserver() {
- // Set a "default" value returned by LastUsedBeginFrameArgs so that gMock
- // doesn't fail an assert and instead returns useful information.
- EXPECT_CALL(*this, LastUsedBeginFrameArgs())
- .Times(::testing::AnyNumber())
- .InSequence(sequence)
- .WillRepeatedly(::testing::Return(kDefaultBeginFrameArgs));
- }
- virtual ~MockBeginFrameObserver() {}
-
- ::testing::Sequence sequence;
-};
-
-TEST(MockBeginFrameObserverTest, ExpectOnBeginFrame) {
- ::testing::NiceMock<MockBeginFrameObserver> obs;
- EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
-
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- MockBeginFrameObserver::kDefaultBeginFrameArgs);
-
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
- BEGINFRAME_FROM_HERE, 100, 200,
- 300)); // One call to LastUsedBeginFrameArgs
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
-
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
- BEGINFRAME_FROM_HERE, 400, 600,
- 300)); // Multiple calls to LastUsedBeginFrameArgs
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
-
- obs.OnBeginFrame(CreateBeginFrameArgsForTesting(
- BEGINFRAME_FROM_HERE, 700, 900,
- 300)); // No calls to LastUsedBeginFrameArgs
-}
-
-TEST(MockBeginFrameObserverTest, ExpectOnBeginFrameStatus) {
- ::testing::NiceMock<MockBeginFrameObserver> obs;
- EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
- EXPECT_BEGIN_FRAME_DROP(obs, 400, 600, 300);
- EXPECT_BEGIN_FRAME_DROP(obs, 450, 650, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
-
- EXPECT_EQ(obs.LastUsedBeginFrameArgs(),
- MockBeginFrameObserver::kDefaultBeginFrameArgs);
-
- // Used
- obs.OnBeginFrame(
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
-
- // Dropped
- obs.OnBeginFrame(
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 400, 600, 300));
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
-
- // Dropped
- obs.OnBeginFrame(
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 450, 650, 300));
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 100, 200, 300));
-
- // Used
- obs.OnBeginFrame(
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 900, 300));
- EXPECT_EQ(
- obs.LastUsedBeginFrameArgs(),
- CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 700, 900, 300));
-}
-
-const BeginFrameArgs MockBeginFrameObserver::kDefaultBeginFrameArgs =
- CreateBeginFrameArgsForTesting(
-#ifdef NDEBUG
- nullptr,
-#else
- FROM_HERE_WITH_EXPLICIT_FUNCTION(
- "MockBeginFrameObserver::kDefaultBeginFrameArgs"),
-#endif
- -1,
- -1,
- -1);
-
-// BeginFrameObserverMixIn testing ---------------------------------------
-class MockMinimalBeginFrameObserverMixIn : public BeginFrameObserverMixIn {
- public:
- MOCK_METHOD1(OnBeginFrameMixInDelegate, bool(const BeginFrameArgs&));
- int64_t dropped_begin_frame_args() const { return dropped_begin_frame_args_; }
-};
-
-TEST(BeginFrameObserverMixInTest, OnBeginFrameImplementation) {
- using ::testing::Return;
- MockMinimalBeginFrameObserverMixIn 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, OnBeginFrameMixInDelegate(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, OnBeginFrameMixInDelegate(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, OnBeginFrameMixInDelegate(args3)).WillOnce(Return(true));
- obs.OnBeginFrame(args3);
- EXPECT_EQ(args3, obs.LastUsedBeginFrameArgs());
- EXPECT_EQ(1, obs.dropped_begin_frame_args());
-}
-
-// BeginFrameSource testing ----------------------------------------------
-TEST(BeginFrameSourceMixInTest, ObserverManipulation) {
- MockBeginFrameObserver obs;
- MockBeginFrameObserver otherObs;
- FakeBeginFrameSource source;
-
- source.AddObserver(&obs);
- EXPECT_EQ(&obs, source.GetObserver());
-
-#ifndef NDEBUG
- // Adding an observer when an observer already exists should DCHECK fail.
- EXPECT_DEATH({ source.AddObserver(&otherObs); }, "");
-
- // Removing wrong observer should DCHECK fail.
- EXPECT_DEATH({ source.RemoveObserver(&otherObs); }, "");
-
- // Removing an observer when there is no observer should DCHECK fail.
- EXPECT_DEATH({
- source.RemoveObserver(&obs);
- source.RemoveObserver(&obs);
- },
- "");
-#endif
- source.RemoveObserver(&obs);
-
- source.AddObserver(&otherObs);
- EXPECT_EQ(&otherObs, source.GetObserver());
- source.RemoveObserver(&otherObs);
-}
-
-TEST(BeginFrameSourceMixInTest, Observer) {
- FakeBeginFrameSource source;
- MockBeginFrameObserver obs;
- source.AddObserver(&obs);
- EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
- EXPECT_BEGIN_FRAME_DROP(obs, 400, 600, 300);
- EXPECT_BEGIN_FRAME_DROP(obs, 450, 650, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
-
- SEND_BEGIN_FRAME_USED(source, 100, 200, 300);
- SEND_BEGIN_FRAME_DROP(source, 400, 600, 300);
- SEND_BEGIN_FRAME_DROP(source, 450, 650, 300);
- SEND_BEGIN_FRAME_USED(source, 700, 900, 300);
-}
-
-TEST(BeginFrameSourceMixInTest, NoObserver) {
- FakeBeginFrameSource source;
- SEND_BEGIN_FRAME_DROP(source, 100, 200, 300);
-}
-
-TEST(BeginFrameSourceMixInTest, NeedsBeginFrames) {
- FakeBeginFrameSource source;
- EXPECT_FALSE(source.NeedsBeginFrames());
- source.SetNeedsBeginFrames(true);
- EXPECT_TRUE(source.NeedsBeginFrames());
- source.SetNeedsBeginFrames(false);
- EXPECT_FALSE(source.NeedsBeginFrames());
-}
-
-class LoopingBeginFrameObserver : public BeginFrameObserverMixIn {
- 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:
- // BeginFrameObserverMixIn
- bool OnBeginFrameMixInDelegate(const BeginFrameArgs& args) override {
- return true;
- }
-};
-
-TEST(BeginFrameSourceMixInTest, DetectAsValueIntoLoop) {
- LoopingBeginFrameObserver obs;
- FakeBeginFrameSource source;
-
- obs.source_ = &source;
- source.AddObserver(&obs);
-
- scoped_refptr<base::trace_event::TracedValue> state =
- new base::trace_event::TracedValue();
- source.AsValueInto(state.get());
-}
-
-// BackToBackBeginFrameSource testing -----------------------------------------
-class TestBackToBackBeginFrameSource : public BackToBackBeginFrameSource {
- public:
- static scoped_ptr<TestBackToBackBeginFrameSource> Create(
- scoped_refptr<TestNowSource> now_src,
- base::SingleThreadTaskRunner* task_runner) {
- return make_scoped_ptr(
- new TestBackToBackBeginFrameSource(now_src, task_runner));
- }
-
- protected:
- TestBackToBackBeginFrameSource(scoped_refptr<TestNowSource> now_src,
- base::SingleThreadTaskRunner* task_runner)
- : BackToBackBeginFrameSource(task_runner), now_src_(now_src) {}
-
- base::TimeTicks Now() override { return now_src_->Now(); }
-
- scoped_refptr<TestNowSource> now_src_;
-};
-
-class BackToBackBeginFrameSourceTest : public ::testing::Test {
- public:
- static const int64_t kDeadline;
- static const int64_t kInterval;
-
- scoped_refptr<TestNowSource> now_src_;
- scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
- scoped_ptr<TestBackToBackBeginFrameSource> source_;
- scoped_ptr<MockBeginFrameObserver> obs_;
-
- void SetUp() override {
- now_src_ = TestNowSource::Create(1000);
- task_runner_ =
- make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
- task_runner_->SetRunTaskLimit(1);
- source_ =
- TestBackToBackBeginFrameSource::Create(now_src_, task_runner_.get());
- obs_ = make_scoped_ptr(new ::testing::StrictMock<MockBeginFrameObserver>());
- source_->AddObserver(obs_.get());
- }
-
- void TearDown() override { obs_.reset(); }
-};
-
-const int64_t BackToBackBeginFrameSourceTest::kDeadline =
- BeginFrameArgs::DefaultInterval().ToInternalValue();
-
-const int64_t BackToBackBeginFrameSourceTest::kInterval =
- BeginFrameArgs::DefaultInterval().ToInternalValue();
-
-TEST_F(BackToBackBeginFrameSourceTest, SetNeedsBeginFramesSendsBeginFrame) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- EXPECT_TRUE(task_runner_->HasPendingTasks());
- task_runner_->RunUntilIdle();
-
- EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
- now_src_->AdvanceNowMicroseconds(100);
- source_->DidFinishFrame(0);
- task_runner_->RunUntilIdle();
-}
-
-TEST_F(BackToBackBeginFrameSourceTest,
- DidFinishFrameThenSetNeedsBeginFramesProducesNoFrame) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- task_runner_->RunUntilIdle();
-
- source_->SetNeedsBeginFrames(false);
- source_->DidFinishFrame(0);
-
- EXPECT_FALSE(task_runner_->HasPendingTasks());
-}
-
-TEST_F(BackToBackBeginFrameSourceTest,
- SetNeedsBeginFramesThenDidFinishFrameProducesNoFrame) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(100);
- source_->DidFinishFrame(0);
- source_->SetNeedsBeginFrames(false);
-
- EXPECT_TRUE(task_runner_->HasPendingTasks());
- task_runner_->RunUntilIdle();
-}
-
-TEST_F(BackToBackBeginFrameSourceTest,
- DidFinishFrameThenTogglingSetNeedsBeginFramesProducesCorrectFrame) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(100);
-
- source_->SetNeedsBeginFrames(false);
- now_src_->AdvanceNowMicroseconds(10);
- source_->DidFinishFrame(0);
- now_src_->AdvanceNowMicroseconds(10);
- source_->SetNeedsBeginFrames(false);
- now_src_->AdvanceNowMicroseconds(10);
- source_->SetNeedsBeginFrames(true);
-
- EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
- EXPECT_TRUE(task_runner_->HasPendingTasks());
- task_runner_->RunUntilIdle();
-}
-
-TEST_F(BackToBackBeginFrameSourceTest,
- TogglingSetNeedsBeginFramesThenDidFinishFrameProducesCorrectFrame) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(100);
- source_->DidFinishFrame(0);
- now_src_->AdvanceNowMicroseconds(10);
- source_->SetNeedsBeginFrames(false);
- now_src_->AdvanceNowMicroseconds(10);
- source_->SetNeedsBeginFrames(true);
- now_src_->AdvanceNowMicroseconds(10);
-
- EXPECT_BEGIN_FRAME_USED(*obs_, 1130, 1130 + kDeadline, kInterval);
- EXPECT_TRUE(task_runner_->HasPendingTasks());
- task_runner_->RunUntilIdle();
-}
-
-TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNeedsBeginFrameFalse) {
- source_->SetNeedsBeginFrames(false);
- source_->DidFinishFrame(0);
- EXPECT_FALSE(task_runner_->RunPendingTasks());
-}
-
-TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(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_->RunUntilIdle();
-}
-
-TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) {
- source_->SetNeedsBeginFrames(true);
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(100);
- source_->DidFinishFrame(0);
- source_->DidFinishFrame(0);
- source_->DidFinishFrame(0);
- EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(100);
- source_->DidFinishFrame(0);
- source_->DidFinishFrame(0);
- source_->DidFinishFrame(0);
- EXPECT_BEGIN_FRAME_USED(*obs_, 1200, 1200 + kDeadline, kInterval);
- task_runner_->RunUntilIdle();
-}
-
-TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) {
- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);
- source_->SetNeedsBeginFrames(true);
- task_runner_->RunUntilIdle();
-
- now_src_->AdvanceNowMicroseconds(100);
- source_->DidFinishFrame(0);
- now_src_->AdvanceNowMicroseconds(50);
- EXPECT_BEGIN_FRAME_USED(*obs_, 1150, 1150 + kDeadline, kInterval);
-
- EXPECT_TRUE(task_runner_->HasPendingTasks());
- task_runner_->RunUntilIdle();
-}
-
-// SyntheticBeginFrameSource testing ------------------------------------------
-class SyntheticBeginFrameSourceTest : public ::testing::Test {
- public:
- scoped_refptr<TestNowSource> now_src_;
- scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
- scoped_ptr<TestSyntheticBeginFrameSource> source_;
- scoped_ptr<MockBeginFrameObserver> obs_;
-
- void SetUp() override {
- now_src_ = TestNowSource::Create(1000);
- task_runner_ =
- make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_, false));
- source_ = TestSyntheticBeginFrameSource::Create(
- now_src_, task_runner_.get(), base::TimeDelta::FromMicroseconds(10000));
- obs_ = make_scoped_ptr(new MockBeginFrameObserver());
- source_->AddObserver(obs_.get());
- }
-
- void TearDown() override { obs_.reset(); }
-};
-
-TEST_F(SyntheticBeginFrameSourceTest,
- SetNeedsBeginFramesCallsOnBeginFrameWithMissedTick) {
- now_src_->SetNowMicroseconds(10010);
- EXPECT_CALL((*obs_), OnBeginFrame(CreateBeginFrameArgsForTesting(
- BEGINFRAME_FROM_HERE, 10000, 20000, 10000,
- BeginFrameArgs::MISSED)));
- source_->SetNeedsBeginFrames(true); // Should cause the last tick to be sent
- // No tasks should need to be run for this to occur.
-}
-
-TEST_F(SyntheticBeginFrameSourceTest,
- SetNeedsBeginFramesCallsCausesOnBeginFrame) {
- source_->SetNeedsBeginFrames(true);
- EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue());
-
- EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
- now_src_->SetNowMicroseconds(10010);
- task_runner_->RunPendingTasks();
-}
-
-TEST_F(SyntheticBeginFrameSourceTest, BasicOperation) {
- task_runner_->SetAutoAdvanceNowToPendingTasks(true);
-
- source_->SetNeedsBeginFrames(true);
- EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
- EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000);
- EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000);
- task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001));
-
- source_->SetNeedsBeginFrames(false);
- // No new frames....
- task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000));
-}
-
-TEST_F(SyntheticBeginFrameSourceTest, VSyncChanges) {
- task_runner_->SetAutoAdvanceNowToPendingTasks(true);
- source_->SetNeedsBeginFrames(true);
-
- EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);
- EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000);
- EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000);
- task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001));
-
- // Update the vsync information
- source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(27500),
- base::TimeDelta::FromMicroseconds(10001));
-
- EXPECT_BEGIN_FRAME_USED(*obs_, 40000, 47502, 10001);
- EXPECT_BEGIN_FRAME_USED(*obs_, 47502, 57503, 10001);
- EXPECT_BEGIN_FRAME_USED(*obs_, 57503, 67504, 10001);
- task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000));
-}
-
-// BeginFrameSourceMultiplexer testing -----------------------------------
-class BeginFrameSourceMultiplexerTest : public ::testing::Test {
- protected:
- void SetUp() override {
- mux_ = BeginFrameSourceMultiplexer::Create();
-
- source1_store_ = make_scoped_ptr(new FakeBeginFrameSource());
- source2_store_ = make_scoped_ptr(new FakeBeginFrameSource());
- source3_store_ = make_scoped_ptr(new FakeBeginFrameSource());
-
- source1_ = source1_store_.get();
- source2_ = source2_store_.get();
- source3_ = source3_store_.get();
- }
-
- void TearDown() override {
- // Make sure the mux is torn down before the sources.
- mux_.reset();
- }
-
- scoped_ptr<BeginFrameSourceMultiplexer> mux_;
- FakeBeginFrameSource* source1_;
- FakeBeginFrameSource* source2_;
- FakeBeginFrameSource* source3_;
-
- private:
- scoped_ptr<FakeBeginFrameSource> source1_store_;
- scoped_ptr<FakeBeginFrameSource> source2_store_;
- scoped_ptr<FakeBeginFrameSource> source3_store_;
-};
-
-TEST_F(BeginFrameSourceMultiplexerTest, SourcesManipulation) {
- EXPECT_EQ(NULL, mux_->ActiveSource());
-
- mux_->AddSource(source1_);
- EXPECT_EQ(source1_, mux_->ActiveSource());
-
- mux_->SetActiveSource(NULL);
- EXPECT_EQ(NULL, mux_->ActiveSource());
-
- mux_->SetActiveSource(source1_);
-
-#ifndef NDEBUG
- // Setting a source which isn't in the mux as active should DCHECK fail.
- EXPECT_DEATH({ mux_->SetActiveSource(source2_); }, "");
-
- // Adding a source which is already added should DCHECK fail.
- EXPECT_DEATH({ mux_->AddSource(source1_); }, "");
-
- // Removing a source which isn't in the mux should DCHECK fail.
- EXPECT_DEATH({ mux_->RemoveSource(source2_); }, "");
-
- // Removing the active source fails
- EXPECT_DEATH({ mux_->RemoveSource(source1_); }, "");
-#endif
-
- // Test manipulation doesn't segfault.
- mux_->AddSource(source2_);
- mux_->RemoveSource(source2_);
-
- mux_->AddSource(source2_);
- mux_->SetActiveSource(source2_);
- EXPECT_EQ(source2_, mux_->ActiveSource());
-
- mux_->RemoveSource(source1_);
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, NeedsBeginFrames) {
- mux_->AddSource(source1_);
- mux_->AddSource(source2_);
- mux_->SetActiveSource(source1_);
- EXPECT_EQ(source1_->NeedsBeginFrames(), false);
- EXPECT_EQ(source2_->NeedsBeginFrames(), false);
-
- // Check SetNeedsFrames works
- mux_->SetNeedsBeginFrames(true);
- EXPECT_EQ(source1_->NeedsBeginFrames(), true);
- EXPECT_EQ(source2_->NeedsBeginFrames(), false);
-
- mux_->SetNeedsBeginFrames(false);
- EXPECT_EQ(source1_->NeedsBeginFrames(), false);
- EXPECT_EQ(source2_->NeedsBeginFrames(), false);
-
- // Checking that switching the source makes SetNeedsFrames on the
- // subsources correctly.
- mux_->SetNeedsBeginFrames(true);
-
- mux_->SetActiveSource(source1_);
- EXPECT_EQ(source1_->NeedsBeginFrames(), true);
- EXPECT_EQ(source2_->NeedsBeginFrames(), false);
-
- mux_->SetActiveSource(source2_);
- EXPECT_EQ(source1_->NeedsBeginFrames(), false);
- EXPECT_EQ(source2_->NeedsBeginFrames(), true);
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, BeginFramesSimple) {
- mux_->AddSource(source1_);
- mux_->AddSource(source2_);
- mux_->SetActiveSource(source1_);
-
- MockBeginFrameObserver obs;
- mux_->AddObserver(&obs);
- EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
-
- mux_->SetActiveSource(source1_);
-
- SEND_BEGIN_FRAME_USED(*source1_, 100, 200, 300);
- SEND_BEGIN_FRAME_DROP(*source2_, 200, 500, 300);
-
- mux_->SetActiveSource(source2_);
- SEND_BEGIN_FRAME_USED(*source2_, 400, 600, 300);
- SEND_BEGIN_FRAME_DROP(*source1_, 500, 700, 300);
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, BeginFramesBackwardsProtection) {
- mux_->AddSource(source1_);
- mux_->AddSource(source2_);
-
- MockBeginFrameObserver obs;
- mux_->AddObserver(&obs);
- EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 1000, 1200, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 1001, 1201, 301);
-
- mux_->SetActiveSource(source1_);
- SEND_BEGIN_FRAME_USED(*source1_, 400, 600, 300);
- SEND_BEGIN_FRAME_USED(*source1_, 700, 900, 300);
-
- mux_->SetActiveSource(source2_);
- SEND_BEGIN_FRAME_DROP(*source2_, 699, 899, 300);
- SEND_BEGIN_FRAME_USED(*source2_, 1000, 1200, 300);
-
- mux_->SetActiveSource(source1_);
- SEND_BEGIN_FRAME_USED(*source1_, 1001, 1201, 301);
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, MinimumIntervalNegativeFails) {
-#ifndef NDEBUG
- EXPECT_DEATH(
- { mux_->SetMinimumInterval(base::TimeDelta::FromInternalValue(-100)); },
- "");
-#endif
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, MinimumIntervalZero) {
- mux_->SetMinimumInterval(base::TimeDelta());
- mux_->AddSource(source1_);
-
- MockBeginFrameObserver obs;
- mux_->AddObserver(&obs);
- EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
-
- SEND_BEGIN_FRAME_USED(*source1_, 100, 200, 300);
- SEND_BEGIN_FRAME_USED(*source1_, 400, 600, 300);
- SEND_BEGIN_FRAME_USED(*source1_, 700, 900, 300);
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, MinimumIntervalBasic) {
- mux_->SetMinimumInterval(base::TimeDelta::FromInternalValue(600));
- mux_->AddSource(source1_);
-
- MockBeginFrameObserver obs;
- mux_->AddObserver(&obs);
- EXPECT_BEGIN_FRAME_USED(obs, 100, 200, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
-
- SEND_BEGIN_FRAME_USED(*source1_, 100, 200, 300);
- SEND_BEGIN_FRAME_DROP(*source1_, 400, 600, 300);
- SEND_BEGIN_FRAME_USED(*source1_, 700, 900, 300);
-}
-
-TEST_F(BeginFrameSourceMultiplexerTest, MinimumIntervalWithMultipleSources) {
- mux_->SetMinimumInterval(base::TimeDelta::FromMicroseconds(150));
- mux_->AddSource(source1_);
- mux_->AddSource(source2_);
-
- MockBeginFrameObserver obs;
- mux_->AddObserver(&obs);
- EXPECT_BEGIN_FRAME_USED(obs, 400, 600, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 700, 900, 300);
- EXPECT_BEGIN_FRAME_USED(obs, 1050, 1250, 300);
-
- mux_->SetActiveSource(source1_);
- SEND_BEGIN_FRAME_USED(*source1_, 400, 600, 300);
- SEND_BEGIN_FRAME_USED(*source1_, 700, 900, 300);
-
- mux_->SetActiveSource(source2_);
- SEND_BEGIN_FRAME_DROP(*source2_, 750, 1050, 300);
- SEND_BEGIN_FRAME_USED(*source2_, 1050, 1250, 300);
-
- mux_->SetActiveSource(source1_);
- SEND_BEGIN_FRAME_DROP(*source2_, 1100, 1400, 300);
-}
-
-} // namespace
-} // namespace cc
« no previous file with comments | « cc/scheduler/begin_frame_source.cc ('k') | cc/scheduler/commit_earlyout_reason.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698