picture_layer_tiling.cc | Explore in Territory

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/351564777): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "cc/tiles/picture_layer_tiling.h"

#include <stddef.h>

#include <algorithm>
#include <cmath>
#include <limits>
#include <set>

#include "base/check_op.h"
#include "base/containers/contains.h"
#include "base/containers/flat_map.h"
#include "base/numerics/safe_conversions.h"
#include "base/trace_event/trace_event.h"
#include "base/trace_event/traced_value.h"
#include "cc/base/features.h"
#include "cc/base/math_util.h"
#include "cc/layers/picture_layer_impl.h"
#include "cc/raster/raster_source.h"
#include "cc/tiles/prioritized_tile.h"
#include "cc/tiles/tile.h"
#include "cc/tiles/tile_priority.h"
#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/size_conversions.h"

namespace cc {

PictureLayerTiling::PictureLayerTiling(
    WhichTree tree,
    const gfx::AxisTransform2d& raster_transform,
    scoped_refptr<RasterSource> raster_source,
    PictureLayerTilingClient* client,
    float min_preraster_distance,
    float max_preraster_distance,
    bool can_use_lcd_text)
    : … { … }

PictureLayerTiling::~PictureLayerTiling() = default;

Tile* PictureLayerTiling::CreateTile(const Tile::CreateInfo& info) { … }

void PictureLayerTiling::CreateMissingTilesInLiveTilesRect() { … }

void PictureLayerTiling::TakeTilesAndPropertiesFrom(
    PictureLayerTiling* pending_twin,
    const Region& layer_invalidation) { … }

bool PictureLayerTiling::SetRasterSourceAndResize(
    scoped_refptr<RasterSource> raster_source) { … }

void PictureLayerTiling::Invalidate(const Region& layer_invalidation) { … }

void PictureLayerTiling::RemoveTilesInRegion(const Region& layer_invalidation,
                                             bool recreate_tiles) { … }

Tile::CreateInfo PictureLayerTiling::CreateInfoForTile(int i, int j) const { … }

bool PictureLayerTiling::ShouldCreateTileAt(
    const Tile::CreateInfo& info) const { … }

bool PictureLayerTiling::TilingMatchesTileIndices(
    const PictureLayerTiling* twin) const { … }

std::unique_ptr<Tile> PictureLayerTiling::TakeTileAt(int i, int j) { … }

void PictureLayerTiling::SetTilePriorityRectsForTesting(
    const gfx::Rect& visible_rect,
    const gfx::Rect& skewport_rect,
    const gfx::Rect& soon_border_rect,
    const gfx::Rect& eventually_rect,
    bool evicts_tiles) { … }

void PictureLayerTiling::Reset() { … }

void PictureLayerTiling::ComputeTilePriorityRects(
    const gfx::Rect& visible_rect_in_layer_space,
    const gfx::Rect& skewport_rect_in_layer_space,
    const gfx::Rect& soon_border_rect_in_layer_space,
    const gfx::Rect& eventually_rect_in_layer_space,
    float ideal_contents_scale,
    const Occlusion& occlusion_in_layer_space) { … }

void PictureLayerTiling::SetPriorityRect(const gfx::Rect& rect_in_layer_space,
                                         PriorityRectType rect_type,
                                         bool evicts_tiles) { … }

void PictureLayerTiling::SetLiveTilesRect(
    const gfx::Rect& new_live_tiles_rect) { … }

void PictureLayerTiling::VerifyTiles() const { … }

bool PictureLayerTiling::IsTileOccludedOnCurrentTree(const Tile* tile) const { … }

bool PictureLayerTiling::ShouldDecodeCheckeredImagesForTile(
    const Tile* tile) const { … }

void PictureLayerTiling::UpdateRequiredStatesOnTile(Tile* tile) const { … }

PictureLayerTiling::CoverageIterator PictureLayerTiling::Cover(
    const gfx::Rect& rect,
    float scale) const { … }

PrioritizedTile PictureLayerTiling::MakePrioritizedTile(
    Tile* tile,
    PriorityRectType priority_rect_type,
    bool is_tile_occluded) const { … }

void PictureLayerTiling::CreateAllTilesForTesting(
    const gfx::Rect& rect_to_raster) { … }

std::map<const Tile*, PrioritizedTile>
PictureLayerTiling::UpdateAndGetAllPrioritizedTilesForTesting() const { … }

TilePriority PictureLayerTiling::ComputePriorityForTile(
    const Tile* tile,
    PriorityRectType priority_rect_type,
    bool is_tile_occluded) const { … }

PictureLayerTiling::PriorityRectType
PictureLayerTiling::ComputePriorityRectTypeForTile(const Tile* tile) const { … }

void PictureLayerTiling::GetAllPrioritizedTilesForTracing(
    std::vector<PrioritizedTile>* prioritized_tiles) const { … }

void PictureLayerTiling::AsValueInto(
    base::trace_event::TracedValue* state) const { … }

size_t PictureLayerTiling::GPUMemoryUsageInBytes() const { … }

gfx::Rect PictureLayerTiling::EnclosingContentsRectFromLayerRect(
    const gfx::Rect& layer_rect) const { … }

gfx::Rect PictureLayerTiling::EnclosingLayerRectFromContentsRect(
    const gfx::Rect& contents_rect) const { … }

gfx::Rect PictureLayerTiling::ComputeTilingRect() const { … }

void PictureLayerTiling::SetTilingRect(const gfx::Rect& tiling_rect) { … }

PictureLayerTiling::TileIterator::TileIterator(PictureLayerTiling* tiling)
    : … { … }

PictureLayerTiling::TileIterator::~TileIterator() = default;

Tile* PictureLayerTiling::TileIterator::GetCurrent() { … }

void PictureLayerTiling::TileIterator::Next() { … }

bool PictureLayerTiling::TileIterator::AtEnd() const { … }

}  // namespace cc
chromium/cc/tiles/picture_layer_tiling.cc
