cc/trees/layer_tree_host_unittest_scroll.cc - Issue 584503005: Make scroll offset type of float in cc

Unified Diff: cc/trees/layer_tree_host_unittest_scroll.cc

Issue 584503005: Make scroll offset type of float in cc (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: update unittests Created 6 years, 3 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

Index: cc/trees/layer_tree_host_unittest_scroll.cc

diff --git a/cc/trees/layer_tree_host_unittest_scroll.cc b/cc/trees/layer_tree_host_unittest_scroll.cc

index 3489a0e79c6cae92f6d562efd0d09ab6062785f4..5c0ce8487a843643ceb1564c88eb1c80614d2a8b 100644

--- a/cc/trees/layer_tree_host_unittest_scroll.cc

+++ b/cc/trees/layer_tree_host_unittest_scroll.cc

@@ -52,9 +52,9 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {

Layer* root = layer_tree_host()->root_layer();

Layer* scroll_layer = root->children()[0].get();

if (!layer_tree_host()->source_frame_number()) {

- EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());

+ EXPECT_VECTOR2DF_EQ(initial_scroll_, scroll_layer->scroll_offset());

danakj 2014/09/18 21:23:49 EXPECT_EQ?

Yufeng Shen (Slow to review) 2014/09/18 22:47:55 Done.

} else {

- EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_,

+ EXPECT_VECTOR2DF_EQ(initial_scroll_ + scroll_amount_,

scroll_layer->scroll_offset());

// Pretend like Javascript updated the scroll position itself.

@@ -65,7 +65,7 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {

virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {

LayerImpl* root = impl->active_tree()->root_layer();

LayerImpl* scroll_layer = root->children()[0];

- EXPECT_VECTOR_EQ(gfx::Vector2d(), scroll_layer->ScrollDelta());

+ EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), scroll_layer->ScrollDelta());

scroll_layer->SetScrollClipLayer(root->id());

scroll_layer->SetBounds(

@@ -74,13 +74,13 @@ class LayerTreeHostScrollTestScrollSimple : public LayerTreeHostScrollTest {

switch (impl->active_tree()->source_frame_number()) {

case 0:

- EXPECT_VECTOR_EQ(initial_scroll_, scroll_layer->scroll_offset());

- EXPECT_VECTOR_EQ(scroll_amount_, scroll_layer->ScrollDelta());

+ EXPECT_VECTOR2DF_EQ(initial_scroll_, scroll_layer->scroll_offset());

+ EXPECT_VECTOR2DF_EQ(scroll_amount_, scroll_layer->ScrollDelta());

PostSetNeedsCommitToMainThread();

break;

case 1:

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), second_scroll_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), second_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), scroll_amount_);

EndTest();

break;

}

@@ -127,13 +127,13 @@ class LayerTreeHostScrollTestScrollMultipleRedraw

virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {

switch (layer_tree_host()->source_frame_number()) {

case 0:

- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(), initial_scroll_);

break;

case 1:

- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(),

initial_scroll_ + scroll_amount_ + scroll_amount_);

case 2:

- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(),

initial_scroll_ + scroll_amount_ + scroll_amount_);

break;

}

@@ -145,27 +145,27 @@ class LayerTreeHostScrollTestScrollMultipleRedraw

if (impl->active_tree()->source_frame_number() == 0 &&

impl->SourceAnimationFrameNumber() == 1) {

// First draw after first commit.

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF());

scroll_layer->ScrollBy(scroll_amount_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), scroll_amount_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), scroll_amount_);

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);

PostSetNeedsRedrawToMainThread();

} else if (impl->active_tree()->source_frame_number() == 0 &&

impl->SourceAnimationFrameNumber() == 2) {

// Second draw after first commit.

EXPECT_EQ(scroll_layer->ScrollDelta(), scroll_amount_);

scroll_layer->ScrollBy(scroll_amount_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(),

scroll_amount_ + scroll_amount_);

- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(), initial_scroll_);

PostSetNeedsCommitToMainThread();

} else if (impl->active_tree()->source_frame_number() == 1) {

// Third or later draw after second commit.

EXPECT_GE(impl->SourceAnimationFrameNumber(), 3);

- EXPECT_VECTOR_EQ(scroll_layer_->ScrollDelta(), gfx::Vector2d());

- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer_->ScrollDelta(), gfx::Vector2dF());

+ EXPECT_VECTOR2DF_EQ(scroll_layer_->scroll_offset(),

initial_scroll_ + scroll_amount_ + scroll_amount_);

