property_tree_test_utils.cc | Explore in Territory

// Copyright 2019 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/test/property_tree_test_utils.h"

#include <memory>
#include <utility>

#include "cc/layers/picture_layer.h"
#include "cc/layers/picture_layer_impl.h"
#include "cc/trees/clip_node.h"
#include "cc/trees/effect_node.h"
#include "cc/trees/layer_tree_host.h"
#include "cc/trees/layer_tree_impl.h"
#include "cc/trees/property_tree.h"
#include "cc/trees/scroll_node.h"
#include "cc/trees/transform_node.h"

namespace cc {

namespace {

template <typename LayerType>
void SetupRootPropertiesInternal(LayerType* root) { … }

template <typename LayerType>
void CopyPropertiesInternal(const LayerType* from, LayerType* to) { … }

// We use a macro instead of a function to avoid |default_id| (which is
// |layer->xxx_tree_index()|) from being evaluated when it's not used because
// |layer| may be null when |id| is valid.
#define ID_OR_DEFAULT(id, default_id) …

template <typename LayerType>
TransformNode& CreateTransformNodeInternal(LayerType* layer,
                                           PropertyTrees* property_trees,
                                           int parent_id) { … }

template <typename LayerType>
ClipNode& CreateClipNodeInternal(LayerType* layer,
                                 PropertyTrees* property_trees,
                                 int parent_id,
                                 int transform_id = kInvalidPropertyNodeId) { … }

template <typename LayerType>
EffectNode& CreateEffectNodeInternal(LayerType* layer,
                                     PropertyTrees* property_trees,
                                     int parent_id,
                                     int transform_id = kInvalidPropertyNodeId,
                                     int clip_id = kInvalidPropertyNodeId) { … }

template <typename LayerType>
ScrollNode& CreateScrollNodeInternal(LayerType* layer,
                                     const gfx::Size& scroll_container_bounds,
                                     int parent_id) { … }

template <typename LayerType, typename MaskLayerType>
void SetupMaskPropertiesInternal(LayerType* masked_layer,
                                 MaskLayerType* mask_layer) { … }

template <typename LayerType>
void SetScrollOffsetInternal(LayerType* layer,
                             const gfx::PointF& scroll_offset) { … }

// TODO(wangxianzhu): Viewport properties can exist without layers, but for now
// it's more convenient to create properties based on layers.
template <typename LayerType>
ViewportPropertyIds SetupViewportProperties(
    LayerType* root,
    LayerType* inner_viewport_scroll_layer,
    LayerType* outer_viewport_scroll_layer) { … }

}  // anonymous namespace

void SetupRootProperties(Layer* root) { … }

void SetupRootProperties(LayerImpl* root) { … }

void CopyProperties(Layer* from, Layer* to) { … }

void CopyProperties(const LayerImpl* from, LayerImpl* to) { … }

TransformNode& CreateTransformNode(Layer* layer, int parent_id) { … }

TransformNode& CreateTransformNode(LayerImpl* layer, int parent_id) { … }

TransformNode& CreateTransformNode(PropertyTrees* property_trees,
                                   int parent_id) { … }

ClipNode& CreateClipNode(Layer* layer, int parent_id) { … }

ClipNode& CreateClipNode(LayerImpl* layer, int parent_id) { … }

ClipNode& CreateClipNode(PropertyTrees* property_trees,
                         int parent_id,
                         int transform_id) { … }

EffectNode& CreateEffectNode(Layer* layer, int parent_id) { … }

EffectNode& CreateEffectNode(LayerImpl* layer, int parent_id) { … }

EffectNode& CreateEffectNode(PropertyTrees* property_trees,
                             int parent_id,
                             int transform_id,
                             int clip_id) { … }

ScrollNode& CreateScrollNode(Layer* layer,
                             const gfx::Size& scroll_container_bounds,
                             int parent_id) { … }

ScrollNode& CreateScrollNode(LayerImpl* layer,
                             const gfx::Size& scroll_container_bounds,
                             int parent_id) { … }

ScrollNode& CreateScrollNodeForNonCompositedScroller(
    PropertyTrees* property_trees,
    int parent_id,
    ElementId element_id,
    const gfx::Size& bounds,
    const gfx::Size& scroll_container_bounds) { … }

void SetupMaskProperties(Layer* masked_layer, PictureLayer* mask_layer) { … }

void SetupMaskProperties(LayerImpl* masked_layer,
                         PictureLayerImpl* mask_layer) { … }

void SetScrollOffset(Layer* layer, const gfx::PointF& scroll_offset) { … }

void SetScrollOffsetFromImplSide(Layer* layer,
                                 const gfx::PointF& scroll_offset) { … }

void SetScrollOffset(LayerImpl* layer, const gfx::PointF& scroll_offset) { … }

void SetupViewport(Layer* root,
                   scoped_refptr<Layer> outer_viewport_scroll_layer,
                   const gfx::Size& outer_viewport_size) { … }

void SetupViewport(Layer* root,
                   const gfx::Size& outer_viewport_size,
                   const gfx::Size& content_size) { … }

void SetupViewport(LayerImpl* root,
                   const gfx::Size& outer_viewport_size,
                   const gfx::Size& content_size) { … }

PropertyTrees* GetPropertyTrees(Layer* layer) { … }

const PropertyTrees* GetPropertyTrees(const Layer* layer) { … }

PropertyTrees* GetPropertyTrees(LayerImpl* layer) { … }

const PropertyTrees* GetPropertyTrees(const LayerImpl* layer) { … }

RenderSurfaceImpl* GetRenderSurface(LayerImpl* layer) { … }

const RenderSurfaceImpl* GetRenderSurface(const LayerImpl* layer) { … }

gfx::PointF ScrollOffsetBase(const LayerImpl* layer) { … }

gfx::Vector2dF ScrollDelta(const LayerImpl* layer) { … }

gfx::PointF CurrentScrollOffset(const Layer* layer,
                                const PropertyTrees* property_trees) { … }

gfx::PointF CurrentScrollOffset(const LayerImpl* layer) { … }

gfx::PointF MaxScrollOffset(const LayerImpl* layer) { … }

}  // namespace cc
chromium/cc/test/property_tree_test_utils.cc
