chromium/third_party/skia/src/core/SkPicture.cpp

/*
 * Copyright 2007 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "include/core/SkPicture.h"

#include "include/core/SkData.h"
#include "include/core/SkPictureRecorder.h"
#include "include/core/SkSerialProcs.h"
#include "include/core/SkStream.h"
#include "include/private/base/SkTFitsIn.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkMathPriv.h"
#include "src/core/SkCanvasPriv.h"
#include "src/core/SkPictureData.h"
#include "src/core/SkPicturePlayback.h"
#include "src/core/SkPicturePriv.h"
#include "src/core/SkPictureRecord.h"
#include "src/core/SkReadBuffer.h"
#include "src/core/SkResourceCache.h"
#include "src/core/SkStreamPriv.h"
#include "src/core/SkWriteBuffer.h"

#include <atomic>
#include <cstring>
#include <memory>

// When we read/write the SkPictInfo via a stream, we have a sentinel byte right after the info.
// Note: in the read/write buffer versions, we have a slightly different convention:
//      We have a sentinel int32_t:
//          0 : failure
//          1 : PictureData
//         <0 : -size of the custom data
enum { … };

/* SkPicture impl.  This handles generic responsibilities like unique IDs and serialization. */

SkPicture::SkPicture() { … }

SkPicture::~SkPicture() { … }

static const char kMagic[] = …;

SkPictInfo SkPicture::createHeader() const { … }

bool SkPicture::IsValidPictInfo(const SkPictInfo& info) { … }

bool SkPicture::StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) { … }

bool SkPicture_StreamIsSKP(SkStream* stream, SkPictInfo* pInfo) { … }

bool SkPicture::BufferIsSKP(SkReadBuffer* buffer, SkPictInfo* pInfo) { … }

sk_sp<SkPicture> SkPicture::Forwardport(const SkPictInfo& info,
                                        const SkPictureData* data,
                                        SkReadBuffer* buffer) { … }

static const int kNestedSKPLimit = …; // Arbitrarily set

sk_sp<SkPicture> SkPicture::MakeFromStream(SkStream* stream, const SkDeserialProcs* procs) { … }

sk_sp<SkPicture> SkPicture::MakeFromData(const void* data, size_t size,
                                         const SkDeserialProcs* procs) { … }

sk_sp<SkPicture> SkPicture::MakeFromData(const SkData* data, const SkDeserialProcs* procs) { … }

sk_sp<SkPicture> SkPicture::MakeFromStreamPriv(SkStream* stream, const SkDeserialProcs* procsPtr,
                                               SkTypefacePlayback* typefaces, int recursionLimit) { … }

sk_sp<SkPicture> SkPicturePriv::MakeFromBuffer(SkReadBuffer& buffer) { … }

SkPictureData* SkPicture::backport() const { … }

void SkPicture::serialize(SkWStream* stream, const SkSerialProcs* procs) const { … }

sk_sp<SkData> SkPicture::serialize(const SkSerialProcs* procs) const { … }

static sk_sp<SkData> custom_serialize(const SkPicture* picture, const SkSerialProcs& procs) { … }

static bool write_pad32(SkWStream* stream, const void* data, size_t size) { … }

// Private serialize.
// SkPictureData::serialize makes a first pass on all subpictures, indicated by textBlobsOnly=true,
// to fill typefaceSet.
void SkPicture::serialize(SkWStream* stream, const SkSerialProcs* procsPtr,
                          SkRefCntSet* typefaceSet, bool textBlobsOnly) const { … }

void SkPicturePriv::Flatten(const sk_sp<const SkPicture> picture, SkWriteBuffer& buffer) { … }

sk_sp<SkPicture> SkPicture::MakePlaceholder(SkRect cull) { … }