render_surface_impl.cc | Explore in Territory

// Copyright 2011 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/layers/render_surface_impl.h"

#include <stddef.h>

#include <algorithm>

#include "base/check_op.h"
#include "cc/base/math_util.h"
#include "cc/debug/debug_colors.h"
#include "cc/layers/append_quads_data.h"
#include "cc/paint/element_id.h"
#include "cc/paint/filter_operations.h"
#include "cc/trees/damage_tracker.h"
#include "cc/trees/effect_node.h"
#include "cc/trees/layer_tree_impl.h"
#include "cc/trees/occlusion.h"
#include "cc/trees/transform_node.h"
#include "components/viz/common/quads/compositor_render_pass.h"
#include "components/viz/common/quads/compositor_render_pass_draw_quad.h"
#include "components/viz/common/quads/content_draw_quad_base.h"
#include "components/viz/common/quads/debug_border_draw_quad.h"
#include "components/viz/common/quads/shared_quad_state.h"
#include "components/viz/common/quads/solid_color_draw_quad.h"
#include "components/viz/common/quads/tile_draw_quad.h"
#include "third_party/skia/include/core/SkImageFilter.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/geometry/transform.h"

namespace cc {

RenderSurfaceImpl::RenderSurfaceImpl(LayerTreeImpl* layer_tree_impl,
                                     ElementId id)
    : … { … }

RenderSurfaceImpl::~RenderSurfaceImpl() = default;

RenderSurfaceImpl* RenderSurfaceImpl::render_target() { … }

const RenderSurfaceImpl* RenderSurfaceImpl::render_target() const { … }

RenderSurfaceImpl::DrawProperties::DrawProperties() = default;

RenderSurfaceImpl::DrawProperties::~DrawProperties() = default;

gfx::RectF RenderSurfaceImpl::DrawableContentRect() const { … }

SkBlendMode RenderSurfaceImpl::BlendMode() const { … }

SkColor4f RenderSurfaceImpl::GetDebugBorderColor() const { … }

float RenderSurfaceImpl::GetDebugBorderWidth() const { … }

LayerImpl* RenderSurfaceImpl::BackdropMaskLayer() const { … }

bool RenderSurfaceImpl::HasMaskingContributingSurface() const { … }

const FilterOperations& RenderSurfaceImpl::Filters() const { … }

gfx::Transform RenderSurfaceImpl::SurfaceScale() const { … }

const FilterOperations& RenderSurfaceImpl::BackdropFilters() const { … }

std::optional<gfx::RRectF> RenderSurfaceImpl::BackdropFilterBounds() const { … }

bool RenderSurfaceImpl::TrilinearFiltering() const { … }

bool RenderSurfaceImpl::HasCopyRequest() const { … }

viz::SubtreeCaptureId RenderSurfaceImpl::SubtreeCaptureId() const { … }

gfx::Size RenderSurfaceImpl::SubtreeSize() const { … }

bool RenderSurfaceImpl::ShouldCacheRenderSurface() const { … }

bool RenderSurfaceImpl::CopyOfOutputRequired() const { … }

int RenderSurfaceImpl::TransformTreeIndex() const { … }

int RenderSurfaceImpl::ClipTreeIndex() const { … }

int RenderSurfaceImpl::EffectTreeIndex() const { … }

const EffectNode* RenderSurfaceImpl::OwningEffectNode() const { … }

EffectNode* RenderSurfaceImpl::OwningEffectNodeMutableForTest() const { … }

void RenderSurfaceImpl::SetClipRect(const gfx::Rect& clip_rect) { … }

void RenderSurfaceImpl::SetContentRect(const gfx::Rect& content_rect) { … }

void RenderSurfaceImpl::SetContentRectForTesting(const gfx::Rect& rect) { … }

gfx::Rect RenderSurfaceImpl::CalculateExpandedClipForFilters(
    const gfx::Transform& target_to_surface) { … }

gfx::Rect RenderSurfaceImpl::CalculateClippedAccumulatedContentRect() { … }

void RenderSurfaceImpl::CalculateContentRectFromAccumulatedContentRect(
    int max_texture_size) { … }

void RenderSurfaceImpl::SetContentRectToViewport() { … }

void RenderSurfaceImpl::ClearAccumulatedContentRect() { … }

void RenderSurfaceImpl::AccumulateContentRectFromContributingLayer(
    LayerImpl* layer) { … }

void RenderSurfaceImpl::AccumulateContentRectFromContributingRenderSurface(
    RenderSurfaceImpl* contributing_surface) { … }

bool RenderSurfaceImpl::SurfacePropertyChanged() const { … }

bool RenderSurfaceImpl::AncestorPropertyChanged() const { … }

void RenderSurfaceImpl::NoteAncestorPropertyChanged() { … }

bool RenderSurfaceImpl::HasDamageFromeContributingContent() const { … }

gfx::Rect RenderSurfaceImpl::GetDamageRect() const { … }

RenderSurfacePropertyChangedFlags RenderSurfaceImpl::GetPropertyChangeFlags()
    const { … }

void RenderSurfaceImpl::ApplyPropertyChangeFlags(
    const RenderSurfacePropertyChangedFlags& flags) { … }

void RenderSurfaceImpl::ResetPropertyChangedFlags() { … }

std::unique_ptr<viz::CompositorRenderPass>
RenderSurfaceImpl::CreateRenderPass() { … }

void RenderSurfaceImpl::AppendQuads(DrawMode draw_mode,
                                    viz::CompositorRenderPass* render_pass,
                                    AppendQuadsData* append_quads_data) { … }

bool RenderSurfaceImpl::ShouldClip() const { … }

}  // namespace cc
chromium/cc/layers/render_surface_impl.cc
