display_item_list.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/paint/display_item_list.h"

#include <limits>
#include <map>
#include <string>

#include "base/trace_event/trace_event.h"
#include "base/trace_event/traced_value.h"
#include "cc/base/math_util.h"
#include "cc/debug/picture_debug_util.h"
#include "cc/paint/paint_op_buffer_iterator.h"
#include "cc/paint/solid_color_analyzer.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkPictureRecorder.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/skia_conversions.h"

namespace cc {

namespace {

bool GetCanvasClipBounds(SkCanvas* canvas, gfx::Rect* clip_bounds) { … }

template <typename Function>
void IterateTextContent(const PaintOpBuffer& buffer,
                        const Function& yield,
                        const gfx::Rect& rect) { … }

template <typename Function>
void IterateTextContentByOffsets(const PaintOpBuffer& buffer,
                                 const std::vector<size_t>& offsets,
                                 const std::vector<gfx::Rect>& rects,
                                 const Function& yield) { … }

constexpr gfx::Rect kMaxBounds(std::numeric_limits<int>::max(),
                               std::numeric_limits<int>::max());

}  // namespace

DisplayItemList::DisplayItemList() { … }

DisplayItemList::~DisplayItemList() = default;

void DisplayItemList::Raster(
    SkCanvas* canvas,
    ImageProvider* image_provider,
    const ScrollOffsetMap* raster_inducing_scroll_offsets) const { … }

void DisplayItemList::Raster(SkCanvas* canvas,
                             const PlaybackParams& params) const { … }

std::vector<size_t> DisplayItemList::OffsetsOfOpsToRaster(
    SkCanvas* canvas) const { … }

void DisplayItemList::CaptureContent(const gfx::Rect& rect,
                                     std::vector<NodeInfo>* content) const { … }

double DisplayItemList::AreaOfDrawText(const gfx::Rect& rect) const { … }

void DisplayItemList::EndPaintOfPairedEnd() { … }

void DisplayItemList::Finalize() { … }

PaintRecord DisplayItemList::FinalizeAndReleaseAsRecordForTesting() { … }

void DisplayItemList::EmitTraceSnapshot() const { … }

std::string DisplayItemList::ToString() const { … }

std::unique_ptr<base::trace_event::TracedValue>
DisplayItemList::CreateTracedValue(bool include_items) const { … }

void DisplayItemList::AddToValue(base::trace_event::TracedValue* state,
                                 bool include_items) const { … }

scoped_refptr<DiscardableImageMap> DisplayItemList::GenerateDiscardableImageMap(
    const ScrollOffsetMap& raster_inducing_scroll_offsets) const { … }

bool DisplayItemList::GetColorIfSolidInRect(const gfx::Rect& rect,
                                            SkColor4f* color,
                                            int max_ops_to_analyze) const { … }

namespace {

std::optional<DirectlyCompositedImageInfo>
DirectlyCompositedImageInfoForPaintOpBuffer(const PaintOpBuffer& op_buffer) { … }

}  // anonymous namespace

std::optional<DirectlyCompositedImageInfo>
DisplayItemList::GetDirectlyCompositedImageInfo() const { … }

void DisplayItemList::PushDrawScrollingContentsOp(
    ElementId scroll_element_id,
    scoped_refptr<DisplayItemList> display_item_list,
    const gfx::Rect& visual_rect) { … }

}  // namespace cc
chromium/cc/paint/display_item_list.cc
