record_paint_canvas.cc | Explore in Territory

// Copyright 2017 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/record_paint_canvas.h"

#include <limits>
#include <utility>

#include "base/containers/span.h"
#include "cc/paint/paint_filter.h"
#include "cc/paint/paint_flags.h"
#include "cc/paint/paint_image_builder.h"
#include "cc/paint/paint_op.h"
#include "cc/paint/paint_record.h"
#include "cc/paint/paint_recorder.h"
#include "cc/paint/skottie_frame_data.h"
#include "cc/paint/skottie_wrapper.h"
#include "third_party/skia/include/core/SkAnnotation.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkPaint.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "third_party/skia/include/core/SkTextBlob.h"
#include "third_party/skia/include/utils/SkNWayCanvas.h"

namespace cc {

RecordPaintCanvas::RecordPaintCanvas() = default;
RecordPaintCanvas::~RecordPaintCanvas() = default;

PaintRecord RecordPaintCanvas::ReleaseAsRecord() { … }

void RecordPaintCanvas::DisableLineDrawingAsPaths() { … }

template <typename T, typename... Args>
void RecordPaintCanvas::push(Args&&... args) { … }

void* RecordPaintCanvas::accessTopLayerPixels(SkImageInfo* info,
                                              size_t* rowBytes,
                                              SkIPoint* origin) { … }

void RecordPaintCanvas::flush() { … }

bool RecordPaintCanvas::NeedsFlush() const { … }

int RecordPaintCanvas::save() { … }

int RecordPaintCanvas::saveLayer(const PaintFlags& flags) { … }

int RecordPaintCanvas::saveLayer(const SkRect& bounds,
                                 const PaintFlags& flags) { … }

int RecordPaintCanvas::saveLayerAlphaf(float alpha) { … }

int RecordPaintCanvas::saveLayerAlphaf(const SkRect& bounds, float alpha) { … }

int RecordPaintCanvas::saveLayerFilters(base::span<sk_sp<PaintFilter>> filters,
                                        const PaintFlags& flags) { … }

void RecordPaintCanvas::restore() { … }

int RecordPaintCanvas::getSaveCount() const { … }

void RecordPaintCanvas::restoreToCount(int save_count) { … }

void RecordPaintCanvas::translate(SkScalar dx, SkScalar dy) { … }

void RecordPaintCanvas::scale(SkScalar sx, SkScalar sy) { … }

void RecordPaintCanvas::rotate(SkScalar degrees) { … }

void RecordPaintCanvas::concat(const SkM44& matrix) { … }

void RecordPaintCanvas::setMatrix(const SkM44& matrix) { … }

void RecordPaintCanvas::clipRect(const SkRect& rect,
                                 SkClipOp op,
                                 bool antialias) { … }

void RecordPaintCanvas::clipRRect(const SkRRect& rrect,
                                  SkClipOp op,
                                  bool antialias) { … }

void RecordPaintCanvas::clipRRectInternal(const SkRRect& rrect,
                                          SkClipOp op,
                                          bool antialias) { … }

void RecordPaintCanvas::clipPath(const SkPath& path,
                                 SkClipOp op,
                                 bool antialias,
                                 UsePaintCache use_paint_cache) { … }

void RecordPaintCanvas::clipPathInternal(const SkPath& path,
                                         SkClipOp op,
                                         bool antialias,
                                         UsePaintCache use_paint_cache) { … }

SkImageInfo RecordPaintCanvas::imageInfo() const { … }

bool RecordPaintCanvas::getLocalClipBounds(SkRect* bounds) const { … }

bool RecordPaintCanvas::getDeviceClipBounds(SkIRect* bounds) const { … }

SkM44 RecordPaintCanvas::getLocalToDevice() const { … }

void RecordPaintCanvas::drawColor(SkColor4f color, SkBlendMode mode) { … }

void RecordPaintCanvas::clear(SkColor4f color) { … }

void RecordPaintCanvas::drawLine(SkScalar x0,
                                 SkScalar y0,
                                 SkScalar x1,
                                 SkScalar y1,
                                 const PaintFlags& flags) { … }

void RecordPaintCanvas::drawArc(const SkRect& oval,
                                SkScalar start_angle_degrees,
                                SkScalar sweep_angle_degrees,
                                const PaintFlags& flags) { … }

void RecordPaintCanvas::drawRect(const SkRect& rect, const PaintFlags& flags) { … }

void RecordPaintCanvas::drawIRect(const SkIRect& rect,
                                  const PaintFlags& flags) { … }

void RecordPaintCanvas::drawOval(const SkRect& oval, const PaintFlags& flags) { … }

void RecordPaintCanvas::drawRRect(const SkRRect& rrect,
                                  const PaintFlags& flags) { … }

void RecordPaintCanvas::drawDRRect(const SkRRect& outer,
                                   const SkRRect& inner,
                                   const PaintFlags& flags) { … }

void RecordPaintCanvas::drawRoundRect(const SkRect& rect,
                                      SkScalar rx,
                                      SkScalar ry,
                                      const PaintFlags& flags) { … }

void RecordPaintCanvas::drawPath(const SkPath& path,
                                 const PaintFlags& flags,
                                 UsePaintCache use_paint_cache) { … }

void RecordPaintCanvas::drawImage(const PaintImage& image,
                                  SkScalar left,
                                  SkScalar top,
                                  const SkSamplingOptions& sampling,
                                  const PaintFlags* flags) { … }

void RecordPaintCanvas::drawImageRect(const PaintImage& image,
                                      const SkRect& src,
                                      const SkRect& dst,
                                      const SkSamplingOptions& sampling,
                                      const PaintFlags* flags,
                                      SkCanvas::SrcRectConstraint constraint) { … }

void RecordPaintCanvas::drawVertices(
    scoped_refptr<RefCountedBuffer<SkPoint>> vertices,
    scoped_refptr<RefCountedBuffer<SkPoint>> uvs,
    scoped_refptr<RefCountedBuffer<uint16_t>> indices,
    const PaintFlags& flags) { … }

void RecordPaintCanvas::drawSkottie(scoped_refptr<SkottieWrapper> skottie,
                                    const SkRect& dst,
                                    float t,
                                    SkottieFrameDataMap images,
                                    const SkottieColorMap& color_map,
                                    SkottieTextPropertyValueMap text_map) { … }

void RecordPaintCanvas::drawTextBlob(sk_sp<SkTextBlob> blob,
                                     SkScalar x,
                                     SkScalar y,
                                     const PaintFlags& flags) { … }

void RecordPaintCanvas::drawTextBlob(sk_sp<SkTextBlob> blob,
                                     SkScalar x,
                                     SkScalar y,
                                     NodeId node_id,
                                     const PaintFlags& flags) { … }

void RecordPaintCanvas::drawPicture(PaintRecord record) { … }

void RecordPaintCanvas::drawPicture(PaintRecord record, bool local_ctm) { … }

void RecordPaintCanvas::Annotate(AnnotationType type,
                                 const SkRect& rect,
                                 sk_sp<SkData> data) { … }

void RecordPaintCanvas::recordCustomData(uint32_t id) { … }

void RecordPaintCanvas::setNodeId(int node_id) { … }

InspectableRecordPaintCanvas::InspectableRecordPaintCanvas(
    const gfx::Size& size)
    : … { … }

InspectableRecordPaintCanvas::InspectableRecordPaintCanvas(
    CreateChildCanvasTag,
    const InspectableRecordPaintCanvas& parent)
    : … { … }

InspectableRecordPaintCanvas::~InspectableRecordPaintCanvas() = default;

int InspectableRecordPaintCanvas::save() { … }

int InspectableRecordPaintCanvas::saveLayer(const PaintFlags& flags) { … }

int InspectableRecordPaintCanvas::saveLayer(const SkRect& bounds,
                                            const PaintFlags& flags) { … }

int InspectableRecordPaintCanvas::saveLayerAlphaf(float alpha) { … }

int InspectableRecordPaintCanvas::saveLayerAlphaf(const SkRect& bounds,
                                                  float alpha) { … }

int InspectableRecordPaintCanvas::saveLayerFilters(
    base::span<sk_sp<PaintFilter>> filters,
    const PaintFlags& flags) { … }

void InspectableRecordPaintCanvas::restore() { … }

int InspectableRecordPaintCanvas::CheckSaveCount(int super_prev_save_count,
                                                 int canvas_prev_save_count) { … }

void InspectableRecordPaintCanvas::translate(SkScalar dx, SkScalar dy) { … }

void InspectableRecordPaintCanvas::scale(SkScalar sx, SkScalar sy) { … }

void InspectableRecordPaintCanvas::rotate(SkScalar degrees) { … }

void InspectableRecordPaintCanvas::concat(const SkM44& matrix) { … }

void InspectableRecordPaintCanvas::setMatrix(const SkM44& matrix) { … }

void InspectableRecordPaintCanvas::clipRect(const SkRect& rect,
                                            SkClipOp op,
                                            bool antialias) { … }

void InspectableRecordPaintCanvas::clipRRectInternal(const SkRRect& rrect,
                                                     SkClipOp op,
                                                     bool antialias) { … }

void InspectableRecordPaintCanvas::clipPathInternal(
    const SkPath& path,
    SkClipOp op,
    bool antialias,
    UsePaintCache use_paint_cache) { … }

SkImageInfo InspectableRecordPaintCanvas::imageInfo() const { … }

bool InspectableRecordPaintCanvas::getLocalClipBounds(SkRect* bounds) const { … }

bool InspectableRecordPaintCanvas::getDeviceClipBounds(SkIRect* bounds) const { … }

SkM44 InspectableRecordPaintCanvas::getLocalToDevice() const { … }

}  // namespace cc
chromium/cc/paint/record_paint_canvas.cc
