blob: 73197741d39ad4229075a9492c8e1bb62121eac8 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/trees/property_tree_builder.h"
#include <stddef.h>
#include <map>
#include <set>
#include "base/memory/ptr_util.h"
#include "cc/base/math_util.h"
#include "cc/layers/layer.h"
#include "cc/layers/layer_impl.h"
#include "cc/output/copy_output_request.h"
#include "cc/trees/clip_node.h"
#include "cc/trees/draw_property_utils.h"
#include "cc/trees/effect_node.h"
#include "cc/trees/layer_tree_impl.h"
#include "cc/trees/layer_tree_settings.h"
#include "cc/trees/mutable_properties.h"
#include "cc/trees/mutator_host.h"
#include "cc/trees/scroll_node.h"
#include "cc/trees/transform_node.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/vector2d_conversions.h"
namespace cc {
namespace {
template <typename LayerType>
struct DataForRecursion {
PropertyTrees* property_trees;
LayerType* transform_tree_parent;
LayerType* transform_fixed_parent;
int render_target;
int clip_tree_parent;
int effect_tree_parent;
int scroll_tree_parent;
const LayerType* page_scale_layer;
const LayerType* inner_viewport_scroll_layer;
const LayerType* outer_viewport_scroll_layer;
const LayerType* overscroll_elasticity_layer;
gfx::Vector2dF elastic_overscroll;
float page_scale_factor;
bool in_subtree_of_page_scale_layer;
bool affected_by_inner_viewport_bounds_delta;
bool affected_by_outer_viewport_bounds_delta;
bool should_flatten;
bool is_hidden;
uint32_t main_thread_scrolling_reasons;
bool scroll_tree_parent_created_by_uninheritable_criteria;
const gfx::Transform* device_transform;
gfx::Transform compound_transform_since_render_target;
bool axis_align_since_render_target;
SkColor safe_opaque_background_color;
};
static LayerPositionConstraint PositionConstraint(Layer* layer) {
return layer->position_constraint();
}
static LayerPositionConstraint PositionConstraint(LayerImpl* layer) {
return layer->test_properties()->position_constraint;
}
static LayerStickyPositionConstraint StickyPositionConstraint(Layer* layer) {
return layer->sticky_position_constraint();
}
static LayerStickyPositionConstraint StickyPositionConstraint(
LayerImpl* layer) {
return layer->test_properties()->sticky_position_constraint;
}
static LayerImplList& Children(LayerImpl* layer) {
return layer->test_properties()->children;
}
static const LayerList& Children(Layer* layer) {
return layer->children();
}
static LayerImpl* ChildAt(LayerImpl* layer, int index) {
return layer->test_properties()->children[index];
}
static Layer* ChildAt(Layer* layer, int index) {
return layer->child_at(index);
}
static Layer* ScrollParent(Layer* layer) {
return layer->scroll_parent();
}
static LayerImpl* ScrollParent(LayerImpl* layer) {
return layer->test_properties()->scroll_parent;
}
static std::set<Layer*>* ScrollChildren(Layer* layer) {
return layer->scroll_children();
}
static std::set<LayerImpl*>* ScrollChildren(LayerImpl* layer) {
return layer->test_properties()->scroll_children.get();
}
static Layer* ClipParent(Layer* layer) {
return layer->clip_parent();
}
static LayerImpl* ClipParent(LayerImpl* layer) {
return layer->test_properties()->clip_parent;
}
static inline const FilterOperations& Filters(Layer* layer) {
return layer->filters();
}
static inline const FilterOperations& Filters(LayerImpl* layer) {
return layer->test_properties()->filters;
}
static Layer* MaskLayer(Layer* layer) {
return layer->mask_layer();
}
static LayerImpl* MaskLayer(LayerImpl* layer) {
return layer->test_properties()->mask_layer;
}
static const gfx::Transform& Transform(Layer* layer) {
return layer->transform();
}
static const gfx::Transform& Transform(LayerImpl* layer) {
return layer->test_properties()->transform;
}
static void SetIsScrollClipLayer(Layer* layer) {
layer->set_is_scroll_clip_layer();
}
static void SetIsScrollClipLayer(LayerImpl* layer) {}
// Methods to query state from the AnimationHost ----------------------
template <typename LayerType>
bool OpacityIsAnimating(LayerType* layer) {
return layer->GetMutatorHost()->IsAnimatingOpacityProperty(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool HasPotentiallyRunningOpacityAnimation(LayerType* layer) {
return layer->GetMutatorHost()->HasPotentiallyRunningOpacityAnimation(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool FilterIsAnimating(LayerType* layer) {
return layer->GetMutatorHost()->IsAnimatingFilterProperty(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool HasPotentiallyRunningFilterAnimation(LayerType* layer) {
return layer->GetMutatorHost()->HasPotentiallyRunningFilterAnimation(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool TransformIsAnimating(LayerType* layer) {
return layer->GetMutatorHost()->IsAnimatingTransformProperty(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool HasPotentiallyRunningTransformAnimation(LayerType* layer) {
return layer->GetMutatorHost()->HasPotentiallyRunningTransformAnimation(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool HasOnlyTranslationTransforms(LayerType* layer) {
return layer->GetMutatorHost()->HasOnlyTranslationTransforms(
layer->element_id(), layer->GetElementTypeForAnimation());
}
template <typename LayerType>
bool AnimationsPreserveAxisAlignment(LayerType* layer) {
return layer->GetMutatorHost()->AnimationsPreserveAxisAlignment(
layer->element_id());
}
template <typename LayerType>
bool HasAnyAnimationTargetingProperty(LayerType* layer,
TargetProperty::Type property) {
return layer->GetMutatorHost()->HasAnyAnimationTargetingProperty(
layer->element_id(), property);
}
// -------------------------------------------------------------------
template <typename LayerType>
static LayerType* GetTransformParent(const DataForRecursion<LayerType>& data,
LayerType* layer) {
return PositionConstraint(layer).is_fixed_position()
? data.transform_fixed_parent
: data.transform_tree_parent;
}
template <typename LayerType>
static bool LayerClipsSubtree(LayerType* layer) {
return layer->masks_to_bounds() || MaskLayer(layer);
}
template <typename LayerType>
static int GetScrollParentId(const DataForRecursion<LayerType>& data,
LayerType* layer) {
const bool inherits_scroll = !ScrollParent(layer);
const int id = inherits_scroll ? data.scroll_tree_parent
: ScrollParent(layer)->scroll_tree_index();
return id;
}
static Layer* Parent(Layer* layer) {
return layer->parent();
}
static LayerImpl* Parent(LayerImpl* layer) {
return layer->test_properties()->parent;
}
static inline int SortingContextId(Layer* layer) {
return layer->sorting_context_id();
}
static inline int SortingContextId(LayerImpl* layer) {
return layer->test_properties()->sorting_context_id;
}
static inline bool Is3dSorted(Layer* layer) {
return layer->Is3dSorted();
}
static inline bool Is3dSorted(LayerImpl* layer) {
return layer->test_properties()->sorting_context_id != 0;
}
template <typename LayerType>
void AddClipNodeIfNeeded(const DataForRecursion<LayerType>& data_from_ancestor,
LayerType* layer,
bool created_transform_node,
DataForRecursion<LayerType>* data_for_children) {
const bool inherits_clip = !ClipParent(layer);
const int parent_id = inherits_clip ? data_from_ancestor.clip_tree_parent
: ClipParent(layer)->clip_tree_index();
bool layer_clips_subtree = LayerClipsSubtree(layer);
bool requires_node =
layer_clips_subtree || Filters(layer).HasFilterThatMovesPixels();
if (!requires_node) {
data_for_children->clip_tree_parent = parent_id;
} else {
LayerType* transform_parent = data_for_children->transform_tree_parent;
if (PositionConstraint(layer).is_fixed_position() &&
!created_transform_node) {
transform_parent = data_for_children->transform_fixed_parent;
}
ClipNode node;
node.clip = gfx::RectF(gfx::PointF() + layer->offset_to_transform_parent(),
gfx::SizeF(layer->bounds()));
node.transform_id = transform_parent->transform_tree_index();
node.owning_layer_id = layer->id();
if (layer_clips_subtree) {
node.clip_type = ClipNode::ClipType::APPLIES_LOCAL_CLIP;
} else {
DCHECK(Filters(layer).HasFilterThatMovesPixels());
node.clip_type = ClipNode::ClipType::EXPANDS_CLIP;
node.clip_expander =
base::MakeUnique<ClipExpander>(layer->effect_tree_index());
}
data_for_children->clip_tree_parent =
data_for_children->property_trees->clip_tree.Insert(node, parent_id);
data_for_children->property_trees->clip_tree.SetOwningLayerIdForNode(
data_for_children->property_trees->clip_tree.back(), layer->id());
}
layer->SetClipTreeIndex(data_for_children->clip_tree_parent);
}
template <typename LayerType>
static inline bool IsAtBoundaryOf3dRenderingContext(LayerType* layer) {
return Parent(layer)
? SortingContextId(Parent(layer)) != SortingContextId(layer)
: Is3dSorted(layer);
}
static inline gfx::Point3F TransformOrigin(Layer* layer) {
return layer->transform_origin();
}
static inline gfx::Point3F TransformOrigin(LayerImpl* layer) {
return layer->test_properties()->transform_origin;
}
static inline bool IsContainerForFixedPositionLayers(Layer* layer) {
return layer->IsContainerForFixedPositionLayers();
}
static inline bool IsContainerForFixedPositionLayers(LayerImpl* layer) {
return layer->test_properties()->is_container_for_fixed_position_layers;
}
static inline bool ShouldFlattenTransform(Layer* layer) {
return layer->should_flatten_transform();
}
static inline bool ShouldFlattenTransform(LayerImpl* layer) {
return layer->test_properties()->should_flatten_transform;
}
template <typename LayerType>
bool AddTransformNodeIfNeeded(
const DataForRecursion<LayerType>& data_from_ancestor,
LayerType* layer,
bool created_render_surface,
DataForRecursion<LayerType>* data_for_children) {
const bool is_root = !Parent(layer);
const bool is_page_scale_layer = layer == data_from_ancestor.page_scale_layer;
const bool is_overscroll_elasticity_layer =
layer == data_from_ancestor.overscroll_elasticity_layer;
const bool is_scrollable = layer->scrollable();
const bool is_fixed = PositionConstraint(layer).is_fixed_position();
const bool is_sticky = StickyPositionConstraint(layer).is_sticky;
const bool is_snapped = layer->IsSnapped();
const bool has_significant_transform =
!Transform(layer).IsIdentityOr2DTranslation();
const bool has_potentially_animated_transform =
HasPotentiallyRunningTransformAnimation(layer);
// A transform node is needed even for a finished animation, since differences
// in the timing of animation state updates can mean that an animation that's
// in the Finished state at tree-building time on the main thread is still in
// the Running state right after commit on the compositor thread.
const bool has_any_transform_animation =
HasAnyAnimationTargetingProperty(layer, TargetProperty::TRANSFORM);
const bool has_proxied_transform_related_property =
!!(layer->mutable_properties() & MutableProperty::kTransformRelated);
const bool has_surface = created_render_surface;
// A transform node is needed to change the render target for subtree when
// a scroll child's render target is different from the scroll parent's render
// target.
const bool scroll_child_has_different_target =
ScrollParent(layer) &&
Parent(layer)->effect_tree_index() !=
ScrollParent(layer)->effect_tree_index();
const bool is_at_boundary_of_3d_rendering_context =
IsAtBoundaryOf3dRenderingContext(layer);
DCHECK(!is_scrollable || is_snapped);
bool requires_node = is_root || is_snapped || has_significant_transform ||
has_any_transform_animation || has_surface || is_fixed ||
is_page_scale_layer || is_overscroll_elasticity_layer ||
has_proxied_transform_related_property ||
scroll_child_has_different_target || is_sticky ||
is_at_boundary_of_3d_rendering_context;
int parent_index = TransformTree::kRootNodeId;
int source_index = TransformTree::kRootNodeId;
gfx::Vector2dF source_offset;
LayerType* transform_parent = GetTransformParent(data_from_ancestor, layer);
DCHECK_EQ(is_root, !transform_parent);
if (transform_parent) {
parent_index = transform_parent->transform_tree_index();
// Because Blink still provides positions with respect to the parent layer,
// we track both a parent TransformNode (which is the parent in the
// TransformTree) and a 'source' TransformNode (which is the TransformNode
// for the parent in the Layer tree).
source_index = Parent(layer)->transform_tree_index();
source_offset = Parent(layer)->offset_to_transform_parent();
}
if (IsContainerForFixedPositionLayers(layer) || is_root) {
data_for_children->affected_by_inner_viewport_bounds_delta =
layer == data_from_ancestor.inner_viewport_scroll_layer;
data_for_children->affected_by_outer_viewport_bounds_delta =
layer == data_from_ancestor.outer_viewport_scroll_layer;
if (is_scrollable) {
DCHECK(!is_root);
DCHECK(Transform(layer).IsIdentity());
data_for_children->transform_fixed_parent = Parent(layer);
} else {
data_for_children->transform_fixed_parent = layer;
}
}
data_for_children->transform_tree_parent = layer;
if (!requires_node) {
data_for_children->should_flatten |= ShouldFlattenTransform(layer);
gfx::Vector2dF local_offset = layer->position().OffsetFromOrigin() +
Transform(layer).To2dTranslation();
gfx::Vector2dF source_to_parent;
if (source_index != parent_index) {
gfx::Transform to_parent;
data_from_ancestor.property_trees->transform_tree.ComputeTranslation(
source_index, parent_index, &to_parent);
source_to_parent = to_parent.To2dTranslation();
}
layer->set_offset_to_transform_parent(source_offset + source_to_parent +
local_offset);
layer->set_should_flatten_transform_from_property_tree(
data_from_ancestor.should_flatten);
layer->SetTransformTreeIndex(parent_index);
return false;
}
data_for_children->property_trees->transform_tree.Insert(TransformNode(),
parent_index);
TransformNode* node =
data_for_children->property_trees->transform_tree.back();
layer->SetTransformTreeIndex(node->id);
data_for_children->property_trees->transform_tree.SetOwningLayerIdForNode(
node, layer->id());
// For animation subsystem purposes, if this layer has a compositor element
// id, we build a map from that id to this transform node.
if (layer->element_id()) {
data_for_children->property_trees
->element_id_to_transform_node_index[layer->element_id()] = node->id;
}
node->scrolls = is_scrollable;
node->should_be_snapped = is_snapped;
node->flattens_inherited_transform = data_for_children->should_flatten;
node->sorting_context_id = SortingContextId(layer);
if (layer == data_from_ancestor.page_scale_layer)
data_for_children->in_subtree_of_page_scale_layer = true;
node->in_subtree_of_page_scale_layer =
data_for_children->in_subtree_of_page_scale_layer;
// Surfaces inherently flatten transforms.
data_for_children->should_flatten =
ShouldFlattenTransform(layer) || has_surface;
DCHECK_GT(data_from_ancestor.property_trees->effect_tree.size(), 0u);
node->has_potential_animation = has_potentially_animated_transform;
node->is_currently_animating = TransformIsAnimating(layer);
if (has_potentially_animated_transform) {
node->has_only_translation_animations =
HasOnlyTranslationTransforms(layer);
}
float post_local_scale_factor = 1.0f;
if (is_page_scale_layer) {
if (!is_root)
post_local_scale_factor *= data_from_ancestor.page_scale_factor;
data_for_children->property_trees->transform_tree.set_page_scale_factor(
data_from_ancestor.page_scale_factor);
}
node->source_node_id = source_index;
node->post_local_scale_factor = post_local_scale_factor;
if (is_root) {
float page_scale_factor_for_root =
is_page_scale_layer ? data_from_ancestor.page_scale_factor : 1.f;
data_for_children->property_trees->transform_tree
.SetRootTransformsAndScales(data_for_children->property_trees
->transform_tree.device_scale_factor(),
page_scale_factor_for_root,
*data_from_ancestor.device_transform,
layer->position());
} else {
node->source_offset = source_offset;
node->update_post_local_transform(layer->position(),
TransformOrigin(layer));
}
if (is_overscroll_elasticity_layer) {
DCHECK(!is_scrollable);
node->scroll_offset =
gfx::ScrollOffset(data_from_ancestor.elastic_overscroll);
} else if (!ScrollParent(layer)) {
node->scroll_offset = layer->CurrentScrollOffset();
}
if (is_fixed) {
if (data_from_ancestor.affected_by_inner_viewport_bounds_delta) {
node->moved_by_inner_viewport_bounds_delta_x =
PositionConstraint(layer).is_fixed_to_right_edge();
node->moved_by_inner_viewport_bounds_delta_y =
PositionConstraint(layer).is_fixed_to_bottom_edge();
if (node->moved_by_inner_viewport_bounds_delta_x ||
node->moved_by_inner_viewport_bounds_delta_y) {
data_for_children->property_trees->transform_tree
.AddNodeAffectedByInnerViewportBoundsDelta(node->id);
}
} else if (data_from_ancestor.affected_by_outer_viewport_bounds_delta) {
node->moved_by_outer_viewport_bounds_delta_x =
PositionConstraint(layer).is_fixed_to_right_edge();
node->moved_by_outer_viewport_bounds_delta_y =
PositionConstraint(layer).is_fixed_to_bottom_edge();
if (node->moved_by_outer_viewport_bounds_delta_x ||
node->moved_by_outer_viewport_bounds_delta_y) {
data_for_children->property_trees->transform_tree
.AddNodeAffectedByOuterViewportBoundsDelta(node->id);
}
}
}
node->local = Transform(layer);
node->update_pre_local_transform(TransformOrigin(layer));
if (StickyPositionConstraint(layer).is_sticky) {
StickyPositionNodeData* sticky_data =
data_for_children->property_trees->transform_tree.StickyPositionData(
node->id);
sticky_data->constraints = StickyPositionConstraint(layer);
sticky_data->scroll_ancestor = GetScrollParentId(data_from_ancestor, layer);
ScrollNode* scroll_ancestor =
data_for_children->property_trees->scroll_tree.Node(
sticky_data->scroll_ancestor);
if (sticky_data->constraints.is_anchored_right ||
sticky_data->constraints.is_anchored_bottom) {
// Sticky nodes whose ancestor scroller is the inner / outer viewport
// need to have their local transform updated when the inner / outer
// viewport bounds change, but do not unconditionally move by that delta
// like fixed position nodes.
if (scroll_ancestor->scrolls_inner_viewport) {
data_for_children->property_trees->transform_tree
.AddNodeAffectedByInnerViewportBoundsDelta(node->id);
} else if (scroll_ancestor->scrolls_outer_viewport) {
data_for_children->property_trees->transform_tree
.AddNodeAffectedByOuterViewportBoundsDelta(node->id);
}
}
// TODO(smcgruer): Pass main thread sticky-shifting offsets of
// non-promoted ancestors, or promote all ancestor sticky elements.
// See http://crbug.com/702229
sticky_data->main_thread_offset =
layer->position().OffsetFromOrigin() -
sticky_data->constraints.parent_relative_sticky_box_offset
.OffsetFromOrigin();
// Copy the ancestor nodes for later use. These layers are guaranteed to
// have transform nodes at this point because they are our ancestors (so
// have already been processed) and are sticky (so have transform nodes).
int shifting_sticky_box_layer_id =
sticky_data->constraints.nearest_layer_shifting_sticky_box;
if (shifting_sticky_box_layer_id != Layer::INVALID_ID) {
sticky_data->nearest_node_shifting_sticky_box =
data_for_children->property_trees->transform_tree
.FindNodeIndexFromOwningLayerId(shifting_sticky_box_layer_id);
DCHECK(sticky_data->nearest_node_shifting_sticky_box !=
TransformTree::kInvalidNodeId);
}
int shifting_containing_block_layer_id =
sticky_data->constraints.nearest_layer_shifting_containing_block;
if (shifting_containing_block_layer_id != Layer::INVALID_ID) {
sticky_data->nearest_node_shifting_containing_block =
data_for_children->property_trees->transform_tree
.FindNodeIndexFromOwningLayerId(
shifting_containing_block_layer_id);
DCHECK(sticky_data->nearest_node_shifting_containing_block !=
TransformTree::kInvalidNodeId);
}
}
node->needs_local_transform_update = true;
data_from_ancestor.property_trees->transform_tree.UpdateTransforms(node->id);
layer->set_offset_to_transform_parent(gfx::Vector2dF());
// Flattening (if needed) will be handled by |node|.
layer->set_should_flatten_transform_from_property_tree(false);
node->owning_layer_id = layer->id();
return true;
}
static inline bool HasPotentialOpacityAnimation(Layer* layer) {
return HasPotentiallyRunningOpacityAnimation(layer) ||
layer->OpacityCanAnimateOnImplThread();
}
static inline bool HasPotentialOpacityAnimation(LayerImpl* layer) {
return HasPotentiallyRunningOpacityAnimation(layer) ||
layer->test_properties()->opacity_can_animate;
}
static inline bool DoubleSided(Layer* layer) {
return layer->double_sided();
}
static inline bool DoubleSided(LayerImpl* layer) {
return layer->test_properties()->double_sided;
}
static inline bool ForceRenderSurface(Layer* layer) {
return layer->force_render_surface_for_testing();
}
static inline bool ForceRenderSurface(LayerImpl* layer) {
return layer->test_properties()->force_render_surface;
}
template <typename LayerType>
static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
return Is3dSorted(layer) && Parent(layer) && Is3dSorted(Parent(layer)) &&
(SortingContextId(Parent(layer)) == SortingContextId(layer));
}
static inline bool IsRootForIsolatedGroup(Layer* layer) {
return layer->is_root_for_isolated_group();
}
static inline bool IsRootForIsolatedGroup(LayerImpl* layer) {
return false;
}
static inline int NumDescendantsThatDrawContent(Layer* layer) {
return layer->NumDescendantsThatDrawContent();
}
static inline int NumLayerOrDescendantsThatDrawContentRecursive(
LayerImpl* layer) {
int num = layer->DrawsContent() ? 1 : 0;
for (size_t i = 0; i < layer->test_properties()->children.size(); ++i) {
LayerImpl* child_layer = layer->test_properties()->children[i];
num += NumLayerOrDescendantsThatDrawContentRecursive(child_layer);
}
return num;
}
static inline int NumDescendantsThatDrawContent(LayerImpl* layer) {
int num_descendants_that_draw_content = 0;
for (size_t i = 0; i < layer->test_properties()->children.size(); ++i) {
LayerImpl* child_layer = layer->test_properties()->children[i];
num_descendants_that_draw_content +=
NumLayerOrDescendantsThatDrawContentRecursive(child_layer);
}
return num_descendants_that_draw_content;
}
static inline float EffectiveOpacity(Layer* layer) {
return layer->EffectiveOpacity();
}
static inline float EffectiveOpacity(LayerImpl* layer) {
return layer->test_properties()->hide_layer_and_subtree
? 0.f
: layer->test_properties()->opacity;
}
static inline float Opacity(Layer* layer) {
return layer->opacity();
}
static inline float Opacity(LayerImpl* layer) {
return layer->test_properties()->opacity;
}
static inline SkBlendMode BlendMode(Layer* layer) {
return layer->blend_mode();
}
static inline SkBlendMode BlendMode(LayerImpl* layer) {
return layer->test_properties()->blend_mode;
}
static inline const gfx::PointF FiltersOrigin(Layer* layer) {
return layer->filters_origin();
}
static inline const gfx::PointF FiltersOrigin(LayerImpl* layer) {
return layer->test_properties()->filters_origin;
}
static inline const FilterOperations& BackgroundFilters(Layer* layer) {
return layer->background_filters();
}
static inline const FilterOperations& BackgroundFilters(LayerImpl* layer) {
return layer->test_properties()->background_filters;
}
static inline bool HideLayerAndSubtree(Layer* layer) {
return layer->hide_layer_and_subtree();
}
static inline bool HideLayerAndSubtree(LayerImpl* layer) {
return layer->test_properties()->hide_layer_and_subtree;
}
static inline bool AlwaysUseActiveTreeOpacity(Layer* layer) {
return layer->AlwaysUseActiveTreeOpacity();
}
static inline bool AlwaysUseActiveTreeOpacity(LayerImpl* layer) {
return false;
}
static inline bool HasCopyRequest(Layer* layer) {
return layer->HasCopyRequest();
}
static inline bool HasCopyRequest(LayerImpl* layer) {
return !layer->test_properties()->copy_requests.empty();
}
static inline bool PropertyChanged(Layer* layer) {
return layer->subtree_property_changed();
}
static inline bool PropertyChanged(LayerImpl* layer) {
return false;
}
template <typename LayerType>
bool ShouldCreateRenderSurface(LayerType* layer,
gfx::Transform current_transform,
bool axis_aligned) {
const bool preserves_2d_axis_alignment =
(current_transform * Transform(layer)).Preserves2dAxisAlignment() &&
axis_aligned && AnimationsPreserveAxisAlignment(layer);
const bool is_root = !Parent(layer);
if (is_root)
return true;
// If the layer uses a mask.
if (MaskLayer(layer)) {
return true;
}
// If the layer uses a CSS filter.
if (!Filters(layer).IsEmpty() || !BackgroundFilters(layer).IsEmpty()) {
return true;
}
// If the layer will use a CSS filter. In this case, the animation
// will start and add a filter to this layer, so it needs a surface.
if (HasPotentiallyRunningFilterAnimation(layer)) {
return true;
}
int num_descendants_that_draw_content = NumDescendantsThatDrawContent(layer);
// If the layer flattens its subtree, but it is treated as a 3D object by its
// parent (i.e. parent participates in a 3D rendering context).
if (LayerIsInExisting3DRenderingContext(layer) &&
ShouldFlattenTransform(layer) && num_descendants_that_draw_content > 0) {
TRACE_EVENT_INSTANT0(
"cc", "PropertyTreeBuilder::ShouldCreateRenderSurface flattening",
TRACE_EVENT_SCOPE_THREAD);
return true;
}
// If the layer has blending.
// TODO(rosca): this is temporary, until blending is implemented for other
// types of quads than RenderPassDrawQuad. Layers having descendants that draw
// content will still create a separate rendering surface.
if (BlendMode(layer) != SkBlendMode::kSrcOver) {
TRACE_EVENT_INSTANT0(
"cc", "PropertyTreeBuilder::ShouldCreateRenderSurface blending",
TRACE_EVENT_SCOPE_THREAD);
return true;
}
// If the layer clips its descendants but it is not axis-aligned with respect
// to its parent.
bool layer_clips_external_content = LayerClipsSubtree(layer);
if (layer_clips_external_content && !preserves_2d_axis_alignment &&
num_descendants_that_draw_content > 0) {
TRACE_EVENT_INSTANT0(
"cc", "PropertyTreeBuilder::ShouldCreateRenderSurface clipping",
TRACE_EVENT_SCOPE_THREAD);
return true;
}
// If the layer has some translucency and does not have a preserves-3d
// transform style. This condition only needs a render surface if two or more
// layers in the subtree overlap. But checking layer overlaps is unnecessarily
// costly so instead we conservatively create a surface whenever at least two
// layers draw content for this subtree.
bool at_least_two_layers_in_subtree_draw_content =
num_descendants_that_draw_content > 0 &&
(layer->DrawsContent() || num_descendants_that_draw_content > 1);
bool may_have_transparency = EffectiveOpacity(layer) != 1.f ||
HasPotentiallyRunningOpacityAnimation(layer);
if (may_have_transparency && ShouldFlattenTransform(layer) &&
at_least_two_layers_in_subtree_draw_content) {
TRACE_EVENT_INSTANT0(
"cc", "PropertyTreeBuilder::ShouldCreateRenderSurface opacity",
TRACE_EVENT_SCOPE_THREAD);
DCHECK(!is_root);
return true;
}
// If the layer has isolation.
// TODO(rosca): to be optimized - create separate rendering surface only when
// the blending descendants might have access to the content behind this layer
// (layer has transparent background or descendants overflow).
// https://code.google.com/p/chromium/issues/detail?id=301738
if (IsRootForIsolatedGroup(layer)) {
TRACE_EVENT_INSTANT0(
"cc", "PropertyTreeBuilder::ShouldCreateRenderSurface isolation",
TRACE_EVENT_SCOPE_THREAD);
return true;
}
// If we force it.
if (ForceRenderSurface(layer))
return true;
// If we'll make a copy of the layer's contents.
if (HasCopyRequest(layer))
return true;
return false;
}
static void TakeCopyRequests(
Layer* layer,
std::vector<std::unique_ptr<CopyOutputRequest>>* copy_requests) {
layer->TakeCopyRequests(copy_requests);
}
static void TakeCopyRequests(
LayerImpl* layer,
std::vector<std::unique_ptr<CopyOutputRequest>>* copy_requests) {
for (auto& request : layer->test_properties()->copy_requests)
copy_requests->push_back(std::move(request));
layer->test_properties()->copy_requests.clear();
}
static void SetSubtreeHasCopyRequest(Layer* layer,
bool subtree_has_copy_request) {
layer->SetSubtreeHasCopyRequest(subtree_has_copy_request);
}
static void SetSubtreeHasCopyRequest(LayerImpl* layer,
bool subtree_has_copy_request) {
layer->test_properties()->subtree_has_copy_request = subtree_has_copy_request;
}
static bool SubtreeHasCopyRequest(Layer* layer) {
return layer->SubtreeHasCopyRequest();
}
static bool SubtreeHasCopyRequest(LayerImpl* layer) {
return layer->test_properties()->subtree_has_copy_request;
}
template <typename LayerType>
bool UpdateSubtreeHasCopyRequestRecursive(LayerType* layer) {
bool subtree_has_copy_request = false;
if (HasCopyRequest(layer))
subtree_has_copy_request = true;
for (size_t i = 0; i < Children(layer).size(); ++i) {
LayerType* current_child = ChildAt(layer, i);
subtree_has_copy_request |=
UpdateSubtreeHasCopyRequestRecursive(current_child);
}
SetSubtreeHasCopyRequest(layer, subtree_has_copy_request);
return subtree_has_copy_request;
}
template <typename LayerType>
bool AddEffectNodeIfNeeded(
const DataForRecursion<LayerType>& data_from_ancestor,
LayerType* layer,
DataForRecursion<LayerType>* data_for_children) {
const bool is_root = !Parent(layer);
const bool has_transparency = EffectiveOpacity(layer) != 1.f;
const bool has_potential_opacity_animation =
HasPotentialOpacityAnimation(layer);
const bool has_potential_filter_animation =
HasPotentiallyRunningFilterAnimation(layer);
const bool has_proxied_opacity =
!!(layer->mutable_properties() & MutableProperty::kOpacity);
const bool should_create_render_surface = ShouldCreateRenderSurface(
layer, data_from_ancestor.compound_transform_since_render_target,
data_from_ancestor.axis_align_since_render_target);
data_for_children->axis_align_since_render_target &=
AnimationsPreserveAxisAlignment(layer);
bool requires_node = is_root || has_transparency ||
has_potential_opacity_animation || has_proxied_opacity ||
should_create_render_surface;
int parent_id = data_from_ancestor.effect_tree_parent;
if (!requires_node) {
layer->SetEffectTreeIndex(parent_id);
data_for_children->effect_tree_parent = parent_id;
data_for_children->compound_transform_since_render_target *=
Transform(layer);
return false;
}
EffectNode node;
node.owning_layer_id = layer->id();
if (AlwaysUseActiveTreeOpacity(layer)) {
data_for_children->property_trees->always_use_active_tree_opacity_effect_ids
.push_back(node.owning_layer_id);
}
node.opacity = Opacity(layer);
node.blend_mode = BlendMode(layer);
node.unscaled_mask_target_size = layer->bounds();
node.has_render_surface = should_create_render_surface;
node.has_copy_request = HasCopyRequest(layer);
node.filters = Filters(layer);
node.background_filters = BackgroundFilters(layer);
node.filters_origin = FiltersOrigin(layer);
node.has_potential_opacity_animation = has_potential_opacity_animation;
node.has_potential_filter_animation = has_potential_filter_animation;
node.double_sided = DoubleSided(layer);
node.subtree_hidden = HideLayerAndSubtree(layer);
node.is_currently_animating_opacity = OpacityIsAnimating(layer);
node.is_currently_animating_filter = FilterIsAnimating(layer);
node.effect_changed = PropertyChanged(layer);
node.subtree_has_copy_request = SubtreeHasCopyRequest(layer);
EffectTree& effect_tree = data_for_children->property_trees->effect_tree;
if (MaskLayer(layer)) {
node.mask_layer_id = MaskLayer(layer)->id();
effect_tree.AddMaskLayerId(node.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
// surface.
if (should_create_render_surface) {
// In this case, we will create a transform node, so it's safe to use the
// next available id from the transform tree as this effect node's
// transform id.
node.transform_id =
data_from_ancestor.property_trees->transform_tree.next_available_id();
}
node.clip_id = data_from_ancestor.clip_tree_parent;
} else {
// Root render surface acts the unbounded and untransformed to draw content
// into. Transform node created from root layer (includes device scale
// factor) and clip node created from root layer (include viewports) applies
// to root render surface's content, but not root render surface itself.
node.transform_id = TransformTree::kRootNodeId;
node.clip_id = ClipTree::kViewportNodeId;
}
int node_id = effect_tree.Insert(node, parent_id);
data_for_children->effect_tree_parent = node_id;
layer->SetEffectTreeIndex(node_id);
data_for_children->property_trees->effect_tree.SetOwningLayerIdForNode(
effect_tree.back(), layer->id());
// For animation subsystem purposes, if this layer has a compositor element
// id, we build a map from that id to this effect node.
if (layer->element_id()) {
data_for_children->property_trees
->element_id_to_effect_node_index[layer->element_id()] = node_id;
}
std::vector<std::unique_ptr<CopyOutputRequest>> layer_copy_requests;
TakeCopyRequests(layer, &layer_copy_requests);
for (auto& it : layer_copy_requests) {
effect_tree.AddCopyRequest(node_id, std::move(it));
}
layer_copy_requests.clear();
if (should_create_render_surface) {
data_for_children->compound_transform_since_render_target =
gfx::Transform();
data_for_children->axis_align_since_render_target = true;
}
return should_create_render_surface;
}
template <typename LayerType>
void AddScrollNodeIfNeeded(
const DataForRecursion<LayerType>& data_from_ancestor,
LayerType* layer,
DataForRecursion<LayerType>* data_for_children) {
int parent_id = GetScrollParentId(data_from_ancestor, layer);
bool is_root = !Parent(layer);
bool scrollable = layer->scrollable();
bool contains_non_fast_scrollable_region =
!layer->non_fast_scrollable_region().IsEmpty();
uint32_t main_thread_scrolling_reasons =
layer->main_thread_scrolling_reasons();
bool scroll_node_uninheritable_criteria =
is_root || scrollable || contains_non_fast_scrollable_region;
bool has_different_main_thread_scrolling_reasons =
main_thread_scrolling_reasons !=
data_from_ancestor.main_thread_scrolling_reasons;
bool requires_node =
scroll_node_uninheritable_criteria ||
(main_thread_scrolling_reasons !=
MainThreadScrollingReason::kNotScrollingOnMain &&
(has_different_main_thread_scrolling_reasons ||
data_from_ancestor
.scroll_tree_parent_created_by_uninheritable_criteria));
int node_id;
if (!requires_node) {
node_id = parent_id;
data_for_children->scroll_tree_parent = node_id;
} else {
ScrollNode node;
node.owning_layer_id = layer->id();
node.scrollable = scrollable;
node.main_thread_scrolling_reasons = main_thread_scrolling_reasons;
node.non_fast_scrollable_region = layer->non_fast_scrollable_region();
gfx::Size clip_bounds;
if (LayerType* scroll_clip_layer = layer->scroll_clip_layer()) {
SetIsScrollClipLayer(scroll_clip_layer);
clip_bounds = scroll_clip_layer->bounds();
DCHECK(scroll_clip_layer->transform_tree_index() !=
TransformTree::kInvalidNodeId);
node.max_scroll_offset_affected_by_page_scale =
!data_from_ancestor.property_trees->transform_tree
.Node(scroll_clip_layer->transform_tree_index())
->in_subtree_of_page_scale_layer &&
data_from_ancestor.in_subtree_of_page_scale_layer;
}
node.scroll_clip_layer_bounds = clip_bounds;
node.scrolls_inner_viewport =
layer == data_from_ancestor.inner_viewport_scroll_layer;
node.scrolls_outer_viewport =
layer == data_from_ancestor.outer_viewport_scroll_layer;
node.bounds = layer->bounds();
node.offset_to_transform_parent = layer->offset_to_transform_parent();
node.should_flatten = layer->should_flatten_transform_from_property_tree();
node.user_scrollable_horizontal = layer->user_scrollable_horizontal();
node.user_scrollable_vertical = layer->user_scrollable_vertical();
node.element_id = layer->element_id();
node.transform_id =
data_for_children->transform_tree_parent->transform_tree_index();
node_id =
data_for_children->property_trees->scroll_tree.Insert(node, parent_id);
data_for_children->scroll_tree_parent = node_id;
data_for_children->main_thread_scrolling_reasons =
node.main_thread_scrolling_reasons;
data_for_children->scroll_tree_parent_created_by_uninheritable_criteria =
scroll_node_uninheritable_criteria;
data_for_children->property_trees->scroll_tree.SetOwningLayerIdForNode(
data_for_children->property_trees->scroll_tree.back(), layer->id());
// For animation subsystem purposes, if this layer has a compositor element
// id, we build a map from that id to this scroll node.
if (layer->element_id()) {
data_for_children->property_trees
->element_id_to_scroll_node_index[layer->element_id()] = node_id;
}
if (node.scrollable) {
data_for_children->property_trees->scroll_tree.SetBaseScrollOffset(
layer->id(), layer->CurrentScrollOffset());
}
}
layer->SetScrollTreeIndex(node_id);
}
template <typename LayerType>
void SetBackfaceVisibilityTransform(LayerType* layer,
bool created_transform_node) {
const bool is_at_boundary_of_3d_rendering_context =
IsAtBoundaryOf3dRenderingContext(layer);
if (layer->use_parent_backface_visibility()) {
DCHECK(!is_at_boundary_of_3d_rendering_context);
DCHECK(Parent(layer));
DCHECK(!Parent(layer)->use_parent_backface_visibility());
layer->SetUseLocalTransformForBackfaceVisibility(
Parent(layer)->use_local_transform_for_backface_visibility());
layer->SetShouldCheckBackfaceVisibility(
Parent(layer)->should_check_backface_visibility());
} else {
// The current W3C spec on CSS transforms says that backface visibility
// should be determined differently depending on whether the layer is in a
// "3d rendering context" or not. For Chromium code, we can determine
// whether we are in a 3d rendering context by checking if the parent
// preserves 3d.
const bool use_local_transform =
!Is3dSorted(layer) ||
(Is3dSorted(layer) && is_at_boundary_of_3d_rendering_context);
layer->SetUseLocalTransformForBackfaceVisibility(use_local_transform);
// A double-sided layer's backface can been shown when its visibile.
if (DoubleSided(layer))
layer->SetShouldCheckBackfaceVisibility(false);
// The backface of a layer that uses local transform for backface visibility
// is not visible when it does not create a transform node as its local
// transform is identity or 2d translation and is not animating.
else if (use_local_transform && !created_transform_node)
layer->SetShouldCheckBackfaceVisibility(false);
else
layer->SetShouldCheckBackfaceVisibility(true);
}
}
template <typename LayerType>
void SetSafeOpaqueBackgroundColor(
const DataForRecursion<LayerType>& data_from_ancestor,
LayerType* layer,
DataForRecursion<LayerType>* data_for_children) {
SkColor background_color = layer->background_color();
data_for_children->safe_opaque_background_color =
SkColorGetA(background_color) == 255
? background_color
: data_from_ancestor.safe_opaque_background_color;
layer->SetSafeOpaqueBackgroundColor(
data_for_children->safe_opaque_background_color);
}
static void SetLayerPropertyChangedForChild(Layer* parent, Layer* child) {
if (parent->subtree_property_changed())
child->SetSubtreePropertyChanged();
}
static void SetLayerPropertyChangedForChild(LayerImpl* parent,
LayerImpl* child) {}
template <typename LayerType>
void BuildPropertyTreesInternal(
LayerType* layer,
const DataForRecursion<LayerType>& data_from_parent) {
layer->set_property_tree_sequence_number(
data_from_parent.property_trees->sequence_number);
DataForRecursion<LayerType> data_for_children(data_from_parent);
bool created_render_surface =
AddEffectNodeIfNeeded(data_from_parent, layer, &data_for_children);
if (created_render_surface)
data_for_children.render_target = data_for_children.effect_tree_parent;
bool created_transform_node = AddTransformNodeIfNeeded(
data_from_parent, layer, created_render_surface, &data_for_children);
AddClipNodeIfNeeded(data_from_parent, layer, created_transform_node,
&data_for_children);
AddScrollNodeIfNeeded(data_from_parent, layer, &data_for_children);
SetBackfaceVisibilityTransform(layer, created_transform_node);
SetSafeOpaqueBackgroundColor(data_from_parent, layer, &data_for_children);
for (size_t i = 0; i < Children(layer).size(); ++i) {
LayerType* current_child = ChildAt(layer, i);
SetLayerPropertyChangedForChild(layer, current_child);
if (!ScrollParent(current_child)) {
BuildPropertyTreesInternal(current_child, data_for_children);
} else {
// The child should be included in its scroll parent's list of scroll
// children.
DCHECK(ScrollChildren(ScrollParent(current_child))->count(current_child));
}
}
if (ScrollChildren(layer)) {
for (LayerType* scroll_child : *ScrollChildren(layer)) {
DCHECK_EQ(ScrollParent(scroll_child), layer);
DCHECK(Parent(scroll_child));
data_for_children.effect_tree_parent =
Parent(scroll_child)->effect_tree_index();
data_for_children.render_target =
Parent(scroll_child)->effect_tree_index();
BuildPropertyTreesInternal(scroll_child, data_for_children);
}
}
if (MaskLayer(layer)) {
MaskLayer(layer)->set_property_tree_sequence_number(
data_from_parent.property_trees->sequence_number);
MaskLayer(layer)->set_offset_to_transform_parent(
layer->offset_to_transform_parent());
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());
}
}
} // namespace
Layer* PropertyTreeBuilder::FindFirstScrollableLayer(Layer* layer) {
if (!layer)
return nullptr;
if (layer->scrollable())
return layer;
for (size_t i = 0; i < layer->children().size(); ++i) {
Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
if (found)
return found;
}
return nullptr;
}
template <typename LayerType>
void BuildPropertyTreesTopLevelInternal(
LayerType* root_layer,
const LayerType* page_scale_layer,
const LayerType* inner_viewport_scroll_layer,
const LayerType* outer_viewport_scroll_layer,
const LayerType* overscroll_elasticity_layer,
const gfx::Vector2dF& elastic_overscroll,
float page_scale_factor,
float device_scale_factor,
const gfx::Rect& viewport,
const gfx::Transform& device_transform,
PropertyTrees* property_trees,
SkColor color) {
if (!property_trees->needs_rebuild) {
draw_property_utils::UpdatePageScaleFactor(
property_trees, page_scale_layer, page_scale_factor,
device_scale_factor, device_transform);
draw_property_utils::UpdateElasticOverscroll(
property_trees, overscroll_elasticity_layer, elastic_overscroll);
property_trees->clip_tree.SetViewportClip(gfx::RectF(viewport));
float page_scale_factor_for_root =
page_scale_layer == root_layer ? page_scale_factor : 1.f;
property_trees->transform_tree.SetRootTransformsAndScales(
device_scale_factor, page_scale_factor_for_root, device_transform,
root_layer->position());
return;
}
DataForRecursion<LayerType> data_for_recursion;
data_for_recursion.property_trees = property_trees;
data_for_recursion.transform_tree_parent = nullptr;
data_for_recursion.transform_fixed_parent = nullptr;
data_for_recursion.render_target = EffectTree::kRootNodeId;
data_for_recursion.clip_tree_parent = ClipTree::kRootNodeId;
data_for_recursion.effect_tree_parent = EffectTree::kInvalidNodeId;
data_for_recursion.scroll_tree_parent = ScrollTree::kRootNodeId;
data_for_recursion.page_scale_layer = page_scale_layer;
data_for_recursion.inner_viewport_scroll_layer = inner_viewport_scroll_layer;
data_for_recursion.outer_viewport_scroll_layer = outer_viewport_scroll_layer;
data_for_recursion.overscroll_elasticity_layer = overscroll_elasticity_layer;
data_for_recursion.elastic_overscroll = elastic_overscroll;
data_for_recursion.page_scale_factor = page_scale_factor;
data_for_recursion.in_subtree_of_page_scale_layer = false;
data_for_recursion.affected_by_inner_viewport_bounds_delta = false;
data_for_recursion.affected_by_outer_viewport_bounds_delta = false;
data_for_recursion.should_flatten = false;
data_for_recursion.is_hidden = false;
data_for_recursion.main_thread_scrolling_reasons =
MainThreadScrollingReason::kNotScrollingOnMain;
data_for_recursion.scroll_tree_parent_created_by_uninheritable_criteria =
true;
data_for_recursion.device_transform = &device_transform;
data_for_recursion.property_trees->clear();
data_for_recursion.compound_transform_since_render_target = gfx::Transform();
data_for_recursion.axis_align_since_render_target = true;
data_for_recursion.property_trees->transform_tree.set_device_scale_factor(
device_scale_factor);
data_for_recursion.safe_opaque_background_color = color;
ClipNode root_clip;
root_clip.clip_type = ClipNode::ClipType::APPLIES_LOCAL_CLIP;
root_clip.clip = gfx::RectF(viewport);
root_clip.transform_id = TransformTree::kRootNodeId;
data_for_recursion.clip_tree_parent =
data_for_recursion.property_trees->clip_tree.Insert(
root_clip, ClipTree::kRootNodeId);
BuildPropertyTreesInternal(root_layer, data_for_recursion);
property_trees->needs_rebuild = false;
// The transform tree is kept up to date as it is built, but the
// combined_clips stored in the clip tree and the screen_space_opacity and
// is_drawn in the effect tree aren't computed during tree building.
property_trees->transform_tree.set_needs_update(false);
property_trees->clip_tree.set_needs_update(true);
property_trees->effect_tree.set_needs_update(true);
property_trees->scroll_tree.set_needs_update(false);
}
#if DCHECK_IS_ON()
static void CheckScrollAndClipPointersForLayer(Layer* layer) {
if (!layer)
return;
if (layer->scroll_children()) {
for (std::set<Layer*>::iterator it = layer->scroll_children()->begin();
it != layer->scroll_children()->end(); ++it) {
DCHECK_EQ((*it)->scroll_parent(), layer);
}
}
if (layer->clip_children()) {
for (std::set<Layer*>::iterator it = layer->clip_children()->begin();
it != layer->clip_children()->end(); ++it) {
DCHECK_EQ((*it)->clip_parent(), layer);
}
}
}
#endif
void PropertyTreeBuilder::BuildPropertyTrees(
Layer* root_layer,
const Layer* page_scale_layer,
const Layer* inner_viewport_scroll_layer,
const Layer* outer_viewport_scroll_layer,
const Layer* overscroll_elasticity_layer,
const gfx::Vector2dF& elastic_overscroll,
float page_scale_factor,
float device_scale_factor,
const gfx::Rect& viewport,
const gfx::Transform& device_transform,
PropertyTrees* property_trees) {
property_trees->is_main_thread = true;
property_trees->is_active = false;
SkColor color = root_layer->layer_tree_host()->background_color();
if (SkColorGetA(color) != 255)
color = SkColorSetA(color, 255);
if (root_layer->layer_tree_host()->has_copy_request())
UpdateSubtreeHasCopyRequestRecursive(root_layer);
BuildPropertyTreesTopLevelInternal(
root_layer, page_scale_layer, inner_viewport_scroll_layer,
outer_viewport_scroll_layer, overscroll_elasticity_layer,
elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
device_transform, property_trees, color);
#if DCHECK_IS_ON()
for (auto* layer : *root_layer->layer_tree_host())
CheckScrollAndClipPointersForLayer(layer);
#endif
property_trees->ResetCachedData();
// During building property trees, all copy requests are moved from layers to
// effect tree, which are then pushed at commit to compositor thread and
// handled there. LayerTreeHost::has_copy_request is only required to
// decide if we want to create a effect node. So, it can be reset now.
root_layer->layer_tree_host()->SetHasCopyRequest(false);
}
void PropertyTreeBuilder::BuildPropertyTrees(
LayerImpl* root_layer,
const LayerImpl* page_scale_layer,
const LayerImpl* inner_viewport_scroll_layer,
const LayerImpl* outer_viewport_scroll_layer,
const LayerImpl* overscroll_elasticity_layer,
const gfx::Vector2dF& elastic_overscroll,
float page_scale_factor,
float device_scale_factor,
const gfx::Rect& viewport,
const gfx::Transform& device_transform,
PropertyTrees* property_trees) {
// Preserve render surfaces when rebuilding.
std::vector<std::unique_ptr<RenderSurfaceImpl>> render_surfaces;
property_trees->effect_tree.TakeRenderSurfaces(&render_surfaces);
property_trees->is_main_thread = false;
property_trees->is_active = root_layer->IsActive();
SkColor color = root_layer->layer_tree_impl()->background_color();
if (SkColorGetA(color) != 255)
color = SkColorSetA(color, 255);
UpdateSubtreeHasCopyRequestRecursive(root_layer);
BuildPropertyTreesTopLevelInternal(
root_layer, page_scale_layer, inner_viewport_scroll_layer,
outer_viewport_scroll_layer, overscroll_elasticity_layer,
elastic_overscroll, page_scale_factor, device_scale_factor, viewport,
device_transform, property_trees, color);
property_trees->effect_tree.CreateOrReuseRenderSurfaces(
&render_surfaces, root_layer->layer_tree_impl());
property_trees->ResetCachedData();
}
} // namespace cc