cc/scheduler/begin_frame_source_unittest.cc - Issue 2583483002: [cc] Adds source_id and sequence_number to BeginFrameArgs.

Unified Diff: cc/scheduler/begin_frame_source_unittest.cc

Issue 2583483002: [cc] Adds source_id and sequence_number to BeginFrameArgs. (Closed)

Patch Set: Created 4 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

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

index b50c4b91ce510a5444ba5912f090adca3dec176c..fda0b9dc5bf151ae47e807ea12682f6c7c71d7be 100644

--- a/cc/scheduler/begin_frame_source_unittest.cc

+++ b/cc/scheduler/begin_frame_source_unittest.cc

@@ -19,6 +19,19 @@ using testing::StrictMock;

namespace cc {

namespace {

+// BeginFrameSource testing ----------------------------------------------------

+using BeginFrameSourceTest = ::testing::Test;

+TEST_F(BeginFrameSourceTest, SourceIdsAreUnique) {

brianderson 2016/12/15 22:10:33 I think this can just be TEST(), which gets rid of

Eric Seckler 2016/12/16 17:25:58 Done.

+ StubBeginFrameSource source1;

+ StubBeginFrameSource source2;

+ StubBeginFrameSource source3;

+ EXPECT_NE(source1.source_id(), source2.source_id());

+ EXPECT_NE(source1.source_id(), source3.source_id());

+ EXPECT_NE(source2.source_id(), source3.source_id());

+// BackToBackBeginFrameSource testing ------------------------------------------

class BackToBackBeginFrameSourceTest : public ::testing::Test {

protected:

static const int64_t kDeadline;

@@ -53,20 +66,23 @@ 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);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

- EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,

+ 1100 + kDeadline, kInterval);

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

source_->DidFinishFrame(obs_.get(), 0);

task_runner_->RunPendingTasks();

}

TEST_F(BackToBackBeginFrameSourceTest,

- DidFinishFrameThenRemoveObserverProducesNoFrame) {

+ RemoveObserverThenDidFinishFrameProducesNoFrame) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

source_->RemoveObserver(obs_.get());

@@ -80,10 +96,11 @@ TEST_F(BackToBackBeginFrameSourceTest,

}

TEST_F(BackToBackBeginFrameSourceTest,

- RemoveObserverThenDidFinishFrameProducesNoFrame) {

+ DidFinishFrameThenRemoveObserverProducesNoFrame) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

@@ -98,7 +115,8 @@ TEST_F(BackToBackBeginFrameSourceTest,

TogglingObserverThenDidFinishFrameProducesCorrectFrame) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

@@ -114,7 +132,8 @@ TEST_F(BackToBackBeginFrameSourceTest,

now_src_->Advance(base::TimeDelta::FromMicroseconds(10));

// The begin frame is posted at the time when the observer was added,

// so it ignores changes to "now" afterward.

- EXPECT_BEGIN_FRAME_USED(*obs_, 1110, 1110 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110,

+ 1110 + kDeadline, kInterval);

EXPECT_TRUE(task_runner_->HasPendingTasks());

task_runner_->RunPendingTasks();

}

@@ -123,7 +142,8 @@ TEST_F(BackToBackBeginFrameSourceTest,

DidFinishFrameThenTogglingObserverProducesCorrectFrame) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

@@ -139,7 +159,8 @@ TEST_F(BackToBackBeginFrameSourceTest,

now_src_->Advance(base::TimeDelta::FromMicroseconds(10));

// Ticks at the time at which the observer was added, ignoring the

// last change to "now".

- EXPECT_BEGIN_FRAME_USED(*obs_, 1120, 1120 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120,

+ 1120 + kDeadline, kInterval);

EXPECT_TRUE(task_runner_->HasPendingTasks());

task_runner_->RunPendingTasks();

}

@@ -155,7 +176,8 @@ TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) {

TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

// Runs the pending begin frame.

task_runner_->RunPendingTasks();

// While running the begin frame, the next frame was cancelled, this

@@ -172,7 +194,8 @@ TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {

source_->DidFinishFrame(obs_.get(), 1);

EXPECT_FALSE(task_runner_->HasPendingTasks());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,

+ 1100 + kDeadline, kInterval);

source_->DidFinishFrame(obs_.get(), 0);

EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime());

task_runner_->RunPendingTasks();

