property_tree_builder.cc | Explore in Territory

// Copyright 2014 The Chromium Authors
// 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 <memory>
#include <set>
#include <utility>
#include <vector>

#include "base/auto_reset.h"
#include "base/memory/raw_ptr.h"
#include "base/memory/raw_ref.h"
#include "cc/base/math_util.h"
#include "cc/layers/layer.h"
#include "cc/layers/layer_impl.h"
#include "cc/layers/picture_layer.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_host.h"
#include "cc/trees/layer_tree_settings.h"
#include "cc/trees/mutator_host.h"
#include "cc/trees/scroll_node.h"
#include "cc/trees/transform_node.h"
#include "components/viz/common/frame_sinks/copy_output_request.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/vector2d_conversions.h"

namespace cc {

namespace {

struct DataForRecursion { … };

class PropertyTreeBuilderContext { … };

// Methods to query state from the AnimationHost ----------------------
bool OpacityIsAnimating(const MutatorHost& host, Layer* layer) { … }

bool HasPotentiallyRunningOpacityAnimation(const MutatorHost& host,
                                           Layer* layer) { … }

bool HasPotentialOpacityAnimation(const MutatorHost& host, Layer* layer) { … }

bool FilterIsAnimating(const MutatorHost& host, Layer* layer) { … }

bool HasPotentiallyRunningFilterAnimation(const MutatorHost& host,
                                          Layer* layer) { … }

bool TransformIsAnimating(const MutatorHost& host, Layer* layer) { … }

bool HasPotentiallyRunningTransformAnimation(const MutatorHost& host,
                                             Layer* layer) { … }

float MaximumAnimationScale(const MutatorHost& host, Layer* layer) { … }

bool AnimationsPreserveAxisAlignment(const MutatorHost& host, Layer* layer) { … }

bool HasAnyAnimationTargetingProperty(const MutatorHost& host,
                                      Layer* layer,
                                      TargetProperty::Type property) { … }

// -------------------------------------------------------------------

bool LayerClipsSubtreeToItsBounds(Layer* layer) { … }

bool LayerClipsSubtree(Layer* layer) { … }

void PropertyTreeBuilderContext::AddClipNodeIfNeeded(
    const DataForRecursion& data_from_ancestor,
    Layer* layer,
    bool created_transform_node,
    DataForRecursion* data_for_children) const { … }

bool PropertyTreeBuilderContext::AddTransformNodeIfNeeded(
    const DataForRecursion& data_from_ancestor,
    Layer* layer,
    bool created_render_surface,
    DataForRecursion* data_for_children) const { … }

RenderSurfaceReason ComputeRenderSurfaceReason(const MutatorHost& mutator_host,
                                               Layer* layer,
                                               gfx::Transform current_transform,
                                               bool animation_axis_aligned) { … }

bool UpdateSubtreeHasCopyRequestRecursive(Layer* layer) { … }

bool PropertyTreeBuilderContext::AddEffectNodeIfNeeded(
    const DataForRecursion& data_from_ancestor,
    Layer* layer,
    DataForRecursion* data_for_children) const { … }

bool PropertyTreeBuilderContext::UpdateRenderSurfaceIfNeeded(
    int parent_effect_tree_id,
    DataForRecursion* data_for_children,
    bool is_rounded_corner_layer_within_parent_bounds,
    bool subtree_has_overlapping_rounded_corner,
    bool subtree_has_gradient_mask,
    bool created_transform_node) const { … }

bool PropertyTreeBuilderContext::IsRoundedCornerLayerWithinParentLayerBounds(
    const Layer* layer) const { … }

void PropertyTreeBuilderContext::AddScrollNodeIfNeeded(
    const DataForRecursion& data_from_ancestor,
    Layer* layer,
    DataForRecursion* data_for_children) const { … }

void SetSafeOpaqueBackgroundColor(const DataForRecursion& data_from_ancestor,
                                  Layer* layer,
                                  DataForRecursion* data_for_children) { … }

void PropertyTreeBuilderContext::BuildPropertyTreesInternal(
    Layer* layer,
    const DataForRecursion& data_from_parent) const { … }

void PropertyTreeBuilderContext::BuildPropertyTrees() { … }

}  // namespace

void PropertyTreeBuilder::BuildPropertyTrees(LayerTreeHost* layer_tree_host) { … }

}  // namespace cc
chromium/cc/trees/property_tree_builder.cc
