diff --git a/cc/debug/debug_rect_history.cc b/cc/debug/debug_rect_history.cc index b936e8736c4689..ed7c611fc4cccc 100644 --- a/cc/debug/debug_rect_history.cc +++ b/cc/debug/debug_rect_history.cc @@ -147,7 +147,7 @@ void DebugRectHistory::SaveScreenSpaceRects( render_surface->screen_space_transform(), render_surface->content_rect()))); - if (render_surface_layer->replica_layer()) { + if (render_surface->HasReplica()) { debug_rects_.push_back( DebugRect(REPLICA_SCREEN_SPACE_RECT_TYPE, MathUtil::MapEnclosingClippedRect( diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc index 14d72ca3b735fb..900ee29e5747f3 100644 --- a/cc/layers/layer_impl.cc +++ b/cc/layers/layer_impl.cc @@ -45,10 +45,6 @@ namespace cc { LayerImpl::LayerImpl(LayerTreeImpl* tree_impl, int id) : parent_(nullptr), - mask_layer_id_(-1), - mask_layer_(nullptr), - replica_layer_id_(-1), - replica_layer_(nullptr), layer_id_(id), layer_tree_impl_(tree_impl), test_properties_(nullptr), @@ -103,12 +99,6 @@ LayerImpl::~LayerImpl() { TRACE_EVENT_OBJECT_DELETED_WITH_ID( TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerImpl", this); - - // The mask and replica layers should have been removed already. - if (mask_layer_) - DCHECK(!layer_tree_impl_->RemoveLayer(mask_layer_id_)); - if (replica_layer_) - DCHECK(!layer_tree_impl_->RemoveLayer(replica_layer_id_)); } void LayerImpl::AddChild(std::unique_ptr child) { @@ -131,11 +121,6 @@ void LayerImpl::SetParent(LayerImpl* parent) { parent_ = parent; } -void LayerImpl::ClearLinksToOtherLayers() { - mask_layer_ = nullptr; - replica_layer_ = nullptr; -} - void LayerImpl::SetHasWillChangeTransformHint(bool has_will_change) { if (has_will_change_transform_hint_ == has_will_change) return; @@ -525,14 +510,6 @@ void LayerImpl::ResetChangeTracking() { if (render_surface_) render_surface_->ResetPropertyChangedFlag(); - - if (mask_layer_) - mask_layer_->ResetChangeTracking(); - - if (replica_layer_) { - // This also resets the replica mask, if it exists. - replica_layer_->ResetChangeTracking(); - } } int LayerImpl::num_copy_requests_in_target_subtree() { @@ -793,65 +770,6 @@ void LayerImpl::SetBoundsDelta(const gfx::Vector2dF& bounds_delta) { } } -void LayerImpl::SetMaskLayer(std::unique_ptr mask_layer) { - int new_layer_id = mask_layer ? mask_layer->id() : -1; - - if (mask_layer) { - DCHECK_EQ(layer_tree_impl(), mask_layer->layer_tree_impl()); - DCHECK_NE(new_layer_id, mask_layer_id_); - } else if (new_layer_id == mask_layer_id_) { - return; - } - - if (mask_layer_) - layer_tree_impl_->RemoveLayer(mask_layer_->id()); - mask_layer_ = mask_layer.get(); - if (mask_layer_) - layer_tree_impl_->AddLayer(std::move(mask_layer)); - - mask_layer_id_ = new_layer_id; -} - -std::unique_ptr LayerImpl::TakeMaskLayer() { - mask_layer_id_ = -1; - std::unique_ptr ret; - if (mask_layer_) - ret = layer_tree_impl_->RemoveLayer(mask_layer_->id()); - mask_layer_ = nullptr; - return ret; -} - -void LayerImpl::SetReplicaLayer(std::unique_ptr replica_layer) { - int new_layer_id = replica_layer ? replica_layer->id() : -1; - - if (replica_layer) { - DCHECK_EQ(layer_tree_impl(), replica_layer->layer_tree_impl()); - DCHECK_NE(new_layer_id, replica_layer_id_); - } else if (new_layer_id == replica_layer_id_) { - return; - } - - if (replica_layer_) - layer_tree_impl_->RemoveLayer(replica_layer_->id()); - replica_layer_ = replica_layer.get(); - if (replica_layer_) - layer_tree_impl_->AddLayer(std::move(replica_layer)); - - replica_layer_id_ = new_layer_id; -} - -std::unique_ptr LayerImpl::TakeReplicaLayerForTesting() { - replica_layer_id_ = -1; - std::unique_ptr ret; - if (replica_layer_) { - if (replica_layer_->mask_layer()) - replica_layer_->SetMaskLayer(nullptr); - ret = layer_tree_impl_->RemoveLayer(replica_layer_->id()); - } - replica_layer_ = nullptr; - return ret; -} - ScrollbarLayerImplBase* LayerImpl::ToScrollbarLayer() { return nullptr; } @@ -1169,16 +1087,6 @@ void LayerImpl::AsValueInto(base::trace_event::TracedValue* state) const { non_fast_scrollable_region_.AsValueInto(state); state->EndArray(); } - if (mask_layer_) { - state->BeginDictionary("mask_layer"); - mask_layer_->AsValueInto(state); - state->EndDictionary(); - } - if (replica_layer_) { - state->BeginDictionary("replica_layer"); - replica_layer_->AsValueInto(state); - state->EndDictionary(); - } state->SetBoolean("can_use_lcd_text", CanUseLCDText()); state->SetBoolean("contents_opaque", contents_opaque()); @@ -1334,9 +1242,7 @@ bool LayerImpl::InsideReplica() const { EffectNode* node = effect_tree.Node(effect_tree_index_); while (node->id > 0) { - LayerImpl* target_layer = layer_tree_impl()->LayerById(node->owner_id); - DCHECK(target_layer); - if (target_layer->has_replica()) + if (node->data.replica_layer_id != -1) return true; node = effect_tree.Node(node->data.target_id); } diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h index b0aaa159cbb36b..0c3975d353afe6 100644 --- a/cc/layers/layer_impl.h +++ b/cc/layers/layer_impl.h @@ -150,22 +150,6 @@ class CC_EXPORT LayerImpl { // For compatibility with Layer. bool has_render_surface() const { return !!render_surface(); } - void SetMaskLayer(std::unique_ptr mask_layer); - LayerImpl* mask_layer() { return mask_layer_; } - const LayerImpl* mask_layer() const { return mask_layer_; } - std::unique_ptr TakeMaskLayer(); - - void SetReplicaLayer(std::unique_ptr replica_layer); - LayerImpl* replica_layer() { return replica_layer_; } - const LayerImpl* replica_layer() const { return replica_layer_; } - std::unique_ptr TakeReplicaLayerForTesting(); - - bool has_mask() const { return !!mask_layer_; } - bool has_replica() const { return !!replica_layer_; } - bool replica_has_mask() const { - return replica_layer_ && (mask_layer_ || replica_layer_->mask_layer_); - } - LayerTreeImpl* layer_tree_impl() const { return layer_tree_impl_; } void PopulateSharedQuadState(SharedQuadState* state) const; @@ -202,7 +186,7 @@ class CC_EXPORT LayerImpl { LayerImplTestProperties* test_properties() { if (!test_properties_) - test_properties_.reset(new LayerImplTestProperties()); + test_properties_.reset(new LayerImplTestProperties(this)); return test_properties_.get(); } @@ -500,8 +484,6 @@ class CC_EXPORT LayerImpl { void NoteLayerPropertyChanged(); - void ClearLinksToOtherLayers(); - void SetHasWillChangeTransformHint(bool has_will_change); bool has_will_change_transform_hint() const { return has_will_change_transform_hint_; @@ -537,12 +519,6 @@ class CC_EXPORT LayerImpl { // Properties internal to LayerImpl LayerImpl* parent_; - // mask_layer_ can be temporarily stolen during tree sync, we need this ID to - // confirm newly assigned layer is still the previous one - int mask_layer_id_; - LayerImpl* mask_layer_; - int replica_layer_id_; // ditto - LayerImpl* replica_layer_; int layer_id_; LayerTreeImpl* layer_tree_impl_; diff --git a/cc/layers/layer_impl_test_properties.cc b/cc/layers/layer_impl_test_properties.cc index d4b946a46e2f91..631272d7f95e87 100644 --- a/cc/layers/layer_impl_test_properties.cc +++ b/cc/layers/layer_impl_test_properties.cc @@ -4,12 +4,15 @@ #include "cc/layers/layer_impl_test_properties.h" +#include "cc/layers/layer_impl.h" #include "cc/output/copy_output_request.h" +#include "cc/trees/layer_tree_impl.h" namespace cc { -LayerImplTestProperties::LayerImplTestProperties() - : double_sided(true), +LayerImplTestProperties::LayerImplTestProperties(LayerImpl* owning_layer) + : owning_layer(owning_layer), + double_sided(true), force_render_surface(false), is_container_for_fixed_position_layers(false), should_flatten_transform(true), @@ -19,8 +22,31 @@ LayerImplTestProperties::LayerImplTestProperties() num_unclipped_descendants(0), opacity(1.f), scroll_parent(nullptr), - clip_parent(nullptr) {} + clip_parent(nullptr), + mask_layer(nullptr), + replica_layer(nullptr) {} LayerImplTestProperties::~LayerImplTestProperties() {} +void LayerImplTestProperties::SetMaskLayer(std::unique_ptr mask) { + if (mask_layer) + owning_layer->layer_tree_impl()->RemoveLayer(mask_layer->id()); + mask_layer = mask.get(); + if (mask) + owning_layer->layer_tree_impl()->AddLayer(std::move(mask)); +} + +void LayerImplTestProperties::SetReplicaLayer( + std::unique_ptr replica) { + if (replica_layer) { + replica_layer->test_properties()->SetMaskLayer(nullptr); + owning_layer->layer_tree_impl()->RemoveLayer(replica_layer->id()); + } + replica_layer = replica.get(); + if (replica) { + replica->SetParent(owning_layer); + owning_layer->layer_tree_impl()->AddLayer(std::move(replica)); + } +} + } // namespace cc diff --git a/cc/layers/layer_impl_test_properties.h b/cc/layers/layer_impl_test_properties.h index 8a5f44cf416051..1047e20b0b0595 100644 --- a/cc/layers/layer_impl_test_properties.h +++ b/cc/layers/layer_impl_test_properties.h @@ -19,9 +19,13 @@ class CopyOutputRequest; class LayerImpl; struct CC_EXPORT LayerImplTestProperties { - LayerImplTestProperties(); + explicit LayerImplTestProperties(LayerImpl* owning_layer); ~LayerImplTestProperties(); + void SetMaskLayer(std::unique_ptr mask); + void SetReplicaLayer(std::unique_ptr replica); + + LayerImpl* owning_layer; bool double_sided; bool force_render_surface; bool is_container_for_fixed_position_layers; @@ -39,6 +43,8 @@ struct CC_EXPORT LayerImplTestProperties { std::unique_ptr> clip_children; std::vector> copy_requests; LayerImplList children; + LayerImpl* mask_layer; + LayerImpl* replica_layer; }; } // namespace cc diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc index 5c9b7cbd26b044..a8a51505fa8771 100644 --- a/cc/layers/layer_impl_unittest.cc +++ b/cc/layers/layer_impl_unittest.cc @@ -300,17 +300,11 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) { gfx::ScrollOffset(arbitrary_vector2d.x(), arbitrary_vector2d.y()))); // Unrelated functions, always set to new values, always set needs update. - VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( - layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)); - layer->NoteLayerPropertyChanged()); host_impl.active_tree()->BuildLayerListAndPropertyTreesForTesting(); VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetMasksToBounds(true); layer->NoteLayerPropertyChanged()); VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetContentsOpaque(true); layer->NoteLayerPropertyChanged()); - VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES( - layer->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5)); - layer->NoteLayerPropertyChanged()); VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer2->SetPosition(arbitrary_point_f); layer->NoteLayerPropertyChanged()); VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->Set3dSortingContextId(1); diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc index 8351fc64261d09..61ac6bb99b8dd4 100644 --- a/cc/layers/picture_layer_impl_unittest.cc +++ b/cc/layers/picture_layer_impl_unittest.cc @@ -1144,13 +1144,13 @@ TEST_F(PictureLayerImplTest, DontAddLowResForSmallLayers) { host_impl()->pending_tree(), 3, pending_raster_source); mask->SetBounds(layer_bounds); mask->SetDrawsContent(true); - pending_layer()->SetMaskLayer(std::move(mask)); + pending_layer()->test_properties()->SetMaskLayer(std::move(mask)); pending_layer()->SetHasRenderSurface(true); RebuildPropertyTreesOnPendingTree(); host_impl()->pending_tree()->UpdateDrawProperties(false); - FakePictureLayerImpl* mask_raw = - static_cast(pending_layer()->mask_layer()); + FakePictureLayerImpl* mask_raw = static_cast( + pending_layer()->test_properties()->mask_layer); // We did an UpdateDrawProperties above, which will set a contents scale on // the mask layer, so allow us to reset the contents scale. mask_raw->ReleaseResources(); @@ -1177,7 +1177,7 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) { host_impl()->pending_tree(), 3, valid_raster_source); mask_ptr->SetBounds(layer_bounds); mask_ptr->SetDrawsContent(true); - pending_layer()->SetMaskLayer(std::move(mask_ptr)); + pending_layer()->test_properties()->SetMaskLayer(std::move(mask_ptr)); pending_layer()->test_properties()->force_render_surface = true; RebuildPropertyTreesOnPendingTree(); @@ -1185,8 +1185,8 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) { bool update_lcd_text = false; host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text); - FakePictureLayerImpl* pending_mask = - static_cast(pending_layer()->mask_layer()); + FakePictureLayerImpl* pending_mask = static_cast( + pending_layer()->test_properties()->mask_layer); EXPECT_EQ(1.f, pending_mask->HighResTiling()->contents_scale()); EXPECT_EQ(1u, pending_mask->num_tilings()); @@ -1196,8 +1196,8 @@ TEST_F(PictureLayerImplTest, HugeMasksGetScaledDown) { ActivateTree(); - FakePictureLayerImpl* active_mask = - static_cast(active_layer()->mask_layer()); + FakePictureLayerImpl* active_mask = static_cast( + host_impl()->active_tree()->LayerById(pending_mask->id())); // Mask layers have a tiling with a single tile in it. EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size()); @@ -1307,7 +1307,7 @@ TEST_F(PictureLayerImplTest, ScaledMaskLayer) { host_impl()->pending_tree(), 3, valid_raster_source); mask_ptr->SetBounds(layer_bounds); mask_ptr->SetDrawsContent(true); - pending_layer()->SetMaskLayer(std::move(mask_ptr)); + pending_layer()->test_properties()->SetMaskLayer(std::move(mask_ptr)); pending_layer()->test_properties()->force_render_surface = true; RebuildPropertyTreesOnPendingTree(); @@ -1315,8 +1315,8 @@ TEST_F(PictureLayerImplTest, ScaledMaskLayer) { bool update_lcd_text = false; host_impl()->pending_tree()->UpdateDrawProperties(update_lcd_text); - FakePictureLayerImpl* pending_mask = - static_cast(pending_layer()->mask_layer()); + FakePictureLayerImpl* pending_mask = static_cast( + pending_layer()->test_properties()->mask_layer); // Masks are scaled, and do not have a low res tiling. EXPECT_EQ(1.3f, pending_mask->HighResTiling()->contents_scale()); @@ -1327,8 +1327,8 @@ TEST_F(PictureLayerImplTest, ScaledMaskLayer) { ActivateTree(); - FakePictureLayerImpl* active_mask = - static_cast(active_layer()->mask_layer()); + FakePictureLayerImpl* active_mask = static_cast( + host_impl()->active_tree()->LayerById(pending_mask->id())); // Mask layers have a tiling with a single tile in it. EXPECT_EQ(1u, active_mask->HighResTiling()->AllTilesForTesting().size()); diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc index 0711d5462eba80..f03d3cc434837b 100644 --- a/cc/layers/render_surface_impl.cc +++ b/cc/layers/render_surface_impl.cc @@ -83,7 +83,7 @@ gfx::RectF RenderSurfaceImpl::DrawableContentRect() const { } gfx::RectF drawable_content_rect = MathUtil::MapClippedRect( draw_transform(), gfx::RectF(surface_content_rect)); - if (owning_layer_->has_replica()) { + if (HasReplica()) { drawable_content_rect.Union(MathUtil::MapClippedRect( replica_draw_transform(), gfx::RectF(surface_content_rect))); } else if (!owning_layer_->filters().IsEmpty() && is_clipped()) { @@ -124,18 +124,39 @@ int RenderSurfaceImpl::OwningLayerId() const { } bool RenderSurfaceImpl::HasReplica() const { - return owning_layer_->has_replica(); + return OwningEffectNode()->data.replica_layer_id != -1; } const LayerImpl* RenderSurfaceImpl::ReplicaLayer() const { - return owning_layer_->replica_layer(); + int replica_layer_id = OwningEffectNode()->data.replica_layer_id; + return owning_layer_->layer_tree_impl()->LayerById(replica_layer_id); +} + +LayerImpl* RenderSurfaceImpl::ReplicaLayer() { + int replica_layer_id = OwningEffectNode()->data.replica_layer_id; + return owning_layer_->layer_tree_impl()->LayerById(replica_layer_id); +} + +LayerImpl* RenderSurfaceImpl::MaskLayer() { + int mask_layer_id = OwningEffectNode()->data.mask_layer_id; + return owning_layer_->layer_tree_impl()->LayerById(mask_layer_id); +} + +bool RenderSurfaceImpl::HasMask() const { + return OwningEffectNode()->data.mask_layer_id != -1; +} + +LayerImpl* RenderSurfaceImpl::ReplicaMaskLayer() { + int replica_mask_layer_id = OwningEffectNode()->data.replica_mask_layer_id; + return owning_layer_->layer_tree_impl()->LayerById(replica_mask_layer_id); +} + +bool RenderSurfaceImpl::HasReplicaMask() const { + return OwningEffectNode()->data.replica_mask_layer_id != -1; } bool RenderSurfaceImpl::HasCopyRequest() const { - return owning_layer_->layer_tree_impl() - ->property_trees() - ->effect_tree.Node(EffectTreeIndex()) - ->data.has_copy_request; + return OwningEffectNode()->data.has_copy_request; } int RenderSurfaceImpl::TransformTreeIndex() const { @@ -150,6 +171,11 @@ int RenderSurfaceImpl::EffectTreeIndex() const { return owning_layer_->effect_tree_index(); } +const EffectNode* RenderSurfaceImpl::OwningEffectNode() const { + return owning_layer_->layer_tree_impl()->property_trees()->effect_tree.Node( + EffectTreeIndex()); +} + void RenderSurfaceImpl::SetClipRect(const gfx::Rect& clip_rect) { if (clip_rect == draw_properties_.clip_rect) return; @@ -171,7 +197,7 @@ void RenderSurfaceImpl::SetContentRectForTesting(const gfx::Rect& rect) { } gfx::Rect RenderSurfaceImpl::CalculateClippedAccumulatedContentRect() { - if (owning_layer_->replica_layer() || HasCopyRequest() || !is_clipped()) + if (ReplicaLayer() || HasCopyRequest() || !is_clipped()) return accumulated_content_rect(); if (accumulated_content_rect().IsEmpty()) diff --git a/cc/layers/render_surface_impl.h b/cc/layers/render_surface_impl.h index eafa789238f45c..707512299e176e 100644 --- a/cc/layers/render_surface_impl.h +++ b/cc/layers/render_surface_impl.h @@ -17,6 +17,7 @@ #include "cc/quads/render_pass.h" #include "cc/quads/shared_quad_state.h" #include "cc/trees/occlusion.h" +#include "cc/trees/property_tree.h" #include "ui/gfx/geometry/rect.h" #include "ui/gfx/geometry/rect_f.h" #include "ui/gfx/transform.h" @@ -141,6 +142,13 @@ class CC_EXPORT RenderSurfaceImpl { int OwningLayerId() const; bool HasReplica() const; const LayerImpl* ReplicaLayer() const; + LayerImpl* ReplicaLayer(); + + LayerImpl* MaskLayer(); + bool HasMask() const; + + LayerImpl* ReplicaMaskLayer(); + bool HasReplicaMask() const; bool HasCopyRequest() const; @@ -170,6 +178,8 @@ class CC_EXPORT RenderSurfaceImpl { void SetContentRect(const gfx::Rect& content_rect); gfx::Rect CalculateClippedAccumulatedContentRect(); + const EffectNode* OwningEffectNode() const; + LayerImpl* owning_layer_; // Container for properties that render surfaces need to compute before they diff --git a/cc/layers/render_surface_impl_unittest.cc b/cc/layers/render_surface_impl_unittest.cc index 40027f64ba097b..8d4b654cbd0dda 100644 --- a/cc/layers/render_surface_impl_unittest.cc +++ b/cc/layers/render_surface_impl_unittest.cc @@ -81,10 +81,10 @@ TEST(RenderSurfaceLayerImplTest, AppendQuadsWithScaledMask) { scale.Scale(2, 2); surface->SetTransform(scale); - surface->SetMaskLayer( + surface->test_properties()->SetMaskLayer( FakeMaskLayerImpl::Create(impl.host_impl()->active_tree(), 4)); - surface->mask_layer()->SetDrawsContent(true); - surface->mask_layer()->SetBounds(layer_size); + surface->test_properties()->mask_layer->SetDrawsContent(true); + surface->test_properties()->mask_layer->SetBounds(layer_size); std::unique_ptr child = LayerImpl::Create(impl.host_impl()->active_tree(), 5); @@ -109,7 +109,7 @@ TEST(RenderSurfaceLayerImplTest, AppendQuadsWithScaledMask) { AppendQuadsData append_quads_data; render_surface_impl->AppendQuads( render_pass.get(), render_surface_impl->draw_transform(), Occlusion(), - SK_ColorBLACK, 1.f, surface_raw->mask_layer(), &append_quads_data, + SK_ColorBLACK, 1.f, render_surface_impl->MaskLayer(), &append_quads_data, RenderPassId(1, 1)); const RenderPassDrawQuad* quad = diff --git a/cc/proto/property_tree.proto b/cc/proto/property_tree.proto index 38cd5a94609860..889068e65a4dd7 100644 --- a/cc/proto/property_tree.proto +++ b/cc/proto/property_tree.proto @@ -89,7 +89,7 @@ message ClipNodeData { } // Proto for struct EffectNodeData. -// NEXT ID: 17 +// NEXT ID: 20 message EffectNodeData { optional float opacity = 1; optional float screen_space_opacity = 2; @@ -107,6 +107,9 @@ message EffectNodeData { optional int64 transform_id = 9; optional int64 clip_id = 10; optional int64 target_id = 12; + optional int64 mask_layer_id = 17; + optional int64 replica_layer_id = 18; + optional int64 replica_mask_layer_id = 19; } // Proto for struct ScrollNodeData @@ -166,6 +169,7 @@ message PropertyTree { // of this property tree. optional TransformTreeData transform_tree_data = 1000; optional ScrollTreeData scroll_tree_data = 1001; + optional EffectTreeData effect_tree_data = 1002; } message ScrollOffsetMapEntry { @@ -192,6 +196,11 @@ message TransformTreeData { repeated TransformCachedNodeData cached_data = 9; } +// Proto for data members of class EffectTree. +message EffectTreeData { + repeated int64 mask_replica_layer_ids = 1 [packed = true]; +} + // Proto for class PropertyTrees. // NEXT ID: 16 message PropertyTrees { diff --git a/cc/test/layer_test_common.h b/cc/test/layer_test_common.h index 71ce5084458245..8cf0d4188e7289 100644 --- a/cc/test/layer_test_common.h +++ b/cc/test/layer_test_common.h @@ -79,7 +79,7 @@ class LayerTestCommon { std::unique_ptr layer = T::Create(host_->host_impl()->active_tree(), layer_impl_id_++); T* ptr = layer.get(); - origin->SetReplicaLayer(std::move(layer)); + origin->test_properties()->SetReplicaLayer(std::move(layer)); return ptr; } diff --git a/cc/trees/damage_tracker.cc b/cc/trees/damage_tracker.cc index c861025f1ee3bc..73e60f584ebff5 100644 --- a/cc/trees/damage_tracker.cc +++ b/cc/trees/damage_tracker.cc @@ -390,7 +390,7 @@ void DamageTracker::ExtendDamageForRenderSurface( draw_transform, damage_rect_in_local_space); target_damage_rect->Union(damage_rect_in_target_space); - if (layer->replica_layer()) { + if (render_surface->HasReplica()) { const gfx::Transform& replica_draw_transform = render_surface->replica_draw_transform(); target_damage_rect->Union(MathUtil::MapEnclosingClippedRect( @@ -401,8 +401,8 @@ void DamageTracker::ExtendDamageForRenderSurface( // If there was damage on the replica's mask, then the target surface receives // that damage as well. - if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { - LayerImpl* replica_mask_layer = layer->replica_layer()->mask_layer(); + if (render_surface->HasReplicaMask()) { + LayerImpl* replica_mask_layer = render_surface->ReplicaMaskLayer(); bool replica_is_new = false; LayerRectMapData& data = diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc index f4599e3b9474d4..879db0084039b5 100644 --- a/cc/trees/damage_tracker_unittest.cc +++ b/cc/trees/damage_tracker_unittest.cc @@ -68,7 +68,7 @@ void EmulateDrawingOneFrame(LayerImpl* root) { target_surface->layer_list(), target_surface, target_surface->SurfacePropertyChangedOnlyFromDescendant(), target_surface->content_rect(), - render_surface_layer_list[index]->mask_layer(), + render_surface_layer_list[index]->render_surface()->MaskLayer(), render_surface_layer_list[index]->filters()); } @@ -1199,7 +1199,8 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplica) { gfx::Transform reflection; reflection.Scale3d(-1.0, 1.0, 1.0); grand_child1_replica->SetTransform(reflection); - grand_child1->SetReplicaLayer(std::move(grand_child1_replica)); + grand_child1->test_properties()->SetReplicaLayer( + std::move(grand_child1_replica)); grand_child1->test_properties()->force_render_surface = true; grand_child1->NoteLayerPropertyChanged(); } @@ -1254,7 +1255,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplica) { // CASE 3: removing the reflection should cause the entire region including // reflection to damage the target surface. ClearDamageForAllSurfaces(root); - grand_child1->SetReplicaLayer(nullptr); + grand_child1->test_properties()->SetReplicaLayer(nullptr); grand_child1->test_properties()->force_render_surface = false; grand_child1->NoteLayerPropertyChanged(); root->layer_tree_impl()->property_trees()->needs_rebuild = true; @@ -1290,10 +1291,10 @@ TEST_F(DamageTrackerTest, VerifyDamageForMask) { LayerImpl::Create(host_impl_.active_tree(), 3); mask_layer->SetPosition(child->position()); mask_layer->SetBounds(child->bounds()); - child->SetMaskLayer(std::move(mask_layer)); + child->test_properties()->SetMaskLayer(std::move(mask_layer)); child->test_properties()->force_render_surface = true; } - LayerImpl* mask_layer = child->mask_layer(); + LayerImpl* mask_layer = child->test_properties()->mask_layer; // Add opacity and a grand_child so that the render surface persists even // after we remove the mask. @@ -1354,7 +1355,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForMask) { // Then test mask removal. ClearDamageForAllSurfaces(root); - child->SetMaskLayer(nullptr); + child->test_properties()->SetMaskLayer(nullptr); child->NoteLayerPropertyChanged(); ASSERT_TRUE(child->LayerPropertyChanged()); root->layer_tree_impl()->property_trees()->needs_rebuild = true; @@ -1386,10 +1387,12 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) { gfx::Transform reflection; reflection.Scale3d(-1.0, 1.0, 1.0); grand_child1_replica->SetTransform(reflection); - grand_child1->SetReplicaLayer(std::move(grand_child1_replica)); + grand_child1->test_properties()->SetReplicaLayer( + std::move(grand_child1_replica)); grand_child1->test_properties()->force_render_surface = true; } - LayerImpl* grand_child1_replica = grand_child1->replica_layer(); + LayerImpl* grand_child1_replica = + grand_child1->test_properties()->replica_layer; // Set up the mask layer on the replica layer { @@ -1397,9 +1400,11 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) { LayerImpl::Create(host_impl_.active_tree(), 7); replica_mask_layer->SetPosition(gfx::PointF()); replica_mask_layer->SetBounds(grand_child1->bounds()); - grand_child1_replica->SetMaskLayer(std::move(replica_mask_layer)); + grand_child1_replica->test_properties()->SetMaskLayer( + std::move(replica_mask_layer)); } - LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer(); + LayerImpl* replica_mask_layer = + grand_child1_replica->test_properties()->mask_layer; root->layer_tree_impl()->property_trees()->needs_rebuild = true; EmulateDrawingOneFrame(root); @@ -1426,7 +1431,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMask) { // target surface. // ClearDamageForAllSurfaces(root); - grand_child1_replica->SetMaskLayer(nullptr); + grand_child1_replica->test_properties()->SetMaskLayer(nullptr); root->layer_tree_impl()->property_trees()->needs_rebuild = true; EmulateDrawingOneFrame(root); @@ -1468,10 +1473,12 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithTransformOrigin) { grand_child1_replica->SetTransform(reflection); // We need to set parent on replica layer for property tree building. grand_child1_replica->SetParent(grand_child1); - grand_child1->SetReplicaLayer(std::move(grand_child1_replica)); + grand_child1->test_properties()->SetReplicaLayer( + std::move(grand_child1_replica)); grand_child1->test_properties()->force_render_surface = true; } - LayerImpl* grand_child1_replica = grand_child1->replica_layer(); + LayerImpl* grand_child1_replica = + grand_child1->test_properties()->replica_layer; // Set up the mask layer on the replica layer { @@ -1480,9 +1487,11 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplicaMaskWithTransformOrigin) { replica_mask_layer->SetPosition(gfx::PointF()); // Note: this is not the transform origin being tested. replica_mask_layer->SetBounds(grand_child1->bounds()); - grand_child1_replica->SetMaskLayer(std::move(replica_mask_layer)); + grand_child1_replica->test_properties()->SetMaskLayer( + std::move(replica_mask_layer)); } - LayerImpl* replica_mask_layer = grand_child1_replica->mask_layer(); + LayerImpl* replica_mask_layer = + grand_child1_replica->test_properties()->mask_layer; root->layer_tree_impl()->property_trees()->needs_rebuild = true; EmulateDrawingOneFrame(root); diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc index 24ac33a066a47b..6881a25cc1a3f3 100644 --- a/cc/trees/draw_property_utils.cc +++ b/cc/trees/draw_property_utils.cc @@ -33,13 +33,6 @@ static bool IsRootLayer(const LayerImpl* layer) { } #if DCHECK_IS_ON() -static LayerImpl* EffectNodeOwner(LayerImpl* layer) { - EffectNode* node = - layer->layer_tree_impl()->property_trees()->effect_tree.Node( - layer->effect_tree_index()); - return layer->layer_tree_impl()->LayerById(node->owner_id); -} - static void ValidateRenderSurfaceForLayer(LayerImpl* layer) { // This test verifies that there are no cases where a LayerImpl needs // a render surface, but doesn't have one. @@ -49,10 +42,13 @@ static void ValidateRenderSurfaceForLayer(LayerImpl* layer) { DCHECK(layer->filters().IsEmpty()) << "layer: " << layer->id(); DCHECK(layer->background_filters().IsEmpty()) << "layer: " << layer->id(); DCHECK(!IsRootLayer(layer)) << "layer: " << layer->id(); - if (EffectNodeOwner(layer)->replica_layer() == layer) + EffectNode* effect_node = + layer->layer_tree_impl()->property_trees()->effect_tree.Node( + layer->effect_tree_index()); + if (effect_node->owner_id != layer->id()) return; - DCHECK(!layer->mask_layer()) << "layer: " << layer->id(); - DCHECK(!layer->replica_layer()) << "layer: " << layer->id(); + DCHECK_EQ(effect_node->data.mask_layer_id, -1) << "layer: " << layer->id(); + DCHECK_EQ(effect_node->data.replica_layer_id, -1) << "layer: " << layer->id(); } #endif diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc index 7cd8974bf0c2d5..71d8e6be0a6626 100644 --- a/cc/trees/layer_tree_host_common.cc +++ b/cc/trees/layer_tree_host_common.cc @@ -186,32 +186,29 @@ void ScrollAndScaleSet::FromProtobuf(const proto::ScrollAndScaleSet& proto) { } static inline void SetMaskLayersAreDrawnRenderSurfaceLayerListMembers( - LayerImpl* layer, + RenderSurfaceImpl* surface, PropertyTrees* property_trees) { - if (layer->mask_layer()) { - layer->mask_layer()->set_is_drawn_render_surface_layer_list_member(true); - draw_property_utils::ComputeMaskDrawProperties(layer->mask_layer(), - property_trees); + LayerImpl* mask_layer = surface->MaskLayer(); + LayerImpl* replica_mask_layer = surface->ReplicaMaskLayer(); + if (mask_layer) { + mask_layer->set_is_drawn_render_surface_layer_list_member(true); + draw_property_utils::ComputeMaskDrawProperties(mask_layer, property_trees); } - if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { - layer->replica_layer() - ->mask_layer() - ->set_is_drawn_render_surface_layer_list_member(true); - draw_property_utils::ComputeMaskDrawProperties( - layer->replica_layer()->mask_layer(), property_trees); + if (replica_mask_layer) { + replica_mask_layer->set_is_drawn_render_surface_layer_list_member(true); + draw_property_utils::ComputeMaskDrawProperties(replica_mask_layer, + property_trees); } } -static inline void ClearLayerIsDrawnRenderSurfaceLayerListMember( - LayerImpl* layer) { - layer->set_is_drawn_render_surface_layer_list_member(false); - if (layer->mask_layer()) - layer->mask_layer()->set_is_drawn_render_surface_layer_list_member(false); - if (layer->replica_layer() && layer->replica_layer()->mask_layer()) { - layer->replica_layer() - ->mask_layer() - ->set_is_drawn_render_surface_layer_list_member(false); - } +static inline void ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers( + RenderSurfaceImpl* surface) { + LayerImpl* mask_layer = surface->MaskLayer(); + LayerImpl* replica_mask_layer = surface->ReplicaMaskLayer(); + if (mask_layer) + mask_layer->set_is_drawn_render_surface_layer_list_member(false); + if (replica_mask_layer) + replica_mask_layer->set_is_drawn_render_surface_layer_list_member(false); } static inline void ClearIsDrawnRenderSurfaceLayerListMember( @@ -225,7 +222,7 @@ static inline void ClearIsDrawnRenderSurfaceLayerListMember( scroll_tree->Node(layer->scroll_tree_index()) ->data.num_drawn_descendants--; } - ClearLayerIsDrawnRenderSurfaceLayerListMember(layer); + layer->set_is_drawn_render_surface_layer_list_member(false); } } @@ -330,9 +327,12 @@ static void ComputeInitialRenderSurfaceLayerList( // all non-skipped layers to the layer list of their target surface, and // add their content rect to their target surface's accumulated content rect. for (LayerImpl* layer : *layer_tree_impl) { - if (layer->render_surface()) + if (layer->render_surface()) { layer->ClearRenderSurfaceLayerList(); - ClearLayerIsDrawnRenderSurfaceLayerListMember(layer); + ClearMaskLayersAreDrawnRenderSurfaceLayerListMembers( + layer->render_surface()); + } + layer->set_is_drawn_render_surface_layer_list_member(false); bool layer_is_drawn = property_trees->effect_tree.Node(layer->effect_tree_index()) @@ -378,7 +378,7 @@ static void ComputeInitialRenderSurfaceLayerList( // TODO(senorblanco): make this smarter for the SkImageFilter case (check // for pixel-moving filters) bool is_occlusion_immune = surface->HasCopyRequest() || - layer->has_replica() || + surface->HasReplica() || layer->filters().HasReferenceFilter() || layer->filters().HasFilterThatMovesPixels(); if (is_occlusion_immune) { @@ -464,7 +464,7 @@ static void ComputeListOfNonEmptySurfaces(LayerTreeImpl* layer_tree_impl, } continue; } - SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(layer, property_trees); + SetMaskLayersAreDrawnRenderSurfaceLayerListMembers(surface, property_trees); final_surface_list->push_back(layer); } } diff --git a/cc/trees/layer_tree_host_common.h b/cc/trees/layer_tree_host_common.h index 69a3d3b8aed633..3452044458a732 100644 --- a/cc/trees/layer_tree_host_common.h +++ b/cc/trees/layer_tree_host_common.h @@ -159,31 +159,31 @@ struct CC_EXPORT ScrollAndScaleSet { DISALLOW_COPY_AND_ASSIGN(ScrollAndScaleSet); }; -template -static void CallFunctionForLayer(LayerType* layer, const Function& function) { - function(layer); - - if (LayerType* mask_layer = layer->mask_layer()) - function(mask_layer); - if (LayerType* replica_layer = layer->replica_layer()) { - function(replica_layer); - if (LayerType* mask_layer = replica_layer->mask_layer()) - function(mask_layer); - } -} - template void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeHost* host, const Function& function) { - for (auto* layer : *host) - CallFunctionForLayer(layer, function); + for (auto* layer : *host) { + function(layer); + if (Layer* mask_layer = layer->mask_layer()) + function(mask_layer); + if (Layer* replica_layer = layer->replica_layer()) { + function(replica_layer); + if (Layer* mask_layer = replica_layer->mask_layer()) + function(mask_layer); + } + } } template -void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeImpl* host_impl, +void LayerTreeHostCommon::CallFunctionForEveryLayer(LayerTreeImpl* tree_impl, const Function& function) { - for (auto* layer : *host_impl) - CallFunctionForLayer(layer, function); + for (auto* layer : *tree_impl) + function(layer); + + for (int id : + tree_impl->property_trees()->effect_tree.mask_replica_layer_ids()) { + function(tree_impl->LayerById(id)); + } } CC_EXPORT PropertyTrees* GetPropertyTrees(Layer* layer); diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc index 0872bff8739164..316545f3426620 100644 --- a/cc/trees/layer_tree_host_common_unittest.cc +++ b/cc/trees/layer_tree_host_common_unittest.cc @@ -673,7 +673,7 @@ TEST_F(LayerTreeHostCommonTest, TransformsForReplica) { SetLayerPropertiesForTesting(child_replica.get(), replica_layer_transform, gfx::Point3F(), gfx::PointF(), gfx::Size(), true, false, false); - child->SetReplicaLayer(std::move(child_replica)); + child->test_properties()->SetReplicaLayer(std::move(child_replica)); ExecuteCalculateDrawProperties(root); @@ -815,8 +815,10 @@ TEST_F(LayerTreeHostCommonTest, TransformsForRenderSurfaceHierarchy) { // We need to set parent on replica layers for property tree building. replica_of_rs1->SetParent(render_surface1); replica_of_rs2->SetParent(render_surface2); - render_surface1->SetReplicaLayer(std::move(replica_of_rs1)); - render_surface2->SetReplicaLayer(std::move(replica_of_rs2)); + render_surface1->test_properties()->SetReplicaLayer( + std::move(replica_of_rs1)); + render_surface2->test_properties()->SetReplicaLayer( + std::move(replica_of_rs2)); ExecuteCalculateDrawProperties(root); // Only layers that are associated with render surfaces should have an actual @@ -4931,7 +4933,7 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceTransformsInHighDPI) { true, false); // We need to set parent on replica layer for property tree building. replica->SetParent(child); - child->SetReplicaLayer(std::move(replica)); + child->test_properties()->SetReplicaLayer(std::move(replica)); // This layer should end up in the same surface as child, with the same draw // and screen space transforms. @@ -5042,7 +5044,7 @@ TEST_F(LayerTreeHostCommonTest, SetLayerPropertiesForTesting(replica.get(), replica_transform, gfx::Point3F(), gfx::PointF(), gfx::Size(13, 11), false, true, false); - child->SetReplicaLayer(std::move(replica)); + child->test_properties()->SetReplicaLayer(std::move(replica)); float device_scale_factor = 1.7f; ExecuteCalculateDrawProperties(parent, device_scale_factor); @@ -7570,10 +7572,10 @@ static void GatherDrawnLayers(LayerImplList* rsll, if (!it.represents_contributing_render_surface()) continue; - if (layer->mask_layer()) - drawn_layers->insert(layer->mask_layer()); - if (layer->replica_layer() && layer->replica_layer()->mask_layer()) - drawn_layers->insert(layer->replica_layer()->mask_layer()); + if (layer->render_surface()->MaskLayer()) + drawn_layers->insert(layer->render_surface()->MaskLayer()); + if (layer->render_surface()->ReplicaMaskLayer()) + drawn_layers->insert(layer->render_surface()->ReplicaMaskLayer()); } } @@ -7702,7 +7704,8 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) { EXPECT_EQ(expected, actual); // Add a mask layer to child. - child_raw->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6)); + child_raw->test_properties()->SetMaskLayer( + LayerImpl::Create(host_impl.active_tree(), 6)); child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true; ExecuteCalculateDrawProperties(grand_parent_raw); @@ -7710,18 +7713,18 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) { EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member()); - EXPECT_TRUE( - child_raw->mask_layer()->is_drawn_render_surface_layer_list_member()); + EXPECT_TRUE(child_raw->test_properties() + ->mask_layer->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member()); EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member()); expected.clear(); expected.insert(grand_child2_raw); - expected.insert(child_raw->mask_layer()); + expected.insert(child_raw->test_properties()->mask_layer); expected.clear(); expected.insert(grand_child2_raw); - expected.insert(child_raw->mask_layer()); + expected.insert(child_raw->test_properties()->mask_layer); actual.clear(); GatherDrawnLayers(render_surface_layer_list_impl(), &actual); @@ -7730,8 +7733,9 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) { // Add replica mask layer. std::unique_ptr replica_layer = LayerImpl::Create(host_impl.active_tree(), 20); - replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 21)); - child_raw->SetReplicaLayer(std::move(replica_layer)); + replica_layer->test_properties()->SetMaskLayer( + LayerImpl::Create(host_impl.active_tree(), 21)); + child_raw->test_properties()->SetReplicaLayer(std::move(replica_layer)); child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true; ExecuteCalculateDrawProperties(grand_parent_raw); @@ -7739,24 +7743,27 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) { EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member()); - EXPECT_TRUE( - child_raw->mask_layer()->is_drawn_render_surface_layer_list_member()); - EXPECT_TRUE(child_raw->replica_layer() - ->mask_layer() - ->is_drawn_render_surface_layer_list_member()); + EXPECT_TRUE(child_raw->test_properties() + ->mask_layer->is_drawn_render_surface_layer_list_member()); + EXPECT_TRUE(child_raw->test_properties() + ->replica_layer->test_properties() + ->mask_layer->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member()); EXPECT_TRUE(grand_child2_raw->is_drawn_render_surface_layer_list_member()); expected.clear(); expected.insert(grand_child2_raw); - expected.insert(child_raw->mask_layer()); - expected.insert(child_raw->replica_layer()->mask_layer()); + expected.insert(child_raw->test_properties()->mask_layer); + expected.insert(child_raw->test_properties() + ->replica_layer->test_properties() + ->mask_layer); actual.clear(); GatherDrawnLayers(render_surface_layer_list_impl(), &actual); EXPECT_EQ(expected, actual); - child_raw->TakeReplicaLayerForTesting(); + child_raw->test_properties()->SetReplicaLayer(nullptr); + child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true; // With nothing drawing, we should have no layers. grand_child2_raw->SetDrawsContent(false); @@ -7766,8 +7773,8 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) { EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(child_raw->is_drawn_render_surface_layer_list_member()); - EXPECT_FALSE( - child_raw->mask_layer()->is_drawn_render_surface_layer_list_member()); + EXPECT_FALSE(child_raw->test_properties() + ->mask_layer->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member()); @@ -7785,19 +7792,19 @@ TEST_F(LayerTreeHostCommonTest, RenderSurfaceLayerListMembership) { EXPECT_FALSE(grand_parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(parent_raw->is_drawn_render_surface_layer_list_member()); EXPECT_TRUE(child_raw->is_drawn_render_surface_layer_list_member()); - EXPECT_TRUE( - child_raw->mask_layer()->is_drawn_render_surface_layer_list_member()); + EXPECT_TRUE(child_raw->test_properties() + ->mask_layer->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(grand_child1_raw->is_drawn_render_surface_layer_list_member()); EXPECT_FALSE(grand_child2_raw->is_drawn_render_surface_layer_list_member()); expected.clear(); expected.insert(child_raw); - expected.insert(child_raw->mask_layer()); + expected.insert(child_raw->test_properties()->mask_layer); actual.clear(); GatherDrawnLayers(render_surface_layer_list_impl(), &actual); EXPECT_EQ(expected, actual); - child_raw->TakeMaskLayer(); + child_raw->test_properties()->SetMaskLayer(nullptr); child_raw->layer_tree_impl()->property_trees()->needs_rebuild = true; // Now everyone's a member! @@ -7864,13 +7871,15 @@ TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) { gfx::Point3F(), gfx::PointF(), gfx::Size(1, 1), true, false, false); - child1_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 4)); + child1_layer->test_properties()->SetMaskLayer( + LayerImpl::Create(host_impl.active_tree(), 4)); child1_layer->SetDrawsContent(true); std::unique_ptr replica_layer = LayerImpl::Create(host_impl.active_tree(), 5); - replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6)); - child1_layer->SetReplicaLayer(std::move(replica_layer)); + replica_layer->test_properties()->SetMaskLayer( + LayerImpl::Create(host_impl.active_tree(), 6)); + child1_layer->test_properties()->SetReplicaLayer(std::move(replica_layer)); child1_layer->SetHasRenderSurface(true); ExecuteCalculateDrawProperties(root_layer); @@ -7895,22 +7904,15 @@ TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) { EXPECT_FLOAT_EQ(1.f, root_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ(3.f, child1_layer->GetIdealContentsScale()); - EXPECT_FLOAT_EQ(3.f, child1_layer->mask_layer()->GetIdealContentsScale()); + EXPECT_FLOAT_EQ( + 3.f, + child1_layer->test_properties()->mask_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ(5.f, child2_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ( 0.f, root_layer->draw_properties().maximum_animation_contents_scale); EXPECT_FLOAT_EQ( 0.f, child1_layer->draw_properties().maximum_animation_contents_scale); - EXPECT_FLOAT_EQ(0.f, - child1_layer->mask_layer() - ->draw_properties() - .maximum_animation_contents_scale); - EXPECT_FLOAT_EQ(0.f, - child1_layer->replica_layer() - ->mask_layer() - ->draw_properties() - .maximum_animation_contents_scale); EXPECT_FLOAT_EQ( 8.f, child2_layer->draw_properties().maximum_animation_contents_scale); @@ -7933,25 +7935,18 @@ TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) { EXPECT_FLOAT_EQ(3.f, root_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ(9.f, child1_layer->GetIdealContentsScale()); - EXPECT_FLOAT_EQ(9.f, child1_layer->mask_layer()->GetIdealContentsScale()); EXPECT_FLOAT_EQ( 9.f, - child1_layer->replica_layer()->mask_layer()->GetIdealContentsScale()); + child1_layer->test_properties()->mask_layer->GetIdealContentsScale()); + EXPECT_FLOAT_EQ(9.f, child1_layer->test_properties() + ->replica_layer->test_properties() + ->mask_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ(15.f, child2_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ( 0.f, root_layer->draw_properties().maximum_animation_contents_scale); EXPECT_FLOAT_EQ( 0.f, child1_layer->draw_properties().maximum_animation_contents_scale); - EXPECT_FLOAT_EQ(0.f, - child1_layer->mask_layer() - ->draw_properties() - .maximum_animation_contents_scale); - EXPECT_FLOAT_EQ(0.f, - child1_layer->replica_layer() - ->mask_layer() - ->draw_properties() - .maximum_animation_contents_scale); EXPECT_FLOAT_EQ( 24.f, child2_layer->draw_properties().maximum_animation_contents_scale); @@ -7966,25 +7961,18 @@ TEST_F(LayerTreeHostCommonTest, DrawPropertyScales) { EXPECT_FLOAT_EQ(12.f, root_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ(36.f, child1_layer->GetIdealContentsScale()); - EXPECT_FLOAT_EQ(36.f, child1_layer->mask_layer()->GetIdealContentsScale()); EXPECT_FLOAT_EQ( 36.f, - child1_layer->replica_layer()->mask_layer()->GetIdealContentsScale()); + child1_layer->test_properties()->mask_layer->GetIdealContentsScale()); + EXPECT_FLOAT_EQ(36.f, child1_layer->test_properties() + ->replica_layer->test_properties() + ->mask_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ(60.f, child2_layer->GetIdealContentsScale()); EXPECT_FLOAT_EQ( 0.f, root_layer->draw_properties().maximum_animation_contents_scale); EXPECT_FLOAT_EQ( 0.f, child1_layer->draw_properties().maximum_animation_contents_scale); - EXPECT_FLOAT_EQ(0.f, - child1_layer->mask_layer() - ->draw_properties() - .maximum_animation_contents_scale); - EXPECT_FLOAT_EQ(0.f, - child1_layer->replica_layer() - ->mask_layer() - ->draw_properties() - .maximum_animation_contents_scale); EXPECT_FLOAT_EQ( 96.f, child2_layer->draw_properties().maximum_animation_contents_scale); } @@ -9689,7 +9677,9 @@ TEST_F(LayerTreeHostCommonTest, MaskLayerDrawProperties) { // Tests that a mask layer's draw properties are computed correctly. LayerImpl* root = root_layer(); LayerImpl* child = AddChild(root); - child->SetMaskLayer(LayerImpl::Create(root->layer_tree_impl(), 100)); + child->test_properties()->SetMaskLayer( + LayerImpl::Create(root->layer_tree_impl(), 100)); + LayerImpl* mask = child->test_properties()->mask_layer; const gfx::Transform identity_matrix; gfx::Transform transform; @@ -9700,9 +9690,9 @@ TEST_F(LayerTreeHostCommonTest, MaskLayerDrawProperties) { true); SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), true, false, false); - SetLayerPropertiesForTesting(child->mask_layer(), identity_matrix, - gfx::Point3F(), gfx::PointF(), gfx::Size(20, 20), - true, false, false); + SetLayerPropertiesForTesting(mask, identity_matrix, gfx::Point3F(), + gfx::PointF(), gfx::Size(20, 20), true, false, + false); root->SetDrawsContent(true); child->SetDrawsContent(false); ExecuteCalculateDrawProperties(root); @@ -9710,38 +9700,37 @@ TEST_F(LayerTreeHostCommonTest, MaskLayerDrawProperties) { // The render surface created for the mask has no contributing content, so the // mask isn't a drawn RSLL member. This means it has an empty visible rect, // but its screen space transform can still be computed correctly on-demand. - EXPECT_FALSE( - child->mask_layer()->is_drawn_render_surface_layer_list_member()); - EXPECT_EQ(gfx::Rect(), child->mask_layer()->visible_layer_rect()); - EXPECT_TRANSFORMATION_MATRIX_EQ(transform, - child->mask_layer()->ScreenSpaceTransform()); + EXPECT_FALSE(mask->is_drawn_render_surface_layer_list_member()); + EXPECT_EQ(gfx::Rect(), mask->visible_layer_rect()); + EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform()); // Make the child's render surface have contributing content. child->SetDrawsContent(true); root->layer_tree_impl()->property_trees()->needs_rebuild = true; ExecuteCalculateDrawProperties(root); - EXPECT_TRUE(child->mask_layer()->is_drawn_render_surface_layer_list_member()); - EXPECT_EQ(gfx::Rect(20, 20), child->mask_layer()->visible_layer_rect()); - EXPECT_TRANSFORMATION_MATRIX_EQ(transform, - child->mask_layer()->ScreenSpaceTransform()); + EXPECT_TRUE(mask->is_drawn_render_surface_layer_list_member()); + EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect()); + EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform()); transform.Translate(10, 10); child->SetTransform(transform); root->layer_tree_impl()->property_trees()->needs_rebuild = true; ExecuteCalculateDrawProperties(root); - EXPECT_TRANSFORMATION_MATRIX_EQ(transform, - child->mask_layer()->ScreenSpaceTransform()); - EXPECT_EQ(gfx::Rect(20, 20), child->mask_layer()->visible_layer_rect()); + EXPECT_TRANSFORMATION_MATRIX_EQ(transform, mask->ScreenSpaceTransform()); + EXPECT_EQ(gfx::Rect(20, 20), mask->visible_layer_rect()); } TEST_F(LayerTreeHostCommonTest, ReplicaMaskLayerDrawProperties) { // Tests that a replica mask layer's draw properties are computed correctly. LayerImpl* root = root_layer(); LayerImpl* child = AddChild(root); - child->SetReplicaLayer(LayerImpl::Create(root->layer_tree_impl(), 100)); - child->replica_layer()->SetParent(child); - child->replica_layer()->SetMaskLayer( + child->test_properties()->SetReplicaLayer( + LayerImpl::Create(root->layer_tree_impl(), 100)); + LayerImpl* replica = child->test_properties()->replica_layer; + replica->SetParent(child); + replica->test_properties()->SetMaskLayer( LayerImpl::Create(root->layer_tree_impl(), 200)); + LayerImpl* replica_mask = replica->test_properties()->mask_layer; const gfx::Transform identity_matrix; gfx::Transform transform; @@ -9754,12 +9743,12 @@ TEST_F(LayerTreeHostCommonTest, ReplicaMaskLayerDrawProperties) { true); SetLayerPropertiesForTesting(child, transform, gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30), true, false, false); - SetLayerPropertiesForTesting(child->replica_layer(), identity_matrix, - gfx::Point3F(), replica_position, - gfx::Size(30, 30), true, false, false); - SetLayerPropertiesForTesting(child->replica_layer()->mask_layer(), - identity_matrix, gfx::Point3F(), gfx::PointF(), - gfx::Size(20, 20), true, false, false); + SetLayerPropertiesForTesting(replica, identity_matrix, gfx::Point3F(), + replica_position, gfx::Size(30, 30), true, false, + false); + SetLayerPropertiesForTesting(replica_mask, identity_matrix, gfx::Point3F(), + gfx::PointF(), gfx::Size(20, 20), true, false, + false); root->SetDrawsContent(true); child->SetDrawsContent(false); ExecuteCalculateDrawProperties(root); @@ -9768,32 +9757,24 @@ TEST_F(LayerTreeHostCommonTest, ReplicaMaskLayerDrawProperties) { // the replica's mask isn't a drawn RSLL member. This means it has an empty // visible rect, but its screen space transform can still be computed // correctly on-demand. - EXPECT_FALSE(child->replica_layer() - ->mask_layer() - ->is_drawn_render_surface_layer_list_member()); - EXPECT_EQ(gfx::Rect(), - child->replica_layer()->mask_layer()->visible_layer_rect()); + EXPECT_FALSE(replica_mask->is_drawn_render_surface_layer_list_member()); + EXPECT_EQ(gfx::Rect(), replica_mask->visible_layer_rect()); gfx::Transform expected_screen_space_transform = transform; expected_screen_space_transform.Translate(replica_position.x(), replica_position.y()); - EXPECT_TRANSFORMATION_MATRIX_EQ( - expected_screen_space_transform, - child->replica_layer()->mask_layer()->ScreenSpaceTransform()); + EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform, + replica_mask->ScreenSpaceTransform()); // Make the child's render surface have contributing content. child->SetDrawsContent(true); root->layer_tree_impl()->property_trees()->needs_rebuild = true; ExecuteCalculateDrawProperties(root); - EXPECT_TRUE(child->replica_layer() - ->mask_layer() - ->is_drawn_render_surface_layer_list_member()); - EXPECT_EQ(gfx::Rect(20, 20), - child->replica_layer()->mask_layer()->visible_layer_rect()); - EXPECT_TRANSFORMATION_MATRIX_EQ( - expected_screen_space_transform, - child->replica_layer()->mask_layer()->ScreenSpaceTransform()); + EXPECT_TRUE(replica_mask->is_drawn_render_surface_layer_list_member()); + EXPECT_EQ(gfx::Rect(20, 20), replica_mask->visible_layer_rect()); + EXPECT_TRANSFORMATION_MATRIX_EQ(expected_screen_space_transform, + replica_mask->ScreenSpaceTransform()); } TEST_F(LayerTreeHostCommonTest, diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc index f1ef243b83c595..63256d484ccc22 100644 --- a/cc/trees/layer_tree_host_impl.cc +++ b/cc/trees/layer_tree_host_impl.cc @@ -647,7 +647,7 @@ void LayerTreeHostImpl::TrackDamageForAllSurfaces( render_surface->damage_tracker()->UpdateDamageTrackingState( render_surface->layer_list(), render_surface, render_surface->SurfacePropertyChangedOnlyFromDescendant(), - render_surface->content_rect(), render_surface_layer->mask_layer(), + render_surface->content_rect(), render_surface->MaskLayer(), render_surface_layer->filters()); } } @@ -697,14 +697,14 @@ static void AppendQuadsForRenderSurfaceLayer( const Occlusion& occlusion = surface->occlusion_in_content_space(); SkColor debug_border_color = surface->GetDebugBorderColor(); float debug_border_width = surface->GetDebugBorderWidth(); - LayerImpl* mask_layer = layer->mask_layer(); + LayerImpl* mask_layer = surface->MaskLayer(); surface->AppendQuads(target_render_pass, draw_transform, occlusion, debug_border_color, debug_border_width, mask_layer, append_quads_data, contributing_render_pass->id); // Add replica after the surface so that it appears below the surface. - if (layer->has_replica()) { + if (surface->HasReplica()) { const gfx::Transform& replica_draw_transform = surface->replica_draw_transform(); Occlusion replica_occlusion = occlusion.GetOcclusionWithGivenDrawTransform( @@ -719,7 +719,7 @@ static void AppendQuadsForRenderSurfaceLayer( // to draw the layer and its reflection in. For now we only apply a separate // reflection mask if the contents don't have a mask of their own. LayerImpl* replica_mask_layer = - mask_layer ? mask_layer : layer->replica_layer()->mask_layer(); + surface->HasMask() ? surface->MaskLayer() : surface->ReplicaMaskLayer(); surface->AppendQuads(target_render_pass, replica_draw_transform, replica_occlusion, replica_debug_border_color, diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc index a3895708e55b8f..d5223a3539e8f8 100644 --- a/cc/trees/layer_tree_host_impl_unittest.cc +++ b/cc/trees/layer_tree_host_impl_unittest.cc @@ -10255,8 +10255,9 @@ TEST_F(LayerTreeHostImplTest, DidBecomeActive) { std::unique_ptr mask_layer = FakePictureLayerImpl::Create(pending_tree, 11); FakePictureLayerImpl* raw_mask_layer = mask_layer.get(); - raw_pending_layer->SetMaskLayer(std::move(mask_layer)); - ASSERT_EQ(raw_mask_layer, raw_pending_layer->mask_layer()); + raw_pending_layer->test_properties()->SetMaskLayer(std::move(mask_layer)); + ASSERT_EQ(raw_mask_layer, raw_pending_layer->test_properties()->mask_layer); + pending_tree->BuildLayerListAndPropertyTreesForTesting(); EXPECT_EQ(1u, raw_pending_layer->did_become_active_call_count()); EXPECT_EQ(0u, raw_mask_layer->did_become_active_call_count()); @@ -10269,10 +10270,14 @@ TEST_F(LayerTreeHostImplTest, DidBecomeActive) { std::unique_ptr replica_mask_layer = FakePictureLayerImpl::Create(pending_tree, 13); FakePictureLayerImpl* raw_replica_mask_layer = replica_mask_layer.get(); - replica_layer->SetMaskLayer(std::move(replica_mask_layer)); - raw_pending_layer->SetReplicaLayer(std::move(replica_layer)); - ASSERT_EQ(raw_replica_mask_layer, - raw_pending_layer->replica_layer()->mask_layer()); + replica_layer->test_properties()->SetMaskLayer(std::move(replica_mask_layer)); + raw_pending_layer->test_properties()->SetReplicaLayer( + std::move(replica_layer)); + ASSERT_EQ(raw_replica_mask_layer, raw_pending_layer->test_properties() + ->replica_layer->test_properties() + ->mask_layer); + pending_tree->property_trees()->needs_rebuild = true; + pending_tree->BuildLayerListAndPropertyTreesForTesting(); EXPECT_EQ(2u, raw_pending_layer->did_become_active_call_count()); EXPECT_EQ(1u, raw_mask_layer->did_become_active_call_count()); diff --git a/cc/trees/layer_tree_host_unittest.cc b/cc/trees/layer_tree_host_unittest.cc index 4300f62032d764..80635f02a7be8d 100644 --- a/cc/trees/layer_tree_host_unittest.cc +++ b/cc/trees/layer_tree_host_unittest.cc @@ -1194,10 +1194,12 @@ class LayerTreeHostTestSwitchMaskLayer : public LayerTreeHostTest { switch (index_) { case 0: index_++; - EXPECT_FALSE(impl->sync_tree()->root_layer()->mask_layer()); + EXPECT_FALSE( + impl->sync_tree()->root_layer()->render_surface()->MaskLayer()); break; case 1: - EXPECT_TRUE(impl->sync_tree()->root_layer()->mask_layer()); + EXPECT_TRUE( + impl->sync_tree()->root_layer()->render_surface()->MaskLayer()); EndTest(); break; } diff --git a/cc/trees/layer_tree_host_unittest_occlusion.cc b/cc/trees/layer_tree_host_unittest_occlusion.cc index 1d3b3963c8de80..6d47b1599675e7 100644 --- a/cc/trees/layer_tree_host_unittest_occlusion.cc +++ b/cc/trees/layer_tree_host_unittest_occlusion.cc @@ -174,7 +174,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesOnMask LayerImpl* root = impl->active_tree()->root_layer(); LayerImpl* child = impl->active_tree()->LayerById(child_->id()); RenderSurfaceImpl* surface = child->render_surface(); - LayerImpl* mask = child->mask_layer(); + LayerImpl* mask = surface->MaskLayer(); // Verify the draw properties are valid. EXPECT_TRUE(root->is_drawn_render_surface_layer_list_member()); @@ -245,7 +245,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesOnScaledMask void DrawLayersOnThread(LayerTreeHostImpl* impl) override { LayerImpl* child = impl->active_tree()->LayerById(child_->id()); - LayerImpl* mask = child->mask_layer(); + LayerImpl* mask = child->render_surface()->MaskLayer(); gfx::Transform scale; scale.Scale(2, 2); @@ -315,7 +315,7 @@ class LayerTreeHostOcclusionTestDrawPropertiesInsideReplica LayerImpl* root = impl->active_tree()->root_layer(); LayerImpl* child = impl->active_tree()->LayerById(child_->id()); RenderSurfaceImpl* surface = child->render_surface(); - LayerImpl* mask = child->mask_layer(); + LayerImpl* mask = surface->MaskLayer(); // Verify the draw properties are valid. EXPECT_TRUE(root->is_drawn_render_surface_layer_list_member()); diff --git a/cc/trees/layer_tree_impl.cc b/cc/trees/layer_tree_impl.cc index e39989515e1f56..797eaf91676150 100644 --- a/cc/trees/layer_tree_impl.cc +++ b/cc/trees/layer_tree_impl.cc @@ -91,6 +91,7 @@ LayerTreeImpl::~LayerTreeImpl() { // Need to explicitly clear the tree prior to destroying this so that // the LayerTreeImpl pointer is still valid in the LayerImpl dtor. DCHECK(!root_layer_); + DCHECK(layers_->empty()); } void LayerTreeImpl::Shutdown() { @@ -923,7 +924,7 @@ bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) { // Masks are used to draw the contributing surface, so should have // the same occlusion as the surface (nothing inside the surface // occludes them). - if (LayerImpl* mask = it->mask_layer()) { + if (LayerImpl* mask = it->render_surface()->MaskLayer()) { Occlusion mask_occlusion = inside_replica ? Occlusion() @@ -932,9 +933,10 @@ bool LayerTreeImpl::UpdateDrawProperties(bool update_lcd_text) { it->DrawTransform()); mask->draw_properties().occlusion_in_content_space = mask_occlusion; } - if (LayerImpl* replica = it->replica_layer()) { - if (LayerImpl* mask = replica->mask_layer()) - mask->draw_properties().occlusion_in_content_space = Occlusion(); + if (LayerImpl* replica_mask = + it->render_surface()->ReplicaMaskLayer()) { + replica_mask->draw_properties().occlusion_in_content_space = + Occlusion(); } } @@ -1034,7 +1036,7 @@ gfx::SizeF LayerTreeImpl::ScrollableSize() const { LayerImpl* LayerTreeImpl::LayerById(int id) const { LayerImplMap::const_iterator iter = layer_id_map_.find(id); - return iter != layer_id_map_.end() ? iter->second : NULL; + return iter != layer_id_map_.end() ? iter->second : nullptr; } void LayerTreeImpl::AddLayerShouldPushProperties(LayerImpl* layer) { @@ -2076,7 +2078,8 @@ void LayerTreeImpl::ScrollAnimationAbort(bool needs_completion) { void LayerTreeImpl::ResetAllChangeTracking() { layers_that_should_push_properties_.clear(); - for (auto* layer : *this) + // Iterate over all layers, including masks and replicas. + for (auto& layer : *layers_) layer->ResetChangeTracking(); property_trees_.ResetAllChangeTracking(); } diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc index f2f57d88c29fba..0b5b521a44e33b 100644 --- a/cc/trees/layer_tree_impl_unittest.cc +++ b/cc/trees/layer_tree_impl_unittest.cc @@ -789,7 +789,7 @@ TEST_F(LayerTreeImplTest, HitTestingForNonClippingIntermediateLayer) { false, false); // Sanity check the intermediate layer should not clip. ASSERT_FALSE(intermediate_layer->masks_to_bounds()); - ASSERT_FALSE(intermediate_layer->mask_layer()); + ASSERT_FALSE(intermediate_layer->test_properties()->mask_layer); // The child of the intermediate_layer is translated so that it does not // overlap intermediate_layer at all. If child is incorrectly clipped, we diff --git a/cc/trees/occlusion_tracker.cc b/cc/trees/occlusion_tracker.cc index ba68f4e76e8c83..573d123db64f09 100644 --- a/cc/trees/occlusion_tracker.cc +++ b/cc/trees/occlusion_tracker.cc @@ -181,7 +181,7 @@ void OcclusionTracker::FinishedRenderTarget(const LayerImpl* finished_target) { // If the occlusion within the surface can not be applied to things outside of // the surface's subtree, then clear the occlusion here so it won't be used. - if (finished_target->mask_layer() || surface->draw_opacity() < 1 || + if (surface->MaskLayer() || surface->draw_opacity() < 1 || !finished_target->uses_default_blend_mode() || target_is_only_for_copy_request || finished_target->filters().HasFilterThatAffectsOpacity()) { @@ -265,7 +265,7 @@ void OcclusionTracker::LeaveToRenderTarget(const LayerImpl* new_target) { stack_[last_index].occlusion_from_inside_target, old_surface->is_clipped(), old_surface->clip_rect(), old_surface->draw_transform()); - if (old_target->has_replica() && !old_target->replica_has_mask()) { + if (old_surface->HasReplica() && !old_surface->HasReplicaMask()) { old_occlusion_from_inside_target_in_new_target.Union( TransformSurfaceOpaqueRegion( stack_[last_index].occlusion_from_inside_target, @@ -285,7 +285,7 @@ void OcclusionTracker::LeaveToRenderTarget(const LayerImpl* new_target) { old_surface->draw_transform()); unoccluded_surface_rect = surface_occlusion.GetUnoccludedContentRect(old_surface->content_rect()); - if (old_target->has_replica()) { + if (old_surface->HasReplica()) { Occlusion replica_occlusion = GetCurrentOcclusionForContributingSurface( old_surface->replica_draw_transform()); unoccluded_replica_rect = replica_occlusion.GetUnoccludedContentRect( @@ -331,7 +331,7 @@ void OcclusionTracker::LeaveToRenderTarget(const LayerImpl* new_target) { new_target, &stack_.back().occlusion_from_outside_target); - if (!old_target->has_replica()) + if (!old_surface->HasReplica()) return; ReduceOcclusionBelowSurface(old_target, unoccluded_replica_rect, diff --git a/cc/trees/occlusion_tracker_unittest.cc b/cc/trees/occlusion_tracker_unittest.cc index 78ad3ea0d3d240..7c113004b237ce 100644 --- a/cc/trees/occlusion_tracker_unittest.cc +++ b/cc/trees/occlusion_tracker_unittest.cc @@ -301,11 +301,11 @@ class OcclusionTrackerTest : public testing::Test { void SetReplica(LayerImpl* owning_layer, std::unique_ptr layer) { // We need to set parent on replica layer for property tree building. layer->SetParent(owning_layer); - owning_layer->SetReplicaLayer(std::move(layer)); + owning_layer->test_properties()->SetReplicaLayer(std::move(layer)); } void SetMask(LayerImpl* owning_layer, std::unique_ptr layer) { - owning_layer->SetMaskLayer(std::move(layer)); + owning_layer->test_properties()->SetMaskLayer(std::move(layer)); } bool opaque_layers_; diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc index 283dae04c2ecdf..1bf2af33f0b238 100644 --- a/cc/trees/property_tree.cc +++ b/cc/trees/property_tree.cc @@ -531,7 +531,10 @@ EffectNodeData::EffectNodeData() has_unclipped_descendants(false), transform_id(0), clip_id(0), - target_id(0) {} + target_id(0), + mask_layer_id(-1), + replica_layer_id(-1), + replica_mask_layer_id(-1) {} EffectNodeData::EffectNodeData(const EffectNodeData& other) = default; @@ -551,7 +554,9 @@ bool EffectNodeData::operator==(const EffectNodeData& other) const { effect_changed == other.effect_changed && num_copy_requests_in_subtree == other.num_copy_requests_in_subtree && transform_id == other.transform_id && clip_id == other.clip_id && - target_id == other.target_id; + target_id == other.target_id && mask_layer_id == other.mask_layer_id && + replica_layer_id == other.replica_layer_id && + replica_mask_layer_id == other.replica_mask_layer_id; } void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const { @@ -573,6 +578,9 @@ void EffectNodeData::ToProtobuf(proto::TreeNode* proto) const { data->set_transform_id(transform_id); data->set_clip_id(clip_id); data->set_target_id(target_id); + data->set_mask_layer_id(mask_layer_id); + data->set_replica_layer_id(replica_layer_id); + data->set_replica_mask_layer_id(replica_mask_layer_id); } void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) { @@ -595,6 +603,9 @@ void EffectNodeData::FromProtobuf(const proto::TreeNode& proto) { transform_id = data.transform_id(); clip_id = data.clip_id(); target_id = data.target_id(); + mask_layer_id = data.mask_layer_id(); + replica_layer_id = data.replica_layer_id(); + replica_mask_layer_id = data.replica_mask_layer_id(); } void EffectNodeData::AsValueInto(base::trace_event::TracedValue* value) const { @@ -612,6 +623,9 @@ void EffectNodeData::AsValueInto(base::trace_event::TracedValue* value) const { value->SetInteger("transform_id", transform_id); value->SetInteger("clip_id", clip_id); value->SetInteger("target_id", target_id); + value->SetInteger("mask_layer_id", mask_layer_id); + value->SetInteger("replica_layer_id", replica_layer_id); + value->SetInteger("replica_mask_layer_id", replica_mask_layer_id); } ScrollNodeData::ScrollNodeData() @@ -1432,6 +1446,11 @@ EffectTree::EffectTree() {} EffectTree::~EffectTree() {} +void EffectTree::clear() { + PropertyTree::clear(); + mask_replica_layer_ids_.clear(); +} + float EffectTree::EffectiveOpacity(const EffectNode* node) const { return node->data.subtree_hidden ? 0.f : node->data.opacity; } @@ -1606,6 +1625,10 @@ void EffectTree::ClearCopyRequests() { set_needs_update(true); } +void EffectTree::AddMaskOrReplicaLayerId(int id) { + mask_replica_layer_ids_.push_back(id); +} + bool EffectTree::ContributesToDrawnSurface(int id) { // All drawn nodes contribute to drawn surface. // Exception : Nodes that are hidden and are drawn only for the sake of @@ -1671,13 +1694,15 @@ void ClipTree::FromProtobuf( EffectTree& EffectTree::operator=(const EffectTree& from) { PropertyTree::operator=(from); + mask_replica_layer_ids_ = from.mask_replica_layer_ids_; // copy_requests_ are omitted here, since these need to be moved rather // than copied or assigned. return *this; } bool EffectTree::operator==(const EffectTree& other) const { - return PropertyTree::operator==(other); + return PropertyTree::operator==(other) && + mask_replica_layer_ids_ == other.mask_replica_layer_ids_; } void EffectTree::ToProtobuf(proto::PropertyTree* proto) const { @@ -1685,6 +1710,10 @@ void EffectTree::ToProtobuf(proto::PropertyTree* proto) const { proto->set_property_type(proto::PropertyTree::Effect); PropertyTree::ToProtobuf(proto); + proto::EffectTreeData* data = proto->mutable_effect_tree_data(); + + for (auto i : mask_replica_layer_ids_) + data->add_mask_replica_layer_ids(i); } void EffectTree::FromProtobuf( @@ -1694,6 +1723,12 @@ void EffectTree::FromProtobuf( DCHECK_EQ(proto.property_type(), proto::PropertyTree::Effect); PropertyTree::FromProtobuf(proto, node_id_to_index_map); + const proto::EffectTreeData& data = proto.effect_tree_data(); + + DCHECK(mask_replica_layer_ids_.empty()); + for (int i = 0; i < data.mask_replica_layer_ids_size(); ++i) { + mask_replica_layer_ids_.push_back(data.mask_replica_layer_ids(i)); + } } ScrollTree::ScrollTree() diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h index ac977a37108f01..622f652f342ab3 100644 --- a/cc/trees/property_tree.h +++ b/cc/trees/property_tree.h @@ -35,7 +35,7 @@ class TransformNodeData; class TransformCachedNodeData; class TransformTreeData; class TreeNode; -} +} // namespace proto class CopyOutputRequest; class LayerTreeImpl; @@ -308,6 +308,9 @@ struct CC_EXPORT EffectNodeData { int clip_id; // Effect node id of which this effect contributes to. int target_id; + int mask_layer_id; + int replica_layer_id; + int replica_mask_layer_id; bool operator==(const EffectNodeData& other) const; @@ -612,6 +615,8 @@ class CC_EXPORT EffectTree final : public PropertyTree { EffectTree& operator=(const EffectTree& from); bool operator==(const EffectTree& other) const; + void clear(); + float EffectiveOpacity(const EffectNode* node) const; void UpdateEffects(int id); @@ -626,6 +631,11 @@ class CC_EXPORT EffectTree final : public PropertyTree { bool HasCopyRequests() const; void ClearCopyRequests(); + void AddMaskOrReplicaLayerId(int id); + const std::vector& mask_replica_layer_ids() const { + return mask_replica_layer_ids_; + } + bool ContributesToDrawnSurface(int id); void ResetChangeTracking(); @@ -642,6 +652,10 @@ class CC_EXPORT EffectTree final : public PropertyTree { // Stores copy requests, keyed by node id. std::unordered_multimap> copy_requests_; + + // Unsorted list of all mask, replica, and replica mask layer ids that + // effect nodes refer to. + std::vector mask_replica_layer_ids_; }; class CC_EXPORT ScrollTree final : public PropertyTree { diff --git a/cc/trees/property_tree_builder.cc b/cc/trees/property_tree_builder.cc index f5ca6dba49da91..adbffbe9896451 100644 --- a/cc/trees/property_tree_builder.cc +++ b/cc/trees/property_tree_builder.cc @@ -213,6 +213,22 @@ static size_t NumUnclippedDescendants(LayerImpl* layer) { return layer->test_properties()->num_unclipped_descendants; } +static Layer* MaskLayer(Layer* layer) { + return layer->mask_layer(); +} + +static LayerImpl* MaskLayer(LayerImpl* layer) { + return layer->test_properties()->mask_layer; +} + +static Layer* ReplicaLayer(Layer* layer) { + return layer->replica_layer(); +} + +static LayerImpl* ReplicaLayer(LayerImpl* layer) { + return layer->test_properties()->replica_layer; +} + template static LayerType* GetTransformParent(const DataForRecursion& data, LayerType* layer) { @@ -232,7 +248,7 @@ static ClipNode* GetClipParent(const DataForRecursion& data, template static bool LayerClipsSubtree(LayerType* layer) { - return layer->masks_to_bounds() || layer->mask_layer(); + return layer->masks_to_bounds() || MaskLayer(layer); } template @@ -730,12 +746,12 @@ bool ShouldCreateRenderSurface(LayerType* layer, // If the layer uses a mask and the layer is not a replica layer. // TODO(weiliangc): After slimming paint there won't be replica layers. - if (layer->mask_layer() && layer->parent()->replica_layer() != layer) { + if (MaskLayer(layer) && ReplicaLayer(layer->parent()) != layer) { return true; } // If the layer has a reflection. - if (layer->replica_layer()) { + if (ReplicaLayer(layer)) { return true; } @@ -882,6 +898,20 @@ bool AddEffectNodeIfNeeded( node.data.subtree_hidden = HideLayerAndSubtree(layer); node.data.is_currently_animating_opacity = layer->OpacityIsAnimating(); + EffectTree& effect_tree = data_for_children->property_trees->effect_tree; + if (MaskLayer(layer)) { + node.data.mask_layer_id = MaskLayer(layer)->id(); + effect_tree.AddMaskOrReplicaLayerId(node.data.mask_layer_id); + } + if (ReplicaLayer(layer)) { + node.data.replica_layer_id = ReplicaLayer(layer)->id(); + effect_tree.AddMaskOrReplicaLayerId(node.data.replica_layer_id); + if (MaskLayer(ReplicaLayer(layer))) { + node.data.replica_mask_layer_id = MaskLayer(ReplicaLayer(layer))->id(); + effect_tree.AddMaskOrReplicaLayerId(node.data.replica_mask_layer_id); + } + } + if (!is_root) { // The effect node's transform id is used only when we create a render // surface. So, we can leave the default value when we don't create a render @@ -904,8 +934,7 @@ bool AddEffectNodeIfNeeded( node.data.transform_id = kRootPropertyTreeNodeId; node.data.clip_id = kViewportClipTreeNodeId; } - data_for_children->effect_tree_parent = - data_for_children->property_trees->effect_tree.Insert(node, parent_id); + data_for_children->effect_tree_parent = effect_tree.Insert(node, parent_id); int node_id = data_for_children->effect_tree_parent; layer->SetEffectTreeIndex(node_id); data_for_children->property_trees->effect_id_to_index_map[layer->id()] = @@ -914,8 +943,7 @@ bool AddEffectNodeIfNeeded( std::vector> layer_copy_requests; TakeCopyRequests(layer, &layer_copy_requests); for (auto& it : layer_copy_requests) { - data_for_children->property_trees->effect_tree.AddCopyRequest( - node_id, std::move(it)); + effect_tree.AddCopyRequest(node_id, std::move(it)); } layer_copy_requests.clear(); @@ -1128,22 +1156,22 @@ void BuildPropertyTreesInternal( } } - if (layer->has_replica()) { + if (ReplicaLayer(layer)) { DataForRecursionFromChild data_from_child; - BuildPropertyTreesInternal(layer->replica_layer(), data_for_children, + BuildPropertyTreesInternal(ReplicaLayer(layer), data_for_children, &data_from_child); data_to_parent->Merge(data_from_child); } - if (layer->mask_layer()) { - layer->mask_layer()->set_property_tree_sequence_number( + if (MaskLayer(layer)) { + MaskLayer(layer)->set_property_tree_sequence_number( data_from_parent.property_trees->sequence_number); - layer->mask_layer()->set_offset_to_transform_parent( + MaskLayer(layer)->set_offset_to_transform_parent( layer->offset_to_transform_parent()); - layer->mask_layer()->SetTransformTreeIndex(layer->transform_tree_index()); - layer->mask_layer()->SetClipTreeIndex(layer->clip_tree_index()); - layer->mask_layer()->SetEffectTreeIndex(layer->effect_tree_index()); - layer->mask_layer()->SetScrollTreeIndex(layer->scroll_tree_index()); + MaskLayer(layer)->SetTransformTreeIndex(layer->transform_tree_index()); + MaskLayer(layer)->SetClipTreeIndex(layer->clip_tree_index()); + MaskLayer(layer)->SetEffectTreeIndex(layer->effect_tree_index()); + MaskLayer(layer)->SetScrollTreeIndex(layer->scroll_tree_index()); } EffectNode* effect_node = data_for_children.property_trees->effect_tree.Node( diff --git a/cc/trees/property_tree_unittest.cc b/cc/trees/property_tree_unittest.cc index 23b34f29f1936c..bd773438e8ada6 100644 --- a/cc/trees/property_tree_unittest.cc +++ b/cc/trees/property_tree_unittest.cc @@ -187,6 +187,9 @@ TEST(PropertyTreeSerializationTest, EffectNodeDataSerialization) { original.has_render_surface = false; original.transform_id = 2; original.clip_id = 3; + original.mask_layer_id = 6; + original.replica_layer_id = 10; + original.replica_mask_layer_id = 9; proto::TreeNode proto; original.ToProtobuf(&proto); @@ -220,13 +223,19 @@ TEST(PropertyTreeSerializationTest, EffectTreeSerialization) { second.owner_id = 6; second.data.transform_id = 4; second.data.opacity = true; + second.data.mask_layer_id = 32; EffectNode third; third.owner_id = 7; third.data.clip_id = 3; + third.data.replica_layer_id = 44; + third.data.replica_mask_layer_id = 45; third.data.has_render_surface = false; original.Insert(second, 0); original.Insert(third, 1); + original.AddMaskOrReplicaLayerId(32); + original.AddMaskOrReplicaLayerId(44); + original.AddMaskOrReplicaLayerId(45); original.set_needs_update(true); proto::PropertyTree proto; diff --git a/cc/trees/tree_synchronizer.cc b/cc/trees/tree_synchronizer.cc index cdb46f772c23ae..4069a3437075c6 100644 --- a/cc/trees/tree_synchronizer.cc +++ b/cc/trees/tree_synchronizer.cc @@ -18,8 +18,10 @@ namespace cc { -template -void SynchronizeTreesInternal(LayerType* layer_root, LayerTreeImpl* tree_impl) { +template +void SynchronizeTreesInternal(LayerTreeType* source_tree, + LayerTreeImpl* tree_impl, + PropertyTrees* property_trees) { DCHECK(tree_impl); TRACE_EVENT0("cc", "TreeSynchronizer::SynchronizeTrees"); @@ -29,31 +31,33 @@ void SynchronizeTreesInternal(LayerType* layer_root, LayerTreeImpl* tree_impl) { for (auto& it : *old_layers) old_layer_map[it->id()] = std::move(it); - PushLayerList(&old_layer_map, layer_root, tree_impl); + PushLayerList(&old_layer_map, source_tree, tree_impl); - for (auto& it : old_layer_map) { - if (it.second) { - // Need to ensure that layer destruction doesn't tear down other layers - // linked to this LayerImpl that have been used in the new tree. - it.second->ClearLinksToOtherLayers(); - } + for (int id : property_trees->effect_tree.mask_replica_layer_ids()) { + std::unique_ptr layer_impl(ReuseOrCreateLayerImpl( + &old_layer_map, source_tree->LayerById(id), tree_impl)); + tree_impl->AddLayer(std::move(layer_impl)); } } void TreeSynchronizer::SynchronizeTrees(Layer* layer_root, LayerTreeImpl* tree_impl) { - if (!layer_root) + if (!layer_root) { tree_impl->DetachLayers(); - else - SynchronizeTreesInternal(layer_root, tree_impl); + } else { + SynchronizeTreesInternal(layer_root->layer_tree_host(), tree_impl, + layer_root->layer_tree_host()->property_trees()); + } } void TreeSynchronizer::SynchronizeTrees(LayerImpl* layer_root, LayerTreeImpl* tree_impl) { - if (!layer_root) + if (!layer_root) { tree_impl->DetachLayers(); - else - SynchronizeTreesInternal(layer_root, tree_impl); + } else { + SynchronizeTreesInternal(layer_root->layer_tree_impl(), tree_impl, + layer_root->layer_tree_impl()->property_trees()); + } } template @@ -68,70 +72,18 @@ std::unique_ptr ReuseOrCreateLayerImpl(OwnedLayerImplMap* old_layers, return layer_impl; } -static void SynchronizeReplicaLayer(LayerImpl* layer_impl, - std::unique_ptr new_replica, - LayerTreeImpl* tree_impl) { - if (layer_impl->replica_layer() && - layer_impl->replica_layer() == new_replica.get()) { - // In this case, we only need to update the ownership, as we're essentially - // just resetting the replica layer. - tree_impl->AddLayer(std::move(new_replica)); - } else { - layer_impl->SetReplicaLayer(std::move(new_replica)); - } -} - -static void SynchronizeMaskLayer(LayerImpl* layer_impl, - std::unique_ptr new_mask, - LayerTreeImpl* tree_impl) { - if (layer_impl->mask_layer() && layer_impl->mask_layer() == new_mask.get()) { - // In this case, we only need to update the ownership, as we're essentially - // just resetting the mask layer. - tree_impl->AddLayer(std::move(new_mask)); - } else { - layer_impl->SetMaskLayer(std::move(new_mask)); - } -} - template -void PushLayerListInternal(OwnedLayerImplMap* old_layers, - LayerTreeType* host, - LayerTreeImpl* tree_impl) { +void PushLayerList(OwnedLayerImplMap* old_layers, + LayerTreeType* host, + LayerTreeImpl* tree_impl) { tree_impl->ClearLayerList(); for (auto* layer : *host) { std::unique_ptr layer_impl( ReuseOrCreateLayerImpl(old_layers, layer, tree_impl)); - std::unique_ptr mask_layer( - ReuseOrCreateLayerImpl(old_layers, layer->mask_layer(), tree_impl)); - SynchronizeMaskLayer(layer_impl.get(), std::move(mask_layer), tree_impl); - - std::unique_ptr replica_layer( - ReuseOrCreateLayerImpl(old_layers, layer->replica_layer(), tree_impl)); - SynchronizeReplicaLayer(layer_impl.get(), std::move(replica_layer), - tree_impl); - if (layer->replica_layer()) { - std::unique_ptr replica_mask_layer(ReuseOrCreateLayerImpl( - old_layers, layer->replica_layer()->mask_layer(), tree_impl)); - SynchronizeMaskLayer(layer_impl->replica_layer(), - std::move(replica_mask_layer), tree_impl); - } tree_impl->AddToLayerList(layer_impl.get()); tree_impl->AddLayer(std::move(layer_impl)); } -} - -void PushLayerList(OwnedLayerImplMap* old_layers, - Layer* old_root, - LayerTreeImpl* tree_impl) { - PushLayerListInternal(old_layers, old_root->layer_tree_host(), tree_impl); - tree_impl->SetRootLayerFromLayerList(); -} - -void PushLayerList(OwnedLayerImplMap* old_layers, - LayerImpl* old_root, - LayerTreeImpl* tree_impl) { - PushLayerListInternal(old_layers, old_root->layer_tree_impl(), tree_impl); tree_impl->SetRootLayerFromLayerList(); } diff --git a/cc/trees/tree_synchronizer_unittest.cc b/cc/trees/tree_synchronizer_unittest.cc index 69035a1ff0643b..a20f725d478022 100644 --- a/cc/trees/tree_synchronizer_unittest.cc +++ b/cc/trees/tree_synchronizer_unittest.cc @@ -96,23 +96,30 @@ void ExpectTreesAreIdentical(Layer* root_layer, EXPECT_EQ(layer->non_fast_scrollable_region(), layer_impl->non_fast_scrollable_region()); - ASSERT_EQ(!!layer->mask_layer(), !!layer_impl->mask_layer()); + const EffectTree& effect_tree = tree_impl->property_trees()->effect_tree; if (layer->mask_layer()) { SCOPED_TRACE("mask_layer"); - EXPECT_EQ(layer->mask_layer()->id(), layer_impl->mask_layer()->id()); + int mask_layer_id = layer->mask_layer()->id(); + EXPECT_TRUE(tree_impl->LayerById(mask_layer_id)); + EXPECT_EQ(mask_layer_id, + effect_tree.Node(layer_impl->effect_tree_index()) + ->data.mask_layer_id); } - ASSERT_EQ(!!layer->replica_layer(), !!layer_impl->replica_layer()); if (layer->replica_layer()) { SCOPED_TRACE("replica_layer"); - EXPECT_EQ(layer->replica_layer()->id(), - layer_impl->replica_layer()->id()); - ASSERT_EQ(!!layer->replica_layer()->mask_layer(), - !!layer_impl->replica_layer()->mask_layer()); + int replica_layer_id = layer->replica_layer()->id(); + EXPECT_TRUE(tree_impl->LayerById(layer->replica_layer()->id())); + EXPECT_EQ(replica_layer_id, + effect_tree.Node(layer_impl->effect_tree_index()) + ->data.replica_layer_id); if (layer->replica_layer()->mask_layer()) { - SCOPED_TRACE("mask_layer"); - EXPECT_EQ(layer->replica_layer()->mask_layer()->id(), - layer_impl->replica_layer()->mask_layer()->id()); + SCOPED_TRACE("replica_mask_layer"); + int replica_mask_layer_id = layer->replica_layer()->mask_layer()->id(); + EXPECT_TRUE(tree_impl->LayerById(replica_mask_layer_id)); + EXPECT_EQ(replica_mask_layer_id, + effect_tree.Node(layer_impl->effect_tree_index()) + ->data.replica_mask_layer_id); } } @@ -465,33 +472,36 @@ TEST_F(TreeSynchronizerTest, SyncMaskReplicaAndReplicaMaskLayers) { replica_layer_with_mask.get()); host_->SetRootLayer(layer_tree_root); + host_->BuildPropertyTreesForTesting(); + host_->CommitAndCreateLayerImplTree(); - TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), - host_->active_tree()); LayerImpl* layer_impl_tree_root = host_->active_tree()->root_layer(); ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, host_->active_tree()); // Remove the mask layer. layer_tree_root->children()[0]->SetMaskLayer(NULL); - TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), - host_->active_tree()); + host_->BuildPropertyTreesForTesting(); + host_->CommitAndCreateLayerImplTree(); + layer_impl_tree_root = host_->active_tree()->root_layer(); ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, host_->active_tree()); // Remove the replica layer. layer_tree_root->children()[1]->SetReplicaLayer(NULL); - TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), - host_->active_tree()); + host_->BuildPropertyTreesForTesting(); + host_->CommitAndCreateLayerImplTree(); + layer_impl_tree_root = host_->active_tree()->root_layer(); ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, host_->active_tree()); // Remove the replica mask. replica_layer_with_mask->SetMaskLayer(NULL); - TreeSynchronizer::SynchronizeTrees(layer_tree_root.get(), - host_->active_tree()); + host_->BuildPropertyTreesForTesting(); + host_->CommitAndCreateLayerImplTree(); + layer_impl_tree_root = host_->active_tree()->root_layer(); ExpectTreesAreIdentical(layer_tree_root.get(), layer_impl_tree_root, host_->active_tree());