@@ -181,28 +204,32 @@ TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) {

TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

source_->DidFinishFrame(obs_.get(), 0);

- EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,

+ 1100 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

source_->DidFinishFrame(obs_.get(), 0);

- EXPECT_BEGIN_FRAME_USED(*obs_, 1200, 1200 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 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);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000,

+ 1000 + kDeadline, kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

@@ -210,7 +237,8 @@ TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) {

now_src_->Advance(base::TimeDelta::FromMicroseconds(50));

// Ticks at the time the last frame finished, so ignores the last change to

// "now".

- EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100,

+ 1100 + kDeadline, kInterval);

EXPECT_TRUE(task_runner_->HasPendingTasks());

task_runner_->RunPendingTasks();

@@ -224,15 +252,19 @@ TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);

source_->AddObserver(&obs2);

- EXPECT_BEGIN_FRAME_USED(obs1, 1000, 1000 + kDeadline, kInterval);

- EXPECT_BEGIN_FRAME_USED(obs2, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,

+ kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

source_->DidFinishFrame(&obs1, 0);

source_->DidFinishFrame(&obs2, 0);

- EXPECT_BEGIN_FRAME_USED(obs1, 1100, 1100 + kDeadline, kInterval);

- EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline,

+ kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

@@ -249,18 +281,21 @@ TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);

source_->AddObserver(&obs1);

- EXPECT_BEGIN_FRAME_USED(obs1, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);

source_->AddObserver(&obs2);

- EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

source_->DidFinishFrame(&obs1, 0);

- EXPECT_BEGIN_FRAME_USED(obs1, 1200, 1200 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

source_->DidFinishFrame(&obs1, 0);

@@ -271,7 +306,8 @@ TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) {

now_src_->Advance(base::TimeDelta::FromMicroseconds(100));

source_->DidFinishFrame(&obs2, 0);

- EXPECT_BEGIN_FRAME_USED(obs2, 1300, 1300 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

source_->DidFinishFrame(&obs2, 0);

@@ -285,8 +321,10 @@ TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);

source_->AddObserver(&obs1);

source_->AddObserver(&obs2);

- EXPECT_BEGIN_FRAME_USED(obs1, 1000, 1000 + kDeadline, kInterval);

- EXPECT_BEGIN_FRAME_USED(obs2, 1000, 1000 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline,

+ kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

// |obs1| finishes first.

@@ -299,8 +337,10 @@ TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) {

// Because the begin frame source already ticked when |obs1| finished,

// we see it as the frame time for both observers.

- EXPECT_BEGIN_FRAME_USED(obs1, 1100, 1100 + kDeadline, kInterval);

- EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline,

+ kInterval);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline,

+ kInterval);

task_runner_->RunPendingTasks();

source_->DidFinishFrame(&obs1, 0);

@@ -337,18 +377,20 @@ TEST_F(DelayBasedBeginFrameSourceTest,

AddObserverCallsOnBeginFrameWithMissedTick) {

now_src_->Advance(base::TimeDelta::FromMicroseconds(9010));

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 10000, 20000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 10000, 20000,

+ 10000);

source_->AddObserver(obs_.get()); // Should cause the last tick to be sent

// No tasks should need to be run for this to occur.

}

TEST_F(DelayBasedBeginFrameSourceTest, AddObserverCallsCausesOnBeginFrame) {

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 0, 10000,

+ 10000);

source_->AddObserver(obs_.get());

EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue());

- EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10000, 20000, 10000);

now_src_->Advance(base::TimeDelta::FromMicroseconds(9010));

task_runner_->RunPendingTasks();

}

@@ -357,11 +399,12 @@ TEST_F(DelayBasedBeginFrameSourceTest, BasicOperation) {

task_runner_->SetAutoAdvanceNowToPendingTasks(true);

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 0, 10000,

+ 10000);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);

- EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000);

- EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10000, 20000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 20000, 30000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 4, 30000, 40000, 10000);

task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001));

source_->RemoveObserver(obs_.get());

@@ -372,21 +415,22 @@ TEST_F(DelayBasedBeginFrameSourceTest, BasicOperation) {

TEST_F(DelayBasedBeginFrameSourceTest, VSyncChanges) {

task_runner_->SetAutoAdvanceNowToPendingTasks(true);

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 0, 10000,

+ 10000);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000);

- EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000);

- EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10000, 20000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 20000, 30000, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 4, 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);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 5, 40000, 47502, 10001);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 6, 47502, 57503, 10001);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 7, 57503, 67504, 10001);

task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000));

}

@@ -395,25 +439,26 @@ TEST_F(DelayBasedBeginFrameSourceTest, AuthoritativeVSyncChanges) {

source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(500),

base::TimeDelta::FromMicroseconds(10000));

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 500, 10500, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 500, 10500,

