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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: cc/surfaces/display_scheduler_unittest.cc

Issue 2854163003: [cc] Plumb BeginFrameAcks through SurfaceManager to DisplayScheduler. (Closed)
Patch Set: fix clang compile error Created 3 years, 7 months 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/surfaces/display_scheduler.cc ('k') | cc/surfaces/display_unittest.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: cc/surfaces/display_scheduler_unittest.cc
diff --git a/cc/surfaces/display_scheduler_unittest.cc b/cc/surfaces/display_scheduler_unittest.cc
index a03aeacb66196a17b4d8342551d207599cca0f62..68e80a00e7adc99fb9235a787e4ac32286534972 100644
--- a/cc/surfaces/display_scheduler_unittest.cc
+++ b/cc/surfaces/display_scheduler_unittest.cc
@@ -5,11 +5,13 @@
#include "cc/surfaces/display_scheduler.h"
#include "base/logging.h"
+#include "base/stl_util.h"
#include "base/test/null_task_runner.h"
#include "base/test/simple_test_tick_clock.h"
#include "base/trace_event/trace_event.h"
#include "cc/output/begin_frame_args.h"
#include "cc/surfaces/display.h"
+#include "cc/surfaces/surface_info.h"
#include "cc/test/fake_external_begin_frame_source.h"
#include "cc/test/scheduler_test_common.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -23,21 +25,38 @@ static constexpr FrameSinkId kArbitraryFrameSinkId(1, 1);
class FakeDisplaySchedulerClient : public DisplaySchedulerClient {
public:
- FakeDisplaySchedulerClient() : draw_and_swap_count_(0) {}
+ FakeDisplaySchedulerClient()
+ : draw_and_swap_count_(0), next_draw_and_swap_fails_(false) {}
~FakeDisplaySchedulerClient() override {}
bool DrawAndSwap() override {
draw_and_swap_count_++;
- return true;
+
+ bool success = !next_draw_and_swap_fails_;
+ next_draw_and_swap_fails_ = false;
+
+ if (success)
+ undrawn_surfaces_.clear();
+ return success;
}
- void Reset() { draw_and_swap_count_ = 0; }
+ bool SurfaceHasUndrawnFrame(const SurfaceId& surface_id) const override {
+ return base::ContainsKey(undrawn_surfaces_, surface_id);
+ }
int draw_and_swap_count() const { return draw_and_swap_count_; }
+ void SetNextDrawAndSwapFails() { next_draw_and_swap_fails_ = true; }
+
+ void SurfaceDamaged(const SurfaceId& surface_id) {
+ undrawn_surfaces_.insert(surface_id);
+ }
+
protected:
int draw_and_swap_count_;
+ bool next_draw_and_swap_fails_;
+ std::set<SurfaceId> undrawn_surfaces_;
};
class TestDisplayScheduler : public DisplayScheduler {
@@ -75,6 +94,8 @@ class TestDisplayScheduler : public DisplayScheduler {
return inside_begin_frame_deadline_interval_;
}
+ bool has_pending_surfaces() { return has_pending_surfaces_; }
+
protected:
int scheduler_begin_frame_deadline_count_;
};
@@ -95,20 +116,35 @@ class DisplaySchedulerTest : public testing::Test {
void SetUp() override { scheduler_.SetRootSurfaceResourcesLocked(false); }
- void AdvanceTimeAndBeginFrameForTest() {
+ void AdvanceTimeAndBeginFrameForTest(
+ const std::vector<SurfaceId>& observing_surfaces) {
now_src_.Advance(base::TimeDelta::FromMicroseconds(10000));
// FakeBeginFrameSource deals with |source_id| and |sequence_number|.
- BeginFrameArgs args = fake_begin_frame_source_.CreateBeginFrameArgs(
+ last_begin_frame_args_ = fake_begin_frame_source_.CreateBeginFrameArgs(
BEGINFRAME_FROM_HERE, &now_src_);
- fake_begin_frame_source_.TestOnBeginFrame(args);
+ fake_begin_frame_source_.TestOnBeginFrame(last_begin_frame_args_);
+ for (const SurfaceId& surface : observing_surfaces)
+ scheduler_.SurfaceDamageExpected(surface, last_begin_frame_args_);
+ }
+
+ void SurfaceDamaged(const SurfaceId& surface_id) {
+ client_.SurfaceDamaged(surface_id);
+ scheduler_.SurfaceDamaged(surface_id, AckForCurrentBeginFrame(), true);
}
protected:
base::SimpleTestTickClock& now_src() { return now_src_; }
FakeDisplaySchedulerClient& client() { return client_; }
DisplayScheduler& scheduler() { return scheduler_; }
+ BeginFrameAck AckForCurrentBeginFrame() {
+ DCHECK(last_begin_frame_args_.IsValid());
+ return BeginFrameAck(last_begin_frame_args_.source_id,
+ last_begin_frame_args_.sequence_number,
+ last_begin_frame_args_.sequence_number, true);
+ }
FakeExternalBeginFrameSource fake_begin_frame_source_;
+ BeginFrameArgs last_begin_frame_args_;
base::SimpleTestTickClock now_src_;
scoped_refptr<base::NullTaskRunner> task_runner_;
@@ -130,18 +166,22 @@ TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilNewRootSurface) {
scheduler_.SetVisible(true);
// Go trough an initial BeginFrame cycle with the root surface.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest(std::vector<SurfaceId>());
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id1, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id1);
scheduler_.BeginFrameDeadlineForTest();
// Resize on the next begin frame cycle should cause the deadline to wait
// for a new root surface.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({root_surface_id1});
late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
- scheduler_.SurfaceDamaged(sid1);
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ SurfaceDamaged(sid1);
EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.DisplayResized();
EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
+ scheduler_.SurfaceDestroyed(root_surface_id1);
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id2, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id2);
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
@@ -149,10 +189,10 @@ TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilNewRootSurface) {
// Verify deadline goes back to normal after resize.
late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid1);
+ AdvanceTimeAndBeginFrameForTest({root_surface_id2, sid1});
+ SurfaceDamaged(sid1);
EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
- scheduler_.SurfaceDamaged(root_surface_id2);
+ SurfaceDamaged(root_surface_id2);
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
@@ -169,29 +209,31 @@ TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilDamagedSurface) {
scheduler_.SetVisible(true);
// Go trough an initial BeginFrame cycle with the root surface.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest(std::vector<SurfaceId>());
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
scheduler_.BeginFrameDeadlineForTest();
// Resize on the next begin frame cycle should cause the deadline to wait
// for a new root surface.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({root_surface_id});
late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
- scheduler_.SurfaceDamaged(sid1);
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ SurfaceDamaged(sid1);
EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.DisplayResized();
EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
- scheduler_.SurfaceDamaged(root_surface_id);
+ SurfaceDamaged(root_surface_id);
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
// Verify deadline goes back to normal after resize.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({root_surface_id, sid1});
late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
- scheduler_.SurfaceDamaged(root_surface_id);
+ SurfaceDamaged(root_surface_id);
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
@@ -200,67 +242,75 @@ TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilDamagedSurface) {
TEST_F(DisplaySchedulerTest, SurfaceDamaged) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
- SurfaceId sid2(kArbitraryFrameSinkId,
LocalSurfaceId(2, base::UnguessableToken::Create()));
+ SurfaceId sid2(kArbitraryFrameSinkId,
+ LocalSurfaceId(3, base::UnguessableToken::Create()));
scheduler_.SetVisible(true);
- // Set the root surface
+ // Create surfaces and set the root surface.
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(sid2, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
- // Get scheduler to detect surface 1 as active by drawing
- // two frames in a row with damage from surface 1.
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid1);
- scheduler_.BeginFrameDeadlineForTest();
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid1);
- scheduler_.BeginFrameDeadlineForTest();
+ // Set surface1 as active via SurfaceDamageExpected().
+ AdvanceTimeAndBeginFrameForTest({sid1});
// Damage only from surface 2 (inactive) does not trigger deadline early.
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid2);
+ SurfaceDamaged(sid2);
+ EXPECT_TRUE(scheduler_.has_pending_surfaces());
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
// Damage from surface 1 triggers deadline early.
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
+ EXPECT_FALSE(scheduler_.has_pending_surfaces());
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
- // Make both surface 1 and 2 active.
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid2);
- scheduler_.SurfaceDamaged(sid1);
- scheduler_.BeginFrameDeadlineForTest();
+ // Set both surface 1 and 2 as active via SurfaceDamageExpected().
+ AdvanceTimeAndBeginFrameForTest({sid1, sid2});
// Deadline doesn't trigger early until surface 1 and 2 are both damaged.
- AdvanceTimeAndBeginFrameForTest();
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
- scheduler_.SurfaceDamaged(sid2);
+ SurfaceDamaged(sid2);
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
- // Make the system idle
- AdvanceTimeAndBeginFrameForTest();
+ // SurfaceDamage with |!has_damage| triggers early deadline.
+ AdvanceTimeAndBeginFrameForTest({sid1});
+ EXPECT_LT(now_src().NowTicks(),
+ scheduler_.DesiredBeginFrameDeadlineTimeForTest());
+ BeginFrameAck ack = AckForCurrentBeginFrame();
+ ack.has_damage = false;
+ scheduler_.SurfaceDamaged(sid1, ack, false);
+ EXPECT_GE(now_src().NowTicks(),
+ scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
- AdvanceTimeAndBeginFrameForTest();
+
+ // System should be idle now.
+ AdvanceTimeAndBeginFrameForTest(std::vector<SurfaceId>());
+ EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval());
+
+ // SurfaceDamage with |!display_damaged| does not affect needs_draw and
+ // scheduler stays idle.
+ scheduler_.SurfaceDamaged(sid1, AckForCurrentBeginFrame(), false);
EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval());
// Deadline should trigger early if child surfaces are idle and
// we get damage on the root surface.
- AdvanceTimeAndBeginFrameForTest();
+ scheduler_.SurfaceDamageExpected(root_surface_id, last_begin_frame_args_);
EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval());
- scheduler_.SurfaceDamaged(root_surface_id);
+ SurfaceDamaged(root_surface_id);
EXPECT_GE(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.BeginFrameDeadlineForTest();
@@ -269,26 +319,28 @@ TEST_F(DisplaySchedulerTest, SurfaceDamaged) {
TEST_F(DisplaySchedulerTest, OutputSurfaceLost) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
+ LocalSurfaceId(2, base::UnguessableToken::Create()));
scheduler_.SetVisible(true);
- // Set the root surface
+ // Create surfaces and set the root surface.
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
// DrawAndSwap normally.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
EXPECT_EQ(0, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(1, client_.draw_and_swap_count());
// Deadline triggers immediately on OutputSurfaceLost.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.OutputSurfaceLost();
@@ -297,7 +349,7 @@ TEST_F(DisplaySchedulerTest, OutputSurfaceLost) {
// Deadline does not DrawAndSwap after OutputSurfaceLost.
EXPECT_EQ(1, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(1, client_.draw_and_swap_count());
}
@@ -305,9 +357,7 @@ TEST_F(DisplaySchedulerTest, OutputSurfaceLost) {
TEST_F(DisplaySchedulerTest, VisibleWithoutDamageNoTicks) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
- SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
scheduler_.SetVisible(true);
@@ -323,9 +373,9 @@ TEST_F(DisplaySchedulerTest, VisibleWithoutDamageNoTicks) {
TEST_F(DisplaySchedulerTest, VisibleWithDamageTicks) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
+ LocalSurfaceId(2, base::UnguessableToken::Create()));
scheduler_.SetNewRootSurface(root_surface_id);
@@ -340,24 +390,27 @@ TEST_F(DisplaySchedulerTest, VisibleWithDamageTicks) {
TEST_F(DisplaySchedulerTest, Visibility) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
+ LocalSurfaceId(2, base::UnguessableToken::Create()));
+ // Create surfaces and set the root surface.
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
scheduler_.SetVisible(true);
EXPECT_EQ(1u, fake_begin_frame_source_.num_observers());
// DrawAndSwap normally.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
EXPECT_EQ(0, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(1, client_.draw_and_swap_count());
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
@@ -381,7 +434,7 @@ TEST_F(DisplaySchedulerTest, Visibility) {
scheduler_.SetVisible(false);
// Does not start listening for begin frames when damage arrives.
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_EQ(0u, fake_begin_frame_source_.num_observers());
// But does when becoming visible with damage again.
@@ -392,26 +445,28 @@ TEST_F(DisplaySchedulerTest, Visibility) {
TEST_F(DisplaySchedulerTest, ResizeCausesSwap) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
+ LocalSurfaceId(2, base::UnguessableToken::Create()));
scheduler_.SetVisible(true);
- // Set the root surface
+ // Create surfaces and set the root surface.
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
// DrawAndSwap normally.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
EXPECT_EQ(0, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(1, client_.draw_and_swap_count());
scheduler_.DisplayResized();
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest(std::vector<SurfaceId>());
// DisplayResized should trigger a swap to happen.
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(2, client_.draw_and_swap_count());
@@ -420,46 +475,48 @@ TEST_F(DisplaySchedulerTest, ResizeCausesSwap) {
TEST_F(DisplaySchedulerTest, RootSurfaceResourcesLocked) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
+ LocalSurfaceId(2, base::UnguessableToken::Create()));
base::TimeTicks late_deadline;
scheduler_.SetVisible(true);
- // Set the root surface
+ // Create surfaces and set the root surface.
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
// DrawAndSwap normally.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
EXPECT_EQ(0, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(1, client_.draw_and_swap_count());
// Deadline triggers late while root resources are locked.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1});
late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.SetRootSurfaceResourcesLocked(true);
EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
// Deadline does not DrawAndSwap while root resources are locked.
EXPECT_EQ(1, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
scheduler_.BeginFrameDeadlineForTest();
EXPECT_EQ(1, client_.draw_and_swap_count());
// Deadline triggers normally when root resources are unlocked.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1, root_surface_id});
late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
scheduler_.SetRootSurfaceResourcesLocked(false);
- scheduler_.SurfaceDamaged(root_surface_id);
+ SurfaceDamaged(root_surface_id);
EXPECT_EQ(base::TimeTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
@@ -471,56 +528,51 @@ TEST_F(DisplaySchedulerTest, RootSurfaceResourcesLocked) {
TEST_F(DisplaySchedulerTest, DidSwapBuffers) {
SurfaceId root_surface_id(
kArbitraryFrameSinkId,
- LocalSurfaceId(0, base::UnguessableToken::Create()));
+ LocalSurfaceId(1, base::UnguessableToken::Create()));
SurfaceId sid1(kArbitraryFrameSinkId,
- LocalSurfaceId(1, base::UnguessableToken::Create()));
- SurfaceId sid2(kArbitraryFrameSinkId,
LocalSurfaceId(2, base::UnguessableToken::Create()));
+ SurfaceId sid2(kArbitraryFrameSinkId,
+ LocalSurfaceId(3, base::UnguessableToken::Create()));
scheduler_.SetVisible(true);
- // Set the root surface
+ // Create surfaces and set the root surface.
+ scheduler_.SurfaceCreated(SurfaceInfo(sid1, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(sid2, 1.0f, gfx::Size()));
+ scheduler_.SurfaceCreated(SurfaceInfo(root_surface_id, 1.0f, gfx::Size()));
scheduler_.SetNewRootSurface(root_surface_id);
- // Get scheduler to detect surface 1 and 2 as active.
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid1);
- scheduler_.SurfaceDamaged(sid2);
- scheduler_.BeginFrameDeadlineForTest();
- AdvanceTimeAndBeginFrameForTest();
- scheduler_.SurfaceDamaged(sid1);
- scheduler_.SurfaceDamaged(sid2);
- scheduler_.BeginFrameDeadlineForTest();
+ // Set surface 1 and 2 as active.
+ AdvanceTimeAndBeginFrameForTest({sid1, sid2});
// DrawAndSwap normally.
- AdvanceTimeAndBeginFrameForTest();
EXPECT_LT(now_src().NowTicks(),
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
- EXPECT_EQ(2, client_.draw_and_swap_count());
- scheduler_.SurfaceDamaged(sid1);
- scheduler_.SurfaceDamaged(sid2);
+ EXPECT_EQ(0, client_.draw_and_swap_count());
+ SurfaceDamaged(sid1);
+ SurfaceDamaged(sid2);
scheduler_.BeginFrameDeadlineForTest();
- EXPECT_EQ(3, client_.draw_and_swap_count());
+ EXPECT_EQ(1, client_.draw_and_swap_count());
scheduler_.DidSwapBuffers();
// Deadline triggers late when swap throttled.
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid1, sid2});
base::TimeTicks late_deadline =
now_src().NowTicks() + BeginFrameArgs::DefaultInterval();
// Damage surface 1, but not surface 2 so we avoid triggering deadline
// early because all surfaces are ready.
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest());
// Don't draw and swap in deadline while swap throttled.
- EXPECT_EQ(3, client_.draw_and_swap_count());
+ EXPECT_EQ(1, client_.draw_and_swap_count());
scheduler_.BeginFrameDeadlineForTest();
- EXPECT_EQ(3, client_.draw_and_swap_count());
+ EXPECT_EQ(1, client_.draw_and_swap_count());
// Deadline triggers normally once not swap throttled.
// Damage from previous BeginFrame should cary over, so don't damage again.
scheduler_.DidReceiveSwapBuffersAck();
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest({sid2});
base::TimeTicks expected_deadline =
scheduler_.LastUsedBeginFrameArgs().deadline -
BeginFrameArgs::DefaultEstimatedParentDrawTime();
@@ -528,13 +580,13 @@ TEST_F(DisplaySchedulerTest, DidSwapBuffers) {
scheduler_.DesiredBeginFrameDeadlineTimeForTest());
// Still waiting for surface 2. Once it updates, deadline should trigger
// immediately again.
- scheduler_.SurfaceDamaged(sid2);
- EXPECT_EQ(scheduler_.DesiredBeginFrameDeadlineTimeForTest(),
- base::TimeTicks());
+ SurfaceDamaged(sid2);
+ EXPECT_EQ(base::TimeTicks(),
+ scheduler_.DesiredBeginFrameDeadlineTimeForTest());
// Draw and swap now that we aren't throttled.
- EXPECT_EQ(3, client_.draw_and_swap_count());
+ EXPECT_EQ(1, client_.draw_and_swap_count());
scheduler_.BeginFrameDeadlineForTest();
- EXPECT_EQ(4, client_.draw_and_swap_count());
+ EXPECT_EQ(2, client_.draw_and_swap_count());
}
// This test verfies that we try to reschedule the deadline
@@ -568,12 +620,12 @@ TEST_F(DisplaySchedulerTest, ScheduleBeginFrameDeadline) {
scheduler_.SetNewRootSurface(root_surface_id);
EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest(std::vector<SurfaceId>());
EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
scheduler_.BeginFrameDeadlineForTest();
scheduler_.DidSwapBuffers();
- AdvanceTimeAndBeginFrameForTest();
+ AdvanceTimeAndBeginFrameForTest(std::vector<SurfaceId>());
EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
scheduler_.DidReceiveSwapBuffersAck();
@@ -585,7 +637,7 @@ TEST_F(DisplaySchedulerTest, ScheduleBeginFrameDeadline) {
scheduler_.SetNewRootSurface(root_surface_id);
EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
- scheduler_.SurfaceDamaged(sid1);
+ SurfaceDamaged(sid1);
EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count());
scheduler_.SetRootSurfaceResourcesLocked(true);
« no previous file with comments | « cc/surfaces/display_scheduler.cc ('k') | cc/surfaces/display_unittest.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698