EndTest();

}

@@ -180,8 +180,8 @@ class LayerTreeHostScrollTestScrollMultipleRedraw

virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }

private:

- gfx::Vector2d initial_scroll_;

- gfx::Vector2d scroll_amount_;

+ gfx::Vector2dF initial_scroll_;

+ gfx::Vector2dF scroll_amount_;

int num_scrolls_;

scoped_refptr<Layer> scroll_layer_;

};

@@ -230,7 +230,8 @@ class LayerTreeHostScrollTestScrollAbortedCommit

// This will not be aborted because of the initial prop changes.

EXPECT_EQ(0, num_impl_scrolls_);

EXPECT_EQ(0, layer_tree_host()->source_frame_number());

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),

+ initial_scroll_);

EXPECT_EQ(1.f, layer_tree_host()->page_scale_factor());

break;

case 2:

@@ -238,7 +239,7 @@ class LayerTreeHostScrollTestScrollAbortedCommit

// initiated from the redraw.

EXPECT_EQ(1, num_impl_scrolls_);

EXPECT_EQ(1, layer_tree_host()->source_frame_number());

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),

initial_scroll_ + impl_scroll_);

EXPECT_EQ(impl_scale_, layer_tree_host()->page_scale_factor());

PostSetNeedsRedrawToMainThread();

@@ -248,7 +249,7 @@ class LayerTreeHostScrollTestScrollAbortedCommit

EXPECT_EQ(2, num_impl_scrolls_);

// The source frame number still increases even with the abort.

EXPECT_EQ(2, layer_tree_host()->source_frame_number());

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),

initial_scroll_ + impl_scroll_ + impl_scroll_);

EXPECT_EQ(impl_scale_ * impl_scale_,

layer_tree_host()->page_scale_factor());

@@ -259,7 +260,7 @@ class LayerTreeHostScrollTestScrollAbortedCommit

// This commit will also be aborted.

EXPECT_EQ(3, num_impl_scrolls_);

EXPECT_EQ(3, layer_tree_host()->source_frame_number());

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),

initial_scroll_ + impl_scroll_ + impl_scroll_ +

impl_scroll_ + second_main_scroll_);

// End the test by drawing to verify this commit is also aborted.

@@ -285,10 +286,10 @@ class LayerTreeHostScrollTestScrollAbortedCommit

if (impl->active_tree()->source_frame_number() == 0 &&

impl->SourceAnimationFrameNumber() == 1) {

// First draw

- EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());

root_scroll_layer->ScrollBy(impl_scroll_);

- EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(), initial_scroll_);

EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());

EXPECT_EQ(1.f, impl->active_tree()->total_page_scale_factor());

@@ -303,10 +304,10 @@ class LayerTreeHostScrollTestScrollAbortedCommit

// Test a second draw after an aborted commit.

// The scroll/scale values should be baked into the offset/scale factor

// since the main thread consumed but aborted the begin frame.

- EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());

root_scroll_layer->ScrollBy(impl_scroll_);

- EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),

initial_scroll_ + impl_scroll_);

EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());

@@ -323,18 +324,18 @@ class LayerTreeHostScrollTestScrollAbortedCommit

} else if (impl->active_tree()->source_frame_number() == 2 &&

impl->SourceAnimationFrameNumber() == 3) {

// Third draw after the second full commit.

- EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());

+ EXPECT_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());

root_scroll_layer->ScrollBy(impl_scroll_);

impl->SetNeedsCommit();

- EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);

- EXPECT_VECTOR_EQ(

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);

+ EXPECT_VECTOR2DF_EQ(

root_scroll_layer->scroll_offset(),

initial_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_);

} else if (impl->active_tree()->source_frame_number() == 2 &&

impl->SourceAnimationFrameNumber() == 4) {

// Final draw after the second aborted commit.

- EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());

- EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2dF());

+ EXPECT_VECTOR2DF_EQ(root_scroll_layer->scroll_offset(),

initial_scroll_ + impl_scroll_ + impl_scroll_ +

impl_scroll_ + second_main_scroll_);

EndTest();

@@ -409,24 +410,20 @@ class LayerTreeHostScrollTestFractionalScroll : public LayerTreeHostScrollTest {

// multiple commits.

switch (impl->active_tree()->source_frame_number()) {

case 0:

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), gfx::Vector2d(0, 0));

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d(0, 0));

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(),

+ gfx::Vector2dF(0, 0));

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF(0, 0));

PostSetNeedsCommitToMainThread();