+ 10000);

source_->AddObserver(obs_.get());

- EXPECT_BEGIN_FRAME_USED(*obs_, 10500, 20500, 10000);

- EXPECT_BEGIN_FRAME_USED(*obs_, 20500, 30500, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10500, 20500, 10000);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 20500, 30500, 10000);

task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(20501));

// This will keep the same timebase, so 500, 9999

source_->SetAuthoritativeVSyncInterval(

base::TimeDelta::FromMicroseconds(9999));

- EXPECT_BEGIN_FRAME_USED(*obs_, 30500, 40496, 9999);

- EXPECT_BEGIN_FRAME_USED(*obs_, 40496, 50495, 9999);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 4, 30500, 40496, 9999);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 5, 40496, 50495, 9999);

task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(40497));

// Change the vsync params, but the new interval will be ignored.

source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(400),

base::TimeDelta::FromMicroseconds(1));

- EXPECT_BEGIN_FRAME_USED(*obs_, 50495, 60394, 9999);

- EXPECT_BEGIN_FRAME_USED(*obs_, 60394, 70393, 9999);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 6, 50495, 60394, 9999);

+ EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 7, 60394, 70393, 9999);

task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60395));

}

@@ -423,25 +468,28 @@ TEST_F(DelayBasedBeginFrameSourceTest, MultipleObservers) {

// now_src_ starts off at 1000.

task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(9010));

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(obs1, 10000, 20000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(obs1, source_->source_id(), 1, 10000, 20000,

+ 10000);

source_->AddObserver(&obs1); // Should cause the last tick to be sent

// No tasks should need to be run for this to occur.

- EXPECT_BEGIN_FRAME_USED(obs1, 20000, 30000, 10000);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 20000, 30000, 10000);

task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000));

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(obs2, 20000, 30000, 10000);

+ // Sequence number unchanged for missed frame with time of last normal frame.

+ EXPECT_BEGIN_FRAME_USED_MISSED(obs2, source_->source_id(), 2, 20000, 30000,

+ 10000);

source_->AddObserver(&obs2); // Should cause the last tick to be sent

// No tasks should need to be run for this to occur.

- EXPECT_BEGIN_FRAME_USED(obs1, 30000, 40000, 10000);

- EXPECT_BEGIN_FRAME_USED(obs2, 30000, 40000, 10000);

+ EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 30000, 40000, 10000);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 3, 30000, 40000, 10000);

task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000));

source_->RemoveObserver(&obs1);

- EXPECT_BEGIN_FRAME_USED(obs2, 40000, 50000, 10000);

+ EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 40000, 50000, 10000);

task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000));

source_->RemoveObserver(&obs2);

@@ -453,7 +501,7 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTick) {

StrictMock<MockBeginFrameObserver> obs;

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(obs, 0, 10000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 1, 0, 10000, 10000);

source_->AddObserver(&obs);

source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000),

@@ -467,7 +515,7 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTick) {

source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(10000),

base::TimeDelta::FromInternalValue(10000));

now_src_->Advance(base::TimeDelta::FromInternalValue(5000));

- EXPECT_BEGIN_FRAME_USED(obs, 10000, 20000, 10000);

+ EXPECT_BEGIN_FRAME_USED(obs, source_->source_id(), 2, 10000, 20000, 10000);

task_runner_->RunPendingTasks();

}

@@ -475,7 +523,7 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) {

StrictMock<MockBeginFrameObserver> obs;

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);

- EXPECT_BEGIN_FRAME_USED_MISSED(obs, 0, 10000, 10000);

+ EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 1, 0, 10000, 10000);

source_->AddObserver(&obs);

source_->RemoveObserver(&obs);

@@ -485,6 +533,8 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) {

// No missed frame received.

EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false);

+ // This does not cause a missed BeginFrame, but the sequence number is

+ // incremented, because the possible missed frame has different time/interval.

source_->AddObserver(&obs);

source_->RemoveObserver(&obs);

@@ -493,7 +543,10 @@ TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) {

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);

+ // Sequence number is incremented again, because the missed frame has

+ // different time/interval.

+ EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 3, 10000, 20000,

+ 10000);

source_->AddObserver(&obs);

source_->RemoveObserver(&obs);

}

« cc/scheduler/begin_frame_source.cc ('K') | « cc/scheduler/begin_frame_source.cc ('k') | cc/scheduler/scheduler_unittest.cc » ('j') | cc/scheduler/scheduler_unittest.cc » ('J')