#define EXECUTE_AND_VERIFY_SUBTREE_CHANGED(code_to_test) \
root->ResetAllChangeTrackingForSubtree(); \
code_to_test; \
+ EXPECT_TRUE(root->needs_push_properties()); \
+ EXPECT_FALSE(child->needs_push_properties()); \
+ EXPECT_FALSE(grand_child->needs_push_properties()); \
EXPECT_TRUE(root->LayerPropertyChanged()); \
EXPECT_TRUE(child->LayerPropertyChanged()); \
EXPECT_TRUE(grand_child->LayerPropertyChanged());
#define EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(code_to_test) \
root->ResetAllChangeTrackingForSubtree(); \
code_to_test; \
+ EXPECT_FALSE(root->needs_push_properties()); \
+ EXPECT_FALSE(child->needs_push_properties()); \
+ EXPECT_FALSE(grand_child->needs_push_properties()); \
+ EXPECT_FALSE(root->LayerPropertyChanged()); \
+ EXPECT_FALSE(child->LayerPropertyChanged()); \
+ EXPECT_FALSE(grand_child->LayerPropertyChanged());
+
+#define EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE( \
+ code_to_test) \
+ root->ResetAllChangeTrackingForSubtree(); \
+ code_to_test; \
+ EXPECT_TRUE(root->needs_push_properties()); \
+ EXPECT_FALSE(child->needs_push_properties()); \
+ EXPECT_FALSE(grand_child->needs_push_properties()); \
EXPECT_FALSE(root->LayerPropertyChanged()); \
EXPECT_FALSE(child->LayerPropertyChanged()); \
EXPECT_FALSE(grand_child->LayerPropertyChanged());
#define EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(code_to_test) \
root->ResetAllChangeTrackingForSubtree(); \
code_to_test; \
+ EXPECT_TRUE(root->needs_push_properties()); \
+ EXPECT_FALSE(child->needs_push_properties()); \
+ EXPECT_FALSE(grand_child->needs_push_properties()); \
EXPECT_TRUE(root->LayerPropertyChanged()); \
EXPECT_FALSE(child->LayerPropertyChanged()); \
EXPECT_FALSE(grand_child->LayerPropertyChanged());
// Create a simple LayerImpl tree:
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
- EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
- root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2));
+ EXPECT_TRUE(host_impl.InitializeRenderer(
+ FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
+ scoped_ptr<LayerImpl> root_clip =
+ LayerImpl::Create(host_impl.active_tree(), 1);
+ scoped_ptr<LayerImpl> root_ptr =
+ LayerImpl::Create(host_impl.active_tree(), 2);
+ LayerImpl* root = root_ptr.get();
+ root_clip->AddChild(root_ptr.Pass());
+ scoped_ptr<LayerImpl> scroll_parent =
+ LayerImpl::Create(host_impl.active_tree(), 3);
+ LayerImpl* scroll_child = LayerImpl::Create(host_impl.active_tree(), 4).get();
+ std::set<LayerImpl*>* scroll_children = new std::set<LayerImpl*>();
+ scroll_children->insert(scroll_child);
+ scroll_children->insert(root);
+
+ scoped_ptr<LayerImpl> clip_parent =
+ LayerImpl::Create(host_impl.active_tree(), 5);
+ LayerImpl* clip_child = LayerImpl::Create(host_impl.active_tree(), 6).get();
+ std::set<LayerImpl*>* clip_children = new std::set<LayerImpl*>();
+ clip_children->insert(clip_child);
+ clip_children->insert(root);
+
+ root->AddChild(LayerImpl::Create(host_impl.active_tree(), 7));
LayerImpl* child = root->children()[0];
- child->AddChild(LayerImpl::Create(host_impl.active_tree(), 3));
+ child->AddChild(LayerImpl::Create(host_impl.active_tree(), 8));
LayerImpl* grand_child = child->children()[0];
- root->SetScrollable(true);
+ root->SetScrollClipLayer(root_clip->id());
// Adding children is an internal operation and should not mark layers as
// changed.
arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
FilterOperations arbitrary_filters;
arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
+ SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
// These properties are internal, and should not be considered "change" when
// they are used.
- EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
- root->set_update_rect(arbitrary_rect_f));
- EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
- root->SetMaxScrollOffset(arbitrary_vector2d));
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->SetUpdateRect(arbitrary_rect_f));
+ EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(root->SetBounds(arbitrary_size));
// Changing these properties affects the entire subtree of layers.
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetAnchorPoint(arbitrary_point_f));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations()));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
- root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
+ root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 9)));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMasksToBounds(true));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetContentsOpaque(true));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
- root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
+ root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 10)));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f));
- EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPreserves3d(true));
+ EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetShouldFlattenTransform(false));
+ EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetIs3dSorted(true));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
root->SetDoubleSided(false)); // constructor initializes it to "true".
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollOffset(arbitrary_vector2d));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetHideLayerAndSubtree(true));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetOpacity(arbitrary_number));
+ EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBlendMode(arbitrary_blend_mode));
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetTransform(arbitrary_transform));
// Changing these properties only affects the layer itself.
EXECUTE_AND_VERIFY_ONLY_LAYER_CHANGED(
root->SetBackgroundFilters(arbitrary_filters));
- // Special case: check that sublayer transform changes all layer's
- // descendants, but not the layer itself.
- root->ResetAllChangeTrackingForSubtree();
- root->SetSublayerTransform(arbitrary_transform);
- EXPECT_FALSE(root->LayerPropertyChanged());
- EXPECT_TRUE(child->LayerPropertyChanged());
- EXPECT_TRUE(grand_child->LayerPropertyChanged());
-
// Special case: check that SetBounds changes behavior depending on
// masksToBounds.
root->SetMasksToBounds(false);
// changed.
EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size));
+ // Changing this property does not cause the layer to be marked as changed
+ // but does cause the layer to need to push properties.
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->SetIsRootForIsolatedGroup(true));
+
+ // Changing these properties should cause the layer to need to push properties
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->SetScrollParent(scroll_parent.get()));
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->SetScrollChildren(scroll_children));
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->RemoveScrollChild(scroll_child));
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->SetClipParent(clip_parent.get()));
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->SetClipChildren(clip_children));
+ EXECUTE_AND_VERIFY_NEEDS_PUSH_PROPERTIES_AND_SUBTREE_DID_NOT_CHANGE(
+ root->RemoveClipChild(clip_child));
+
// After setting all these properties already, setting to the exact same
// values again should not cause any change.
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetMasksToBounds(true));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
root->SetPosition(arbitrary_point_f));
- EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetPreserves3d(true));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
+ root->SetShouldFlattenTransform(false));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetIs3dSorted(true));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
root->SetTransform(arbitrary_transform));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
root->SetContentsScale(arbitrary_number, arbitrary_number));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetContentsOpaque(true));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetOpacity(arbitrary_number));
- EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
- root->SetSublayerTransform(arbitrary_transform));
+ root->SetBlendMode(arbitrary_blend_mode));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
+ root->SetIsRootForIsolatedGroup(true));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetDrawsContent(true));
EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(root->SetBounds(arbitrary_size));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
+ root->SetScrollParent(scroll_parent.get()));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
+ root->SetScrollChildren(scroll_children));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
+ root->SetClipParent(clip_parent.get()));
+ EXECUTE_AND_VERIFY_SUBTREE_DID_NOT_CHANGE(
+ root->SetClipChildren(clip_children));
}
TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
- EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
- scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
- root->SetScrollable(true);
+ EXPECT_TRUE(host_impl.InitializeRenderer(
+ FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
+ host_impl.active_tree()->SetRootLayer(
+ LayerImpl::Create(host_impl.active_tree(), 1));
+ LayerImpl* root = host_impl.active_tree()->root_layer();
+ scoped_ptr<LayerImpl> layer_ptr =
+ LayerImpl::Create(host_impl.active_tree(), 2);
+ LayerImpl* layer = layer_ptr.get();
+ root->AddChild(layer_ptr.Pass());
+ layer->SetScrollClipLayer(root->id());
+ DCHECK(host_impl.CanDraw());
gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
float arbitrary_number = 0.352f;
gfx::Size arbitrary_size = gfx::Size(111, 222);
gfx::Point arbitrary_point = gfx::Point(333, 444);
gfx::Vector2d arbitrary_vector2d = gfx::Vector2d(111, 222);
- gfx::Vector2d large_vector2d = gfx::Vector2d(1000, 1000);
+ gfx::Size large_size = gfx::Size(1000, 1000);
gfx::Rect arbitrary_rect = gfx::Rect(arbitrary_point, arbitrary_size);
gfx::RectF arbitrary_rect_f =
gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
FilterOperations arbitrary_filters;
arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
+ SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
// Related filter functions.
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(FilterOperations()));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(FilterOperations()));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
// Related scrolling functions.
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMaxScrollOffset(large_vector2d));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetMaxScrollOffset(large_vector2d));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(arbitrary_vector2d));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->ScrollBy(gfx::Vector2d()));
- root->SetScrollDelta(gfx::Vector2d(0, 0));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(large_size));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(arbitrary_vector2d));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->ScrollBy(gfx::Vector2d()));
+ layer->SetScrollDelta(gfx::Vector2d(0, 0));
host_impl.ForcePrepareToDraw();
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetScrollDelta(arbitrary_vector2d));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
+ layer->SetScrollDelta(arbitrary_vector2d));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetScrollDelta(arbitrary_vector2d));
+ layer->SetScrollDelta(arbitrary_vector2d));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetScrollOffset(arbitrary_vector2d));
+ layer->SetScrollOffset(arbitrary_vector2d));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetScrollOffset(arbitrary_vector2d));
+ layer->SetScrollOffset(arbitrary_vector2d));
// Unrelated functions, always set to new values, always set needs update.
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetAnchorPointZ(arbitrary_number));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetAnchorPointZ(arbitrary_number));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
+ layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
+ layer->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetShouldFlattenTransform(false));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetIs3dSorted(true));
+
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetDoubleSided(false)); // constructor initializes it to "true".
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentBounds(arbitrary_size));
+ layer->SetDoubleSided(false)); // constructor initializes it to "true".
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentBounds(arbitrary_size));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetContentsScale(arbitrary_number, arbitrary_number));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true));
+ layer->SetContentsScale(arbitrary_number, arbitrary_number));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetBackgroundColor(arbitrary_color));
+ layer->SetBackgroundColor(arbitrary_color));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetBackgroundFilters(arbitrary_filters));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetTransform(arbitrary_transform));
+ layer->SetBackgroundFilters(arbitrary_filters));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number));
VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetSublayerTransform(arbitrary_transform));
- VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size));
+ layer->SetBlendMode(arbitrary_blend_mode));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetTransform(arbitrary_transform));
+ VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
// Unrelated functions, set to the same values, no needs update.
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetAnchorPointZ(arbitrary_number));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetFilters(arbitrary_filters));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetMasksToBounds(true));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetContentsOpaque(true));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPosition(arbitrary_point_f));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetPreserves3d(true));
+ layer->SetAnchorPointZ(arbitrary_number));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetDoubleSided(false)); // constructor initializes it to "true".
+ layer->SetIsRootForIsolatedGroup(true));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetFilters(arbitrary_filters));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetPosition(arbitrary_point_f));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetIs3dSorted(true));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetContentBounds(arbitrary_size));
+ layer->SetDoubleSided(false)); // constructor initializes it to "true".
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetContentsScale(arbitrary_number, arbitrary_number));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetDrawsContent(true));
+ layer->SetContentBounds(arbitrary_size));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetBackgroundColor(arbitrary_color));
+ layer->SetContentsScale(arbitrary_number, arbitrary_number));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetDrawsContent(true));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetBackgroundFilters(arbitrary_filters));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetOpacity(arbitrary_number));
+ layer->SetBackgroundColor(arbitrary_color));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetTransform(arbitrary_transform));
+ layer->SetBackgroundFilters(arbitrary_filters));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetOpacity(arbitrary_number));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
+ layer->SetBlendMode(arbitrary_blend_mode));
VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
- root->SetSublayerTransform(arbitrary_transform));
- VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(root->SetBounds(arbitrary_size));
+ layer->SetIsRootForIsolatedGroup(true));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
+ layer->SetTransform(arbitrary_transform));
+ VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
}
TEST(LayerImplTest, SafeOpaqueBackgroundColor) {
FakeImplProxy proxy;
FakeLayerTreeHostImpl host_impl(&proxy);
- EXPECT_TRUE(host_impl.InitializeRenderer(CreateFakeOutputSurface()));
+ EXPECT_TRUE(host_impl.InitializeRenderer(
+ FakeOutputSurface::Create3d().PassAs<OutputSurface>()));
scoped_ptr<LayerImpl> layer = LayerImpl::Create(host_impl.active_tree(), 1);
for (int contents_opaque = 0; contents_opaque < 2; ++contents_opaque) {
LayerImplScrollTest() : host_impl_(&proxy_), root_id_(7) {
host_impl_.active_tree()
->SetRootLayer(LayerImpl::Create(host_impl_.active_tree(), root_id_));
- host_impl_.active_tree()->root_layer()->SetScrollable(true);
+ host_impl_.active_tree()->root_layer()->AddChild(
+ LayerImpl::Create(host_impl_.active_tree(), root_id_ + 1));
+ layer()->SetScrollClipLayer(root_id_);
+ // Set the max scroll offset by noting that the root layer has bounds (1,1),
+ // thus whatever bounds are set for the layer will be the max scroll
+ // offset plus 1 in each direction.
+ host_impl_.active_tree()->root_layer()->SetBounds(gfx::Size(1, 1));
+ gfx::Vector2d max_scroll_offset(51, 81);
+ layer()->SetBounds(gfx::Size(max_scroll_offset.x(), max_scroll_offset.y()));
}
- LayerImpl* layer() { return host_impl_.active_tree()->root_layer(); }
+ LayerImpl* layer() {
+ return host_impl_.active_tree()->root_layer()->children()[0];
+ }
private:
FakeImplProxy proxy_;
TEST_F(LayerImplScrollTest, ScrollByWithZeroOffset) {
// Test that LayerImpl::ScrollBy only affects ScrollDelta and total scroll
// offset is bounded by the range [0, max scroll offset].
- gfx::Vector2d max_scroll_offset(50, 80);
- layer()->SetMaxScrollOffset(max_scroll_offset);
EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->TotalScrollOffset());
EXPECT_VECTOR_EQ(gfx::Vector2dF(), layer()->scroll_offset());
}
TEST_F(LayerImplScrollTest, ScrollByWithNonZeroOffset) {
- gfx::Vector2d max_scroll_offset(50, 80);
gfx::Vector2d scroll_offset(10, 5);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
class ScrollDelegateIgnore : public LayerScrollOffsetDelegate {
public:
- virtual void SetMaxScrollOffset(gfx::Vector2dF max_scroll_offset) OVERRIDE {}
- virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) OVERRIDE {}
+ virtual void SetMaxScrollOffset(
+ const gfx::Vector2dF& max_scroll_offset) OVERRIDE {}
+ virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_value) OVERRIDE {}
virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE {
return fixed_offset_;
}
virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
- void set_fixed_offset(gfx::Vector2dF fixed_offset) {
+ void set_fixed_offset(const gfx::Vector2dF& fixed_offset) {
fixed_offset_ = fixed_offset;
}
- virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {}
- virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {}
+ virtual void SetTotalPageScaleFactorAndLimits(
+ float page_scale_factor,
+ float min_page_scale_factor,
+ float max_page_scale_factor) OVERRIDE {}
+ virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {}
private:
gfx::Vector2dF fixed_offset_;
};
TEST_F(LayerImplScrollTest, ScrollByWithIgnoringDelegate) {
- gfx::Vector2d max_scroll_offset(50, 80);
gfx::Vector2d scroll_offset(10, 5);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
class ScrollDelegateAccept : public LayerScrollOffsetDelegate {
public:
- virtual void SetMaxScrollOffset(gfx::Vector2dF max_scroll_offset) OVERRIDE {}
- virtual void SetTotalScrollOffset(gfx::Vector2dF new_value) OVERRIDE {
+ virtual void SetMaxScrollOffset(
+ const gfx::Vector2dF& max_scroll_offset) OVERRIDE {}
+ virtual void SetTotalScrollOffset(const gfx::Vector2dF& new_value) OVERRIDE {
current_offset_ = new_value;
}
virtual gfx::Vector2dF GetTotalScrollOffset() OVERRIDE {
return current_offset_;
}
virtual bool IsExternalFlingActive() const OVERRIDE { return false; }
- virtual void SetTotalPageScaleFactor(float page_scale_factor) OVERRIDE {}
- virtual void SetScrollableSize(gfx::SizeF scrollable_size) OVERRIDE {}
+ virtual void SetTotalPageScaleFactorAndLimits(
+ float page_scale_factor,
+ float min_page_scale_factor,
+ float max_page_scale_factor) OVERRIDE {}
+ virtual void SetScrollableSize(const gfx::SizeF& scrollable_size) OVERRIDE {}
private:
gfx::Vector2dF current_offset_;
};
TEST_F(LayerImplScrollTest, ScrollByWithAcceptingDelegate) {
- gfx::Vector2d max_scroll_offset(50, 80);
gfx::Vector2d scroll_offset(10, 5);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
EXPECT_VECTOR_EQ(scroll_offset, layer()->TotalScrollOffset());
}
TEST_F(LayerImplScrollTest, ApplySentScrollsNoDelegate) {
- gfx::Vector2d max_scroll_offset(50, 80);
gfx::Vector2d scroll_offset(10, 5);
gfx::Vector2dF scroll_delta(20.5f, 8.5f);
gfx::Vector2d sent_scroll_delta(12, -3);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
layer()->ScrollBy(scroll_delta);
layer()->SetSentScrollDelta(sent_scroll_delta);
}
TEST_F(LayerImplScrollTest, ApplySentScrollsWithIgnoringDelegate) {
- gfx::Vector2d max_scroll_offset(50, 80);
gfx::Vector2d scroll_offset(10, 5);
gfx::Vector2d sent_scroll_delta(12, -3);
gfx::Vector2dF fixed_offset(32, 12);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
ScrollDelegateIgnore delegate;
delegate.set_fixed_offset(fixed_offset);
}
TEST_F(LayerImplScrollTest, ApplySentScrollsWithAcceptingDelegate) {
- gfx::Vector2d max_scroll_offset(50, 80);
gfx::Vector2d scroll_offset(10, 5);
gfx::Vector2d sent_scroll_delta(12, -3);
gfx::Vector2dF scroll_delta(20.5f, 8.5f);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
ScrollDelegateAccept delegate;
layer()->SetScrollOffsetDelegate(&delegate);
EXPECT_VECTOR_EQ(gfx::Vector2d(), layer()->sent_scroll_delta());
}
-TEST_F(LayerImplScrollTest, ScrollUserUnscrollableLayer) {
- gfx::Vector2d max_scroll_offset(50, 80);
+// The user-scrollability breaks for zoomed-in pages. So disable this.
+// http://crbug.com/322223
+TEST_F(LayerImplScrollTest, DISABLED_ScrollUserUnscrollableLayer) {
gfx::Vector2d scroll_offset(10, 5);
gfx::Vector2dF scroll_delta(20.5f, 8.5f);
layer()->set_user_scrollable_vertical(false);
- layer()->SetMaxScrollOffset(max_scroll_offset);
layer()->SetScrollOffset(scroll_offset);
gfx::Vector2dF unscrolled = layer()->ScrollBy(scroll_delta);
projects / platform / framework / web / crosswalk.git / blobdiff