break;

case 1:

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),

- gfx::ToFlooredVector2d(scroll_amount_));

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),

- gfx::Vector2dF(fmod(scroll_amount_.x(), 1.0f), 0.0f));

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), scroll_amount_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF(0, 0));

PostSetNeedsCommitToMainThread();

break;

case 2:

- EXPECT_VECTOR_EQ(

- scroll_layer->scroll_offset(),

- gfx::ToFlooredVector2d(scroll_amount_ + scroll_amount_));

- EXPECT_VECTOR_EQ(

- scroll_layer->ScrollDelta(),

- gfx::Vector2dF(fmod(2.0f * scroll_amount_.x(), 1.0f), 0.0f));

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(),

+ scroll_amount_ + scroll_amount_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF(0, 0));

EndTest();

break;

}

@@ -523,23 +520,23 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {

}

virtual void Layout() OVERRIDE {

- EXPECT_VECTOR_EQ(gfx::Vector2d(),

+ EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(),

expected_no_scroll_layer_->scroll_offset());

switch (layer_tree_host()->source_frame_number()) {

case 0:

- EXPECT_VECTOR_EQ(initial_offset_,

+ EXPECT_VECTOR2DF_EQ(initial_offset_,

expected_scroll_layer_->scroll_offset());

break;

case 1:

- EXPECT_VECTOR_EQ(initial_offset_ + scroll_amount_,

+ EXPECT_VECTOR2DF_EQ(initial_offset_ + scroll_amount_,

expected_scroll_layer_->scroll_offset());

// Pretend like Javascript updated the scroll position itself.

expected_scroll_layer_->SetScrollOffset(javascript_scroll_);

break;

case 2:

- EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,

+ EXPECT_VECTOR2DF_EQ(javascript_scroll_ + scroll_amount_,

expected_scroll_layer_->scroll_offset());

break;

}

@@ -562,8 +559,8 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {

expected_no_scroll_layer_impl = child_layer_impl;

}

- EXPECT_VECTOR_EQ(gfx::Vector2d(), root_impl->ScrollDelta());

- EXPECT_VECTOR_EQ(gfx::Vector2d(),

+ EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), root_impl->ScrollDelta());

+ EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(),

expected_no_scroll_layer_impl->ScrollDelta());

// Ensure device scale factor is affecting the layers.

@@ -585,9 +582,9 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {

impl->ScrollEnd();

// Check the scroll is applied as a delta.

- EXPECT_VECTOR_EQ(initial_offset_,

+ EXPECT_VECTOR2DF_EQ(initial_offset_,

expected_scroll_layer_impl->scroll_offset());

- EXPECT_VECTOR_EQ(scroll_amount_,

+ EXPECT_VECTOR2DF_EQ(scroll_amount_,

expected_scroll_layer_impl->ScrollDelta());

break;

}

@@ -602,17 +599,17 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {

impl->ScrollEnd();

// Check the scroll is applied as a delta.

- EXPECT_VECTOR_EQ(javascript_scroll_,

+ EXPECT_VECTOR2DF_EQ(javascript_scroll_,

expected_scroll_layer_impl->scroll_offset());

- EXPECT_VECTOR_EQ(scroll_amount_,

+ EXPECT_VECTOR2DF_EQ(scroll_amount_,

expected_scroll_layer_impl->ScrollDelta());

break;

}

case 2:

- EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,

+ EXPECT_VECTOR2DF_EQ(javascript_scroll_ + scroll_amount_,

expected_scroll_layer_impl->scroll_offset());

- EXPECT_VECTOR_EQ(gfx::Vector2d(),

+ EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(),

expected_scroll_layer_impl->ScrollDelta());

EndTest();

@@ -627,7 +624,7 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {

final_scroll_offset_);

} else {

EXPECT_EQ(2, num_scrolls_);

- EXPECT_VECTOR_EQ(gfx::Vector2d(), final_scroll_offset_);

+ EXPECT_VECTOR2DF_EQ(gfx::Vector2dF(), final_scroll_offset_);

}

@@ -635,11 +632,11 @@ class LayerTreeHostScrollTestCaseWithChild : public LayerTreeHostScrollTest {

float device_scale_factor_;

bool scroll_child_layer_;

- gfx::Vector2d initial_offset_;

- gfx::Vector2d javascript_scroll_;

- gfx::Vector2d scroll_amount_;

+ gfx::Vector2dF initial_offset_;

+ gfx::Vector2dF javascript_scroll_;

+ gfx::Vector2dF scroll_amount_;

int num_scrolls_;

- gfx::Vector2d final_scroll_offset_;

+ gfx::Vector2dF final_scroll_offset_;

FakeContentLayerClient fake_content_layer_client_;

@@ -780,9 +777,9 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {

Layer* root = layer_tree_host()->root_layer();

Layer* scroll_layer = root->children()[0].get();

if (!layer_tree_host()->source_frame_number()) {

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);

} else {

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(),

initial_scroll_ + impl_thread_scroll1_);

// Pretend like Javascript updated the scroll position itself with a

@@ -811,12 +808,14 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {

case 0:

if (!impl->pending_tree()) {

impl->BlockNotifyReadyToActivateForTesting(true);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF());

scroll_layer->ScrollBy(impl_thread_scroll1_);

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll1_);

- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(),

+ impl_thread_scroll1_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

PostSetNeedsCommitToMainThread();

// CommitCompleteOnThread will trigger this function again

@@ -827,29 +826,30 @@ class ImplSidePaintingScrollTestSimple : public ImplSidePaintingScrollTest {

EXPECT_EQ(impl->pending_tree()->source_frame_number(), 1);

scroll_layer->ScrollBy(impl_thread_scroll2_);

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(),

impl_thread_scroll1_ + impl_thread_scroll2_);

- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(),

+ EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),

impl_thread_scroll1_);

LayerImpl* pending_scroll_layer = pending_root->children()[0];

- EXPECT_VECTOR_EQ(

+ EXPECT_VECTOR2DF_EQ(

pending_scroll_layer->scroll_offset(),

initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);

- EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),

impl_thread_scroll2_);

- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),

- gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

}

