#include "cc/test/layer_tree_test.h"
#include "cc/test/test_shared_bitmap_manager.h"
#include "cc/trees/layer_tree_impl.h"
-#include "ui/gfx/point_conversions.h"
-#include "ui/gfx/size_conversions.h"
-#include "ui/gfx/vector2d_conversions.h"
+#include "ui/gfx/geometry/point_conversions.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/geometry/vector2d_conversions.h"
namespace cc {
namespace {
scroll_amount_(2, -1),
num_scrolls_(0) {}
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
Layer* root_layer = layer_tree_host()->root_layer();
scoped_refptr<Layer> scroll_layer = Layer::Create();
root_layer->AddChild(scroll_layer);
PostSetNeedsCommitToMainThread();
}
- virtual void Layout() OVERRIDE {
+ void Layout() override {
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());
} else {
- EXPECT_VECTOR_EQ(initial_scroll_ + scroll_amount_,
+ EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(initial_scroll_,
+ scroll_amount_),
scroll_layer->scroll_offset());
// Pretend like Javascript updated the scroll position itself.
}
}
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ 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());
}
}
- virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
- float scale,
- float top_controls_delta) OVERRIDE {
+ void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+ float scale,
+ float top_controls_delta) override {
num_scrolls_++;
}
- virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
+ void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
private:
- gfx::Vector2d initial_scroll_;
- gfx::Vector2d second_scroll_;
- gfx::Vector2d scroll_amount_;
+ gfx::ScrollOffset initial_scroll_;
+ gfx::ScrollOffset second_scroll_;
+ gfx::Vector2dF scroll_amount_;
int num_scrolls_;
};
LayerTreeHostScrollTestScrollMultipleRedraw()
: initial_scroll_(40, 10), scroll_amount_(-3, 17), num_scrolls_(0) {}
- virtual void BeginTest() OVERRIDE {
+ void BeginTest() override {
Layer* root_layer = layer_tree_host()->root_layer();
scroll_layer_ = Layer::Create();
root_layer->AddChild(scroll_layer_);
PostSetNeedsCommitToMainThread();
}
- virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
switch (layer_tree_host()->source_frame_number()) {
case 0:
EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(), initial_scroll_);
break;
case 1:
- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
- initial_scroll_ + scroll_amount_ + scroll_amount_);
+ EXPECT_VECTOR_EQ(
+ scroll_layer_->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_,
+ scroll_amount_ + scroll_amount_));
case 2:
- EXPECT_VECTOR_EQ(scroll_layer_->scroll_offset(),
- initial_scroll_ + scroll_amount_ + scroll_amount_);
+ EXPECT_VECTOR_EQ(
+ scroll_layer_->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_,
+ scroll_amount_ + scroll_amount_));
break;
}
}
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
LayerImpl* scroll_layer =
impl->active_tree()->LayerById(scroll_layer_->id());
if (impl->active_tree()->source_frame_number() == 0 &&
// 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(),
- initial_scroll_ + scroll_amount_ + scroll_amount_);
+ EXPECT_VECTOR_EQ(
+ scroll_layer_->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_,
+ scroll_amount_ + scroll_amount_));
EndTest();
}
}
- virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
- float scale,
- float top_controls_delta) OVERRIDE {
+ void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+ float scale,
+ float top_controls_delta) override {
num_scrolls_++;
}
- virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
+ void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
private:
- gfx::Vector2d initial_scroll_;
- gfx::Vector2d scroll_amount_;
+ gfx::ScrollOffset initial_scroll_;
+ gfx::Vector2dF scroll_amount_;
int num_scrolls_;
scoped_refptr<Layer> scroll_layer_;
};
num_impl_commits_(0),
num_impl_scrolls_(0) {}
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
LayerTreeHostScrollTest::SetupTree();
Layer* root_layer = layer_tree_host()->root_layer();
scoped_refptr<Layer> root_scroll_layer = Layer::Create();
layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
}
- virtual void WillBeginMainFrame() OVERRIDE {
+ void WillBeginMainFrame() override {
num_will_begin_main_frames_++;
Layer* root_scroll_layer =
layer_tree_host()->root_layer()->children()[0].get();
// 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(),
- initial_scroll_ + impl_scroll_);
+ EXPECT_VECTOR_EQ(
+ root_scroll_layer->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_, impl_scroll_));
EXPECT_EQ(impl_scale_, layer_tree_host()->page_scale_factor());
PostSetNeedsRedrawToMainThread();
break;
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(),
- initial_scroll_ + impl_scroll_ + impl_scroll_);
+ EXPECT_VECTOR_EQ(
+ root_scroll_layer->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_,
+ impl_scroll_ + impl_scroll_));
EXPECT_EQ(impl_scale_ * impl_scale_,
layer_tree_host()->page_scale_factor());
- root_scroll_layer->SetScrollOffset(root_scroll_layer->scroll_offset() +
- second_main_scroll_);
+ root_scroll_layer->SetScrollOffset(gfx::ScrollOffsetWithDelta(
+ root_scroll_layer->scroll_offset(), second_main_scroll_));
break;
case 4:
// This commit will also be aborted.
EXPECT_EQ(3, num_impl_scrolls_);
EXPECT_EQ(3, layer_tree_host()->source_frame_number());
+ gfx::Vector2dF delta =
+ impl_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_;
EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
- initial_scroll_ + impl_scroll_ + impl_scroll_ +
- impl_scroll_ + second_main_scroll_);
+ gfx::ScrollOffsetWithDelta(initial_scroll_, delta));
+
// End the test by drawing to verify this commit is also aborted.
PostSetNeedsRedrawToMainThread();
break;
}
}
- virtual void DidBeginMainFrame() OVERRIDE { num_did_begin_main_frames_++; }
+ void DidBeginMainFrame() override { num_did_begin_main_frames_++; }
- virtual void WillCommit() OVERRIDE { num_will_commits_++; }
+ void WillCommit() override { num_will_commits_++; }
- virtual void DidCommit() OVERRIDE { num_did_commits_++; }
+ void DidCommit() override { num_did_commits_++; }
- virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
num_impl_commits_++;
}
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
LayerImpl* root_scroll_layer =
impl->active_tree()->root_layer()->children()[0];
EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), gfx::Vector2d());
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_ + impl_scroll_);
+ EXPECT_VECTOR_EQ(
+ root_scroll_layer->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_, impl_scroll_));
EXPECT_EQ(1.f, impl->active_tree()->page_scale_delta());
EXPECT_EQ(impl_scale_, impl->active_tree()->total_page_scale_factor());
root_scroll_layer->ScrollBy(impl_scroll_);
impl->SetNeedsCommit();
EXPECT_VECTOR_EQ(root_scroll_layer->ScrollDelta(), impl_scroll_);
- EXPECT_VECTOR_EQ(
- root_scroll_layer->scroll_offset(),
- initial_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_);
+ gfx::Vector2dF delta = impl_scroll_ + impl_scroll_ + second_main_scroll_;
+ EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_, delta));
} 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());
+ gfx::Vector2dF delta =
+ impl_scroll_ + impl_scroll_ + impl_scroll_ + second_main_scroll_;
EXPECT_VECTOR_EQ(root_scroll_layer->scroll_offset(),
- initial_scroll_ + impl_scroll_ + impl_scroll_ +
- impl_scroll_ + second_main_scroll_);
+ gfx::ScrollOffsetWithDelta(initial_scroll_, delta));
EndTest();
} else {
// Commit for source frame 3 is aborted.
}
}
- virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
- float scale,
- float top_controls_delta) OVERRIDE {
+ void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+ float scale,
+ float top_controls_delta) override {
num_impl_scrolls_++;
}
- virtual void AfterTest() OVERRIDE {
+ void AfterTest() override {
EXPECT_EQ(3, num_impl_scrolls_);
// Verify that the embedder sees aborted commits as real commits.
EXPECT_EQ(4, num_will_begin_main_frames_);
}
private:
- gfx::Vector2d initial_scroll_;
- gfx::Vector2d impl_scroll_;
- gfx::Vector2d second_main_scroll_;
+ gfx::ScrollOffset initial_scroll_;
+ gfx::Vector2dF impl_scroll_;
+ gfx::Vector2dF second_main_scroll_;
float impl_scale_;
int num_will_begin_main_frames_;
int num_did_begin_main_frames_;
public:
LayerTreeHostScrollTestFractionalScroll() : scroll_amount_(1.75, 0) {}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
LayerTreeHostScrollTest::SetupTree();
Layer* root_layer = layer_tree_host()->root_layer();
scoped_refptr<Layer> root_scroll_layer = Layer::Create();
layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
}
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
LayerImpl* root = impl->active_tree()->root_layer();
LayerImpl* scroll_layer = root->children()[0];
scroll_layer->ScrollBy(scroll_amount_);
}
- virtual void AfterTest() OVERRIDE {}
+ void AfterTest() override {}
private:
gfx::Vector2dF scroll_amount_;
scroll_amount_(2, -1),
num_scrolls_(0) {}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
layer_tree_host()->SetDeviceScaleFactor(device_scale_factor_);
scoped_refptr<Layer> root_layer = Layer::Create();
LayerTreeHostScrollTest::SetupTree();
}
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void WillCommit() OVERRIDE {
+ void WillCommit() override {
// Keep the test committing (otherwise the early out for no update
// will stall the test).
if (layer_tree_host()->source_frame_number() < 2) {
final_scroll_offset_ = expected_scroll_layer_->scroll_offset();
}
- virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
- float scale,
- float top_controls_delta) OVERRIDE {
+ void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+ float scale,
+ float top_controls_delta) override {
num_scrolls_++;
}
- virtual void Layout() OVERRIDE {
+ void Layout() override {
EXPECT_VECTOR_EQ(gfx::Vector2d(),
expected_no_scroll_layer_->scroll_offset());
expected_scroll_layer_->scroll_offset());
break;
case 1:
- EXPECT_VECTOR_EQ(initial_offset_ + scroll_amount_,
- expected_scroll_layer_->scroll_offset());
+ EXPECT_VECTOR_EQ(
+ gfx::ScrollOffsetWithDelta(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_VECTOR_EQ(gfx::ScrollOffsetWithDelta(javascript_scroll_,
+ scroll_amount_),
expected_scroll_layer_->scroll_offset());
break;
}
}
- virtual void DidActivateTreeOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DidActivateTreeOnThread(LayerTreeHostImpl* impl) override {
LayerImpl* root_impl = impl->active_tree()->root_layer();
FakePictureLayerImpl* root_scroll_layer_impl =
static_cast<FakePictureLayerImpl*>(root_impl->children()[0]);
}
case 2:
- EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
+ EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(javascript_scroll_,
+ scroll_amount_),
expected_scroll_layer_impl->scroll_offset());
EXPECT_VECTOR_EQ(gfx::Vector2d(),
expected_scroll_layer_impl->ScrollDelta());
}
}
- virtual void AfterTest() OVERRIDE {
+ void AfterTest() override {
if (scroll_child_layer_) {
EXPECT_EQ(0, num_scrolls_);
- EXPECT_VECTOR_EQ(javascript_scroll_ + scroll_amount_,
+ EXPECT_VECTOR_EQ(gfx::ScrollOffsetWithDelta(javascript_scroll_,
+ scroll_amount_),
final_scroll_offset_);
} else {
EXPECT_EQ(2, num_scrolls_);
- EXPECT_VECTOR_EQ(gfx::Vector2d(), final_scroll_offset_);
+ EXPECT_VECTOR_EQ(gfx::ScrollOffset(), final_scroll_offset_);
}
}
float device_scale_factor_;
bool scroll_child_layer_;
- gfx::Vector2d initial_offset_;
- gfx::Vector2d javascript_scroll_;
+ gfx::ScrollOffset initial_offset_;
+ gfx::ScrollOffset javascript_scroll_;
gfx::Vector2d scroll_amount_;
int num_scrolls_;
- gfx::Vector2d final_scroll_offset_;
+ gfx::ScrollOffset final_scroll_offset_;
FakeContentLayerClient fake_content_layer_client_;
class ImplSidePaintingScrollTest : public LayerTreeHostScrollTest {
public:
- virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
+ void InitializeSettings(LayerTreeSettings* settings) override {
settings->impl_side_painting = true;
}
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
if (impl->pending_tree())
impl->SetNeedsRedraw();
}
impl_thread_scroll2_(-3, 10),
num_scrolls_(0) {}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
LayerTreeHostScrollTest::SetupTree();
Layer* root_layer = layer_tree_host()->root_layer();
scoped_refptr<Layer> root_scroll_layer = Layer::Create();
layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
}
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void Layout() OVERRIDE {
+ void Layout() override {
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_);
} else {
- EXPECT_VECTOR_EQ(scroll_layer->scroll_offset(),
- initial_scroll_ + impl_thread_scroll1_);
+ EXPECT_VECTOR_EQ(
+ scroll_layer->scroll_offset(),
+ gfx::ScrollOffsetWithDelta(initial_scroll_, impl_thread_scroll1_));
// Pretend like Javascript updated the scroll position itself with a
// change of main_thread_scroll.
- scroll_layer->SetScrollOffset(initial_scroll_ + main_thread_scroll_ +
- impl_thread_scroll1_);
+ scroll_layer->SetScrollOffset(
+ gfx::ScrollOffsetWithDelta(
+ initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_));
}
}
- virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
// We force a second draw here of the first commit before activating
// the second commit.
if (impl->active_tree()->source_frame_number() == 0)
impl->SetNeedsRedraw();
}
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
LayerImpl* root = impl->active_tree()->root_layer();
LayerImpl* pending_scroll_layer = pending_root->children()[0];
EXPECT_VECTOR_EQ(
pending_scroll_layer->scroll_offset(),
- initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
+ gfx::ScrollOffsetWithDelta(
+ initial_scroll_, main_thread_scroll_ + impl_thread_scroll1_));
EXPECT_VECTOR_EQ(pending_scroll_layer->ScrollDelta(),
impl_thread_scroll2_);
EXPECT_VECTOR_EQ(pending_scroll_layer->sent_scroll_delta(),
EXPECT_FALSE(impl->pending_tree());
EXPECT_VECTOR_EQ(
scroll_layer->scroll_offset(),
- initial_scroll_ + main_thread_scroll_ + impl_thread_scroll1_);
+ gfx::ScrollOffsetWithDelta(
+ 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());
EndTest();
}
}
- virtual void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
- float scale,
- float top_controls_delta) OVERRIDE {
+ void ApplyViewportDeltas(const gfx::Vector2d& scroll_delta,
+ float scale,
+ float top_controls_delta) override {
num_scrolls_++;
}
- virtual void AfterTest() OVERRIDE { EXPECT_EQ(1, num_scrolls_); }
+ void AfterTest() override { EXPECT_EQ(1, num_scrolls_); }
private:
- gfx::Vector2d initial_scroll_;
- gfx::Vector2d main_thread_scroll_;
- gfx::Vector2d impl_thread_scroll1_;
- gfx::Vector2d impl_thread_scroll2_;
+ gfx::ScrollOffset initial_scroll_;
+ gfx::Vector2dF main_thread_scroll_;
+ gfx::Vector2dF impl_thread_scroll1_;
+ gfx::Vector2dF impl_thread_scroll2_;
int num_scrolls_;
};
ImplSidePaintingScrollTestImplOnlyScroll()
: initial_scroll_(20, 10), impl_thread_scroll_(-2, 3) {}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
LayerTreeHostScrollTest::SetupTree();
Layer* root_layer = layer_tree_host()->root_layer();
scoped_refptr<Layer> root_scroll_layer = Layer::Create();
layer_tree_host()->SetPageScaleFactorAndLimits(1.f, 0.01f, 100.f);
}
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void WillCommit() OVERRIDE {
+ void WillCommit() override {
Layer* root = layer_tree_host()->root_layer();
Layer* scroll_layer = root->children()[0].get();
switch (layer_tree_host()->source_frame_number()) {
}
}
- virtual void BeginCommitOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void BeginCommitOnThread(LayerTreeHostImpl* impl) override {
// Scroll after the 2nd commit has started.
if (impl->active_tree()->source_frame_number() == 0) {
LayerImpl* active_root = impl->active_tree()->root_layer();
}
}
- virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void CommitCompleteOnThread(LayerTreeHostImpl* impl) override {
// We force a second draw here of the first commit before activating
// the second commit.
LayerImpl* active_root = impl->active_tree()->root_layer();
case 2:
// On the next commit, this delta should have been sent and applied.
EXPECT_VECTOR_EQ(pending_scroll_layer->scroll_offset(),
- initial_scroll_ + impl_thread_scroll_);
+ gfx::ScrollOffsetWithDelta(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());
}
}
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
ImplSidePaintingScrollTest::DrawLayersOnThread(impl);
LayerImpl* root = impl->active_tree()->root_layer();
}
}
- virtual void AfterTest() OVERRIDE {}
+ void AfterTest() override {}
private:
- gfx::Vector2d initial_scroll_;
- gfx::Vector2d impl_thread_scroll_;
+ gfx::ScrollOffset initial_scroll_;
+ gfx::Vector2dF impl_thread_scroll_;
};
MULTI_THREAD_TEST_F(ImplSidePaintingScrollTestImplOnlyScroll);
public:
LayerTreeHostScrollTestScrollZeroMaxScrollOffset() {}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
LayerTreeTest::SetupTree();
scoped_refptr<Layer> scroll_layer = Layer::Create();
layer_tree_host()->root_layer()->AddChild(scroll_layer);
}
- virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
LayerImpl* root = impl->active_tree()->root_layer();
LayerImpl* scroll_layer = root->children()[0];
scroll_layer->SetScrollClipLayer(root->id());
EndTest();
}
- virtual void AfterTest() OVERRIDE {}
+ void AfterTest() override {}
};
SINGLE_AND_MULTI_THREAD_TEST_F(
bool* received_stop_flinging)
: task_runner_(runner), received_stop_flinging_(received_stop_flinging) {}
- virtual void WillShutdown() OVERRIDE {
+ void WillShutdown() override {
if (!received_stop_flinging_)
ADD_FAILURE() << "WillShutdown() called before fling stopped";
}
- virtual void Animate(base::TimeTicks time) OVERRIDE {
+ void Animate(base::TimeTicks time) override {
if (!task_runner_->BelongsToCurrentThread())
ADD_FAILURE() << "Animate called on wrong thread";
}
- virtual void MainThreadHasStoppedFlinging() OVERRIDE {
+ void MainThreadHasStoppedFlinging() override {
if (!task_runner_->BelongsToCurrentThread())
ADD_FAILURE() << "MainThreadHasStoppedFlinging called on wrong thread";
*received_stop_flinging_ = true;
}
- virtual void DidOverscroll(
- const gfx::PointF& causal_event_viewport_point,
- const gfx::Vector2dF& accumulated_overscroll,
- const gfx::Vector2dF& latest_overscroll_delta) OVERRIDE {
- if (!task_runner_->BelongsToCurrentThread())
- ADD_FAILURE() << "DidOverscroll called on wrong thread";
- }
-
private:
base::SingleThreadTaskRunner* task_runner_;
bool* received_stop_flinging_;
scoped_ptr<LayerTreeHost> layer_tree_host =
LayerTreeHost::CreateThreaded(&client,
shared_bitmap_manager.get(),
+ NULL,
settings,
base::MessageLoopProxy::current(),
impl_thread.message_loop_proxy());
base::Unretained(&input_handler_client)));
layer_tree_host->DidStopFlinging();
- layer_tree_host.reset();
+ layer_tree_host = nullptr;
impl_thread.Stop();
EXPECT_TRUE(received_stop_flinging);
}
LayerTreeHostScrollTestLayerStructureChange()
: scroll_destroy_whole_tree_(false) {}
- virtual void SetupTree() OVERRIDE {
+ void SetupTree() override {
scoped_refptr<Layer> root_layer = Layer::Create();
root_layer->SetBounds(gfx::Size(10, 10));
LayerTreeHostScrollTest::SetupTree();
}
- virtual void BeginTest() OVERRIDE {
- PostSetNeedsCommitToMainThread();
- }
+ void BeginTest() override { PostSetNeedsCommitToMainThread(); }
- virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+ void DrawLayersOnThread(LayerTreeHostImpl* impl) override {
LayerImpl* root = impl->active_tree()->root_layer();
switch (impl->active_tree()->source_frame_number()) {
case 0:
}
}
- virtual void AfterTest() OVERRIDE {}
+ void AfterTest() override {}
virtual void DidScroll(Layer* layer) {
if (scroll_destroy_whole_tree_) {
projects / platform / framework / web / crosswalk.git / blobdiff