break;

case 1:

EXPECT_FALSE(impl->pending_tree());

- EXPECT_VECTOR_EQ(

+ EXPECT_VECTOR2DF_EQ(

scroll_layer->scroll_offset(),

initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);

- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll2_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

EndTest();

break;

}

@@ -945,36 +945,39 @@ class ImplSidePaintingScrollTestImplOnlyScroll

ASSERT_TRUE(pending_scroll_layer);

switch (impl->pending_tree()->source_frame_number()) {

case 0:

- EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->scroll_offset(),

initial_scroll_);

- EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());

- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),

- gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),

+ gfx::Vector2dF());

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

EXPECT_FALSE(active_root);

break;

case 1:

// Even though the scroll happened during the commit, both layers

// should have the appropriate scroll delta.

- EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->scroll_offset(),

initial_scroll_);

- EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),

impl_thread_scroll_);

- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),

- gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

ASSERT_TRUE(active_root);

- EXPECT_VECTOR_EQ(active_scroll_layer->scroll_offset(), initial_scroll_);

- EXPECT_VECTOR_EQ(active_scroll_layer->ScrollDelta(),

+ EXPECT_VECTOR2DF_EQ(active_scroll_layer->scroll_offset(),

+ initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(active_scroll_layer->ScrollDelta(),

impl_thread_scroll_);

- EXPECT_VECTOR_EQ(active_scroll_layer->sent_scroll_delta(),

- gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(active_scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

break;

case 2:

// On the next commit, this delta should have been sent and applied.

- EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->scroll_offset(),

initial_scroll_ + impl_thread_scroll_);

- EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(), gfx::Vector2d());

- EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),

- gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->ScrollDelta(),

+ gfx::Vector2dF());

+ EXPECT_VECTOR2DF_EQ(pending_scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

EndTest();

break;

}

@@ -988,15 +991,17 @@ class ImplSidePaintingScrollTestImplOnlyScroll

switch (impl->active_tree()->source_frame_number()) {

case 0:

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), gfx::Vector2d());

- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), gfx::Vector2dF());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

PostSetNeedsCommitToMainThread();

break;

case 1:

- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(), initial_scroll_);

- EXPECT_VECTOR_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);

- EXPECT_VECTOR_EQ(scroll_layer->sent_scroll_delta(), gfx::Vector2d());

+ EXPECT_VECTOR2DF_EQ(scroll_layer->scroll_offset(), initial_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->ScrollDelta(), impl_thread_scroll_);

+ EXPECT_VECTOR2DF_EQ(scroll_layer->sent_scroll_delta(),

+ gfx::Vector2dF());

PostSetNeedsCommitToMainThread();

break;

}

« cc/trees/layer_tree_host_impl_unittest.cc ('K') | « cc/trees/layer_tree_host_unittest.cc ('k') | no next file » | no next file with comments »