}
void AndroidCodecBench::onDelayedSetup() {
- SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(fData.get()));
+ SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(fData));
SkISize scaledSize = codec->getSampledDimensions(fSampleSize);
fInfo = codec->getInfo().makeWH(scaledSize.width(), scaledSize.height())
SkAndroidCodec::AndroidOptions options;
options.fSampleSize = fSampleSize;
for (int i = 0; i < n; i++) {
- codec.reset(SkAndroidCodec::NewFromData(fData.get()));
+ codec.reset(SkAndroidCodec::NewFromData(fData));
#ifdef SK_DEBUG
const SkCodec::Result result =
#endif
}
void BitmapRegionDecoderBench::onDelayedSetup() {
- fBRD.reset(SkBitmapRegionDecoder::Create(fData.get(),
- SkBitmapRegionDecoder::kAndroidCodec_Strategy));
+ fBRD.reset(SkBitmapRegionDecoder::Create(fData, SkBitmapRegionDecoder::kAndroidCodec_Strategy));
}
void BitmapRegionDecoderBench::onDraw(int n, SkCanvas* canvas) {
alpha_type_to_str(alphaType));
#ifdef SK_DEBUG
// Ensure that we can create an SkCodec from this data.
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fData.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fData));
SkASSERT(codec);
#endif
}
}
void CodecBench::onDelayedSetup() {
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fData.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fData));
fInfo = codec->getInfo().makeColorType(fColorType)
.makeAlphaType(fAlphaType)
}
for (int i = 0; i < n; i++) {
colorCount = 256;
- codec.reset(SkCodec::NewFromData(fData.get()));
+ codec.reset(SkCodec::NewFromData(fData));
#ifdef SK_DEBUG
const SkCodec::Result result =
#endif
}
void ColorCodecBench::decodeAndXform() {
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fEncoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fEncoded));
SkASSERT(codec);
#ifdef SK_DEBUG
#if defined(SK_TEST_QCMS)
void ColorCodecBench::decodeAndXformQCMS() {
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fEncoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fEncoded));
#ifdef SK_DEBUG
const SkCodec::Result result =
#endif
#endif
void ColorCodecBench::onDelayedSetup() {
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fEncoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fEncoded));
fSrcData = codec->getICCData();
sk_sp<SkData> dstData = SkData::MakeFromFileName(
GetResourcePath("icc_profiles/HP_ZR30w.icc").c_str());
return target;
}
-static bool valid_brd_bench(SkData* encoded, SkColorType colorType, uint32_t sampleSize,
+static bool valid_brd_bench(sk_sp<SkData> encoded, SkColorType colorType, uint32_t sampleSize,
uint32_t minOutputSize, int* width, int* height) {
SkAutoTDelete<SkBitmapRegionDecoder> brd(
SkBitmapRegionDecoder::Create(encoded, SkBitmapRegionDecoder::kAndroidCodec_Strategy));
continue;
}
sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (!codec) {
// Nothing to time.
SkDebugf("Cannot find codec for %s\n", path.c_str());
continue;
}
sk_sp<SkData> encoded(SkData::MakeFromFileName(path.c_str()));
- SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
if (!codec) {
// Nothing to time.
SkDebugf("Cannot find codec for %s\n", path.c_str());
int width = 0;
int height = 0;
- if (!valid_brd_bench(encoded.get(), colorType, sampleSize, minOutputSize,
+ if (!valid_brd_bench(encoded, colorType, sampleSize, minOutputSize,
&width, &height)) {
break;
}
info("Couldn't read %s.", path.c_str());
return;
}
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec.get()) {
info("Couldn't create codec for %s.", path.c_str());
return;
if (!encoded) {
return NULL;
}
- return SkBitmapRegionDecoder::Create(encoded.get(),
- SkBitmapRegionDecoder::kAndroidCodec_Strategy);
+ return SkBitmapRegionDecoder::Create(encoded, SkBitmapRegionDecoder::kAndroidCodec_Strategy);
}
Error BRDSrc::draw(SkCanvas* canvas) const {
return SkStringPrintf("Couldn't read %s.", fPath.c_str());
}
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec.get()) {
return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
}
SkISize CodecSrc::size() const {
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec) {
return SkISize::Make(0, 0);
}
if (!encoded) {
return SkStringPrintf("Couldn't read %s.", fPath.c_str());
}
- SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
if (nullptr == codec.get()) {
return SkStringPrintf("Couldn't create android codec for %s.", fPath.c_str());
}
SkISize AndroidCodecSrc::size() const {
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
- SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromData(encoded));
if (nullptr == codec) {
return SkISize::Make(0, 0);
}
SkISize ImageGenSrc::size() const {
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec) {
return SkISize::Make(0, 0);
}
return SkStringPrintf("Couldn't read %s.", fPath.c_str());
}
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec.get()) {
return SkStringPrintf("Couldn't create codec for %s.", fPath.c_str());
}
SkISize ColorCodecSrc::size() const {
sk_sp<SkData> encoded(SkData::MakeFromFileName(fPath.c_str()));
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (nullptr == codec) {
return SkISize::Make(0, 0);
}
class Fuzz : SkNoncopyable {
public:
- explicit Fuzz(SkData*);
+ explicit Fuzz(sk_sp<SkData>);
// Returns the total number of "random" bytes available.
size_t size();
}
static uint8_t calculate_option(SkData*);
-static int fuzz_api(SkData*);
-static int fuzz_img(SkData*, uint8_t, uint8_t);
-static int fuzz_skp(SkData*);
-static int fuzz_icc(SkData*);
-static int fuzz_color_deserialize(SkData*);
+static int fuzz_api(sk_sp<SkData>);
+static int fuzz_img(sk_sp<SkData>, uint8_t, uint8_t);
+static int fuzz_skp(sk_sp<SkData>);
+static int fuzz_icc(sk_sp<SkData>);
+static int fuzz_color_deserialize(sk_sp<SkData>);
int main(int argc, char** argv) {
SkCommandLineFlags::Parse(argc, argv);
if (!FLAGS_type.isEmpty()) {
switch (FLAGS_type[0][0]) {
- case 'a': return fuzz_api(bytes.get());
+ case 'a': return fuzz_api(bytes);
- case 'c': return fuzz_color_deserialize(bytes.get());
+ case 'c': return fuzz_color_deserialize(bytes);
case 'i':
if (FLAGS_type[0][1] == 'c') { //icc
- return fuzz_icc(bytes.get());
+ return fuzz_icc(bytes);
}
// We only allow one degree of freedom to avoid a search space explosion for afl-fuzz.
if (FLAGS_type[0][6] == 's') { // image_scale
- return fuzz_img(bytes.get(), option, 0);
+ return fuzz_img(bytes, option, 0);
}
// image_mode
- return fuzz_img(bytes.get(), 0, option);
- case 's': return fuzz_skp(bytes.get());
+ return fuzz_img(bytes, 0, option);
+ case 's': return fuzz_skp(bytes);
}
}
return printUsage(argv[0]);
return total;
}
-int fuzz_api(SkData* bytes) {
+int fuzz_api(sk_sp<SkData> bytes) {
const char* name = FLAGS_name.isEmpty() ? "" : FLAGS_name[0];
for (auto r = SkTRegistry<Fuzzable>::Head(); r; r = r->next()) {
}
}
-int fuzz_img(SkData* bytes, uint8_t scale, uint8_t mode) {
+int fuzz_img(sk_sp<SkData> bytes, uint8_t scale, uint8_t mode) {
// We can scale 1x, 2x, 4x, 8x, 16x
scale = scale % 5;
float fscale = (float)pow(2.0f, scale);
return 0;
}
-int fuzz_skp(SkData* bytes) {
+int fuzz_skp(sk_sp<SkData> bytes) {
SkMemoryStream stream(bytes);
SkDebugf("Decoding\n");
sk_sp<SkPicture> pic(SkPicture::MakeFromStream(&stream));
return 0;
}
-int fuzz_icc(SkData* bytes) {
+int fuzz_icc(sk_sp<SkData> bytes) {
sk_sp<SkColorSpace> space(SkColorSpace::NewICC(bytes->data(), bytes->size()));
if (!space) {
SkDebugf("[terminated] Couldn't decode ICC.\n");
return 0;
}
-int fuzz_color_deserialize(SkData* bytes) {
+int fuzz_color_deserialize(sk_sp<SkData> bytes) {
sk_sp<SkColorSpace> space(SkColorSpace::Deserialize(bytes->data(), bytes->size()));
if (!space) {
SkDebugf("[terminated] Couldn't deserialize Colorspace.\n");
return 0;
}
-Fuzz::Fuzz(SkData* bytes) : fBytes(SkSafeRef(bytes)), fNextByte(0) {}
+Fuzz::Fuzz(sk_sp<SkData> bytes) : fBytes(bytes), fNextByte(0) {}
void Fuzz::signalBug () { SkDebugf("Signal bug\n"); raise(SIGSEGV); }
void Fuzz::signalBoring() { SkDebugf("Signal boring\n"); exit(0); }
'SK_SUPPORT_LEGACY_XFERMODE_PTR',
'SK_IGNORE_GPU_DITHER',
'SK_SUPPORT_LEGACY_PICTUREINSTALLPIXELREF',
+ 'SK_SUPPORT_LEGACY_STREAM_DATA',
],
},
}
* @param strategy Strategy used for scaling and subsetting
* @return Tries to create an SkBitmapRegionDecoder, returns NULL on failure
*/
- static SkBitmapRegionDecoder* Create(
- SkData* data, Strategy strategy);
+ static SkBitmapRegionDecoder* Create(sk_sp<SkData>, Strategy strategy);
/*
* @param stream Takes ownership of the stream
*
* The SkPngChunkReader handles unknown chunks in PNGs.
* See SkCodec.h for more details.
- *
- * Will take a ref if it returns a codec, else will not affect the data.
*/
- static SkAndroidCodec* NewFromData(SkData*, SkPngChunkReader* = NULL);
+ static SkAndroidCodec* NewFromData(sk_sp<SkData>, SkPngChunkReader* = NULL);
+ static SkAndroidCodec* NewFromData(SkData* data, SkPngChunkReader* reader) {
+ return NewFromData(sk_ref_sp(data), reader);
+ }
virtual ~SkAndroidCodec() {}
* failure to decode the image.
* If the PNG does not contain unknown chunks, the SkPngChunkReader
* will not be used or modified.
- *
- * Will take a ref if it returns a codec, else will not affect the data.
*/
- static SkCodec* NewFromData(SkData*, SkPngChunkReader* = NULL);
+ static SkCodec* NewFromData(sk_sp<SkData>, SkPngChunkReader* = NULL);
+ static SkCodec* NewFromData(SkData* data, SkPngChunkReader* reader) {
+ return NewFromData(sk_ref_sp(data), reader);
+ }
virtual ~SkCodec();
/** If copyData is true, the stream makes a private copy of the data. */
SkMemoryStream(const void* data, size_t length, bool copyData = false);
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
/** Use the specified data as the memory for this stream.
* The stream will call ref() on the data (assuming it is not NULL).
* DEPRECATED
*/
SkMemoryStream(SkData*);
+#endif
/** Creates the stream to read from the specified data */
SkMemoryStream(sk_sp<SkData>);
*/
void setMemoryOwned(const void* data, size_t length);
+ sk_sp<SkData> asData() const { return fData; }
+ void setData(sk_sp<SkData>);
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
/** Return the stream's data in a SkData.
* The caller must call unref() when it is finished using the data.
*/
- SkData* copyToData() const;
+ SkData* copyToData() const { return asData().release(); }
/**
* Use the specified data as the memory for this stream.
* The stream will call ref() on the data (assuming it is not NULL).
* The function returns the data parameter as a convenience.
*/
- SkData* setData(SkData*);
+ SkData* setData(SkData* data) {
+ this->setData(sk_ref_sp(data));
+ return data;
+ }
+#endif
void skipToAlign4();
const void* getAtPos();
void copyTo(void* dst) const;
void writeToStream(SkWStream* dst) const;
+ sk_sp<SkData> snapshotAsData() const;
+ // Return the contents as SkData, and then reset the stream.
+ sk_sp<SkData> detachAsData();
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
/**
* Return a copy of the data written so far. This call is responsible for
* calling unref() when they are finished with the data.
*/
- SkData* copyToData() const;
+ SkData* copyToData() const {
+ return snapshotAsData().release();
+ }
+#endif
/** Reset, returning a reader stream with the current content. */
SkStreamAsset* detachAsStream();
"SK_SUPPORT_LEGACY_TYPEFACE_PTR",
"SK_SUPPORT_LEGACY_XFERMODE_PTR",
"SK_SUPPORT_LEGACY_PICTUREINSTALLPIXELREF",
+ "SK_SUPPORT_LEGACY_STREAM_DATA",
]
################################################################################
bool requireUnpremul = false) {
SkASSERT(kIndex_8_SkColorType != colorType);
sk_sp<SkData> data(SkData::MakeFromFileName(filename));
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
if (!codec) {
return false;
}
#include "SkCodecPriv.h"
SkBitmapRegionDecoder* SkBitmapRegionDecoder::Create(
- SkData* data, Strategy strategy) {
+ sk_sp<SkData> data, Strategy strategy) {
return SkBitmapRegionDecoder::Create(new SkMemoryStream(data),
strategy);
}
}
}
-SkAndroidCodec* SkAndroidCodec::NewFromData(SkData* data, SkPngChunkReader* chunkReader) {
+SkAndroidCodec* SkAndroidCodec::NewFromData(sk_sp<SkData> data, SkPngChunkReader* chunkReader) {
if (!data) {
return nullptr;
}
return nullptr;
}
-SkCodec* SkCodec::NewFromData(SkData* data, SkPngChunkReader* reader) {
+SkCodec* SkCodec::NewFromData(sk_sp<SkData> data, SkPngChunkReader* reader) {
if (!data) {
return nullptr;
}
#include "SkCodecImageGenerator.h"
-SkImageGenerator* SkCodecImageGenerator::NewFromEncodedCodec(SkData* data) {
+SkImageGenerator* SkCodecImageGenerator::NewFromEncodedCodec(sk_sp<SkData> data) {
SkCodec* codec = SkCodec::NewFromData(data);
if (nullptr == codec) {
return nullptr;
return info;
}
-SkCodecImageGenerator::SkCodecImageGenerator(SkCodec* codec, SkData* data)
+SkCodecImageGenerator::SkCodecImageGenerator(SkCodec* codec, sk_sp<SkData> data)
: INHERITED(make_premul(codec->getInfo()))
, fCodec(codec)
- , fData(SkRef(data))
+ , fData(std::move(data))
{}
SkData* SkCodecImageGenerator::onRefEncodedData(SK_REFENCODEDDATA_CTXPARAM) {
/*
* If this data represents an encoded image that we know how to decode,
* return an SkCodecImageGenerator. Otherwise return nullptr.
- *
- * Refs the data if an image generator can be returned. Otherwise does
- * not affect the data.
*/
- static SkImageGenerator* NewFromEncodedCodec(SkData* data);
+ static SkImageGenerator* NewFromEncodedCodec(sk_sp<SkData>);
+ static SkImageGenerator* NewFromEncodedCodec(SkData* data) {
+ return NewFromEncodedCodec(sk_ref_sp(data));
+ }
protected:
SkData* onRefEncodedData(SK_REFENCODEDDATA_CTXPARAM) override;
private:
/*
* Takes ownership of codec
- * Refs the data
*/
- SkCodecImageGenerator(SkCodec* codec, SkData* data);
+ SkCodecImageGenerator(SkCodec* codec, sk_sp<SkData>);
SkAutoTDelete<SkCodec> fCodec;
sk_sp<SkData> fData;
fOffset = 0;
}
+#ifdef SK_SUPPORT_LEGACY_STREAM_DATA
SkMemoryStream::SkMemoryStream(SkData* data) {
if (nullptr == data) {
fData = SkData::MakeEmpty();
}
fOffset = 0;
}
+#endif
void SkMemoryStream::setMemoryOwned(const void* src, size_t size) {
fData = SkData::MakeFromMalloc(src, size);
fOffset = 0;
}
-SkData* SkMemoryStream::copyToData() const {
- return SkSafeRef(fData.get());
-}
-
-SkData* SkMemoryStream::setData(SkData* data) {
+void SkMemoryStream::setData(sk_sp<SkData> data) {
if (nullptr == data) {
fData = SkData::MakeEmpty();
} else {
- fData = sk_ref_sp(data);
+ fData = data;
}
fOffset = 0;
- return data;
}
void SkMemoryStream::skipToAlign4() {
write(&zero, padBytes);
}
-SkData* SkDynamicMemoryWStream::copyToData() const {
+sk_sp<SkData> SkDynamicMemoryWStream::snapshotAsData() const {
if (nullptr == fCopy) {
auto data = SkData::MakeUninitialized(fBytesWritten);
// be sure to call copyTo() before we assign to fCopy
this->copyTo(data->writable_data());
fCopy = std::move(data);
}
- return SkRef(fCopy.get());
+ return fCopy;
+}
+
+sk_sp<SkData> SkDynamicMemoryWStream::detachAsData() {
+ sk_sp<SkData> data = this->snapshotAsData();
+ this->reset();
+ return data;
}
void SkDynamicMemoryWStream::invalidateCopy() {
size_t bytesRead = stream->read(buffer, bufferSize);
tempStream.write(buffer, bytesRead);
} while (!stream->isAtEnd());
- return sk_sp<SkData>(tempStream.copyToData());
+ return tempStream.detachAsData();
}
bool SkStreamCopy(SkWStream* out, SkStream* input) {
SkDynamicMemoryWStream stream;
quality = SkMin32(100, SkMax32(0, quality));
if (this->onEncode(&stream, bm, quality)) {
- return stream.copyToData();
+ return stream.detachAsData().release();
}
return nullptr;
}
static void dump_path(FILE* file, const SkPath& path, bool force, bool dumpAsHex) {
SkDynamicMemoryWStream wStream;
path.dump(&wStream, force, dumpAsHex);
- sk_sp<SkData> data(wStream.copyToData());
+ sk_sp<SkData> data(wStream.detachAsData());
fprintf(file, "%.*s\n", (int) data->size(), data->data());
}
SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
// could be in base impl
- return this->createFromStream(new SkMemoryStream(data));
+ return this->createFromStream(new SkMemoryStream(sk_ref_sp(data)));
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
}
SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
- return this->createFromStream(new SkMemoryStream(data), ttcIndex);
+ return this->createFromStream(new SkMemoryStream(sk_ref_sp(data)), ttcIndex);
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
}
SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
- return this->createFromStream(new SkMemoryStream(data), ttcIndex);
+ return this->createFromStream(new SkMemoryStream(sk_ref_sp(data)), ttcIndex);
}
SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
}
SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
- return this->createFromStream(new SkMemoryStream(data), ttcIndex);
+ return this->createFromStream(new SkMemoryStream(sk_ref_sp(data)), ttcIndex);
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
}
SkTypeface* SkFontMgr_DirectWrite::onCreateFromData(SkData* data, int ttcIndex) const {
- return this->createFromStream(new SkMemoryStream(data), ttcIndex);
+ return this->createFromStream(new SkMemoryStream(sk_ref_sp(data)), ttcIndex);
}
SkTypeface* SkFontMgr_DirectWrite::onCreateFromFile(const char path[], int ttcIndex) const {
SkTScopedComPtr<IStream> iStream;
// Note that iStream will take ownership of the new memory stream because
// we set |deleteOnRelease| to true.
- hr = SkIStream::CreateFromSkStream(new SkMemoryStream(data), true, &iStream);
+ hr = SkIStream::CreateFromSkStream(new SkMemoryStream(sk_ref_sp(data)), true, &iStream);
if (FAILED(hr)) {
return nullptr;
}
HRM(E_FAIL, "Unable to encode bitmap as png.");
}
SkMemoryStream* read = new SkMemoryStream;
- read->setData(write.copyToData())->unref();
+ read->setData(write.detachAsData());
SkTScopedComPtr<IStream> readWrapper;
HRM(SkIStream::CreateFromSkStream(read, true, &readWrapper),
"Could not create stream from png data.");
SkAnnotateRectWithURL(canvas, r, data.get());
REPORTER_ASSERT(reporter, doc->close());
- sk_sp<SkData> out(outStream.copyToData());
+ sk_sp<SkData> out = outStream.detachAsData();
const char* rawOutput = (const char*)out->data();
REPORTER_ASSERT(reporter, ContainsString(rawOutput, out->size(), "/Annots "));
SkAnnotateNamedDestination(canvas, p, data.get());
REPORTER_ASSERT(reporter, doc->close());
- sk_sp<SkData> out(outStream.copyToData());
+ sk_sp<SkData> out = outStream.detachAsData();
const char* rawOutput = (const char*)out->data();
REPORTER_ASSERT(reporter,
/**
* encode this bitmap into some data via SkImageEncoder
*/
-static SkData* create_data_from_bitmap(const SkBitmap& bm,
- SkImageEncoder::Type type) {
+static sk_sp<SkData> create_data_from_bitmap(const SkBitmap& bm, SkImageEncoder::Type type) {
SkDynamicMemoryWStream stream;
if (SkImageEncoder::EncodeStream(&stream, bm, type, 100)) {
- return stream.copyToData();
+ return stream.detachAsData();
}
return nullptr;
}
};
for (size_t i = 0; i < SK_ARRAY_COUNT(types); i++) {
SkImageEncoder::Type type = types[i];
- sk_sp<SkData> encoded(create_data_from_bitmap(original, type));
+ sk_sp<SkData> encoded = create_data_from_bitmap(original, type);
REPORTER_ASSERT(reporter, encoded.get() != nullptr);
if (nullptr == encoded.get()) {
continue;
#include "SkData.h"
inline bool decode_memory(const void* mem, size_t size, SkBitmap* bm) {
- sk_sp<SkData> data(SkData::MakeWithoutCopy(mem, size));
-
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(SkData::MakeWithoutCopy(mem, size)));
if (!codec) {
return false;
}
if (isIncomplete) {
size_t size = stream->getLength();
sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
- codec.reset(SkCodec::NewFromData(data.get()));
+ codec.reset(SkCodec::NewFromData(data));
} else {
codec.reset(SkCodec::NewFromStream(stream.release()));
}
if (isIncomplete) {
size_t size = stream->getLength();
sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
- androidCodec.reset(SkAndroidCodec::NewFromData(data.get()));
+ androidCodec.reset(SkAndroidCodec::NewFromData(data));
} else {
androidCodec.reset(SkAndroidCodec::NewFromStream(stream.release()));
}
ChunkReader chunkReader(r);
// Now read the file with SkCodec.
- sk_sp<SkData> data(wStream.copyToData());
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get(), &chunkReader));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(wStream.detachAsData(), &chunkReader));
REPORTER_ASSERT(r, codec);
if (!codec) {
return;
// Stream that can only peek up to a limit
class LimitedPeekingMemStream : public SkStream {
public:
- LimitedPeekingMemStream(SkData* data, size_t limit)
- : fStream(data)
+ LimitedPeekingMemStream(sk_sp<SkData> data, size_t limit)
+ : fStream(std::move(data))
, fLimit(limit) {}
size_t peek(void* buf, size_t bytes) const override {
// The limit is less than webp needs to peek or read.
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(
- new LimitedPeekingMemStream(data.get(), 25)));
+ new LimitedPeekingMemStream(data, 25)));
REPORTER_ASSERT(r, codec);
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
// Similarly, a stream which does not peek should still succeed.
- codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data.get(), 0)));
+ codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 0)));
REPORTER_ASSERT(r, codec);
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
writeableData[1] = static_cast<uint8_t>(~0x9F);
// SkCodec should support this.
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
REPORTER_ASSERT(r, codec);
if (!codec) {
return;
sk_sp<SkData>(SkImageEncoder::EncodeData(bm1, SkImageEncoder::kPNG_Type, 100));
// Prepare to decode. The codec should recognize that the PNG is 565.
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
REPORTER_ASSERT(r, origColorType == codec->getInfo().colorType());
REPORTER_ASSERT(r, origAlphaType == codec->getInfo().alphaType());
pdfMetadata, nullptr, /* pdfa = */ true);
doc->beginPage(64, 64)->drawColor(SK_ColorRED);
doc->close();
- sk_sp<SkData> data(buffer.copyToData());
- buffer.reset();
+ sk_sp<SkData> data(buffer.detachAsData());
+
static const char* expectations[] = {
"sRGB IEC61966-2.1",
"<dc:title><rdf:Alt><rdf:li xml:lang=\"x-default\">test document",
pdfMetadata, nullptr, /* pdfa = */ true);
doc->beginPage(64, 64)->drawColor(SK_ColorRED);
doc->close();
- data.reset(buffer.copyToData());
- buffer.reset();
+ data = buffer.detachAsData();
static const char* moreExpectations[] = {
"/Producer (phoney library)",
static bool stream_equals(const SkDynamicMemoryWStream& stream, size_t offset,
const char* buffer, size_t len) {
- sk_sp<SkData> data(stream.copyToData());
+ sk_sp<SkData> data = stream.snapshotAsData();
if (offset + len > data->size()) {
return false;
}
canvas->flush();
document->endPage();
document->close();
- sk_sp<SkData> pdfData(pdf.copyToData());
+ sk_sp<SkData> pdfData(pdf.detachAsData());
SkASSERT(pdfData);
- pdf.reset();
REPORTER_ASSERT(r, is_subset_of(mandrillData.get(), pdfData.get()));
canvas->flush();
document->endPage();
document->close();
- pdfData.reset(pdf.copyToData());
+ pdfData = pdf.detachAsData();
SkASSERT(pdfData);
- pdf.reset();
REPORTER_ASSERT(r, is_subset_of(mandrillData.get(), pdfData.get()));
metadata, nullptr, false);
doc->beginPage(612.0f, 792.0f);
doc->close();
- sk_sp<SkData> data(pdf.copyToData());
+ sk_sp<SkData> data = pdf.detachAsData();
static const char* expectations[] = {
"/Title (A1)",
"/Author (A2)",
compressedByteStream.writeToStream(&expected);
compressedByteStream.reset();
expected.writeText("\nendstream");
- sk_sp<SkData> expectedResultData2(expected.copyToData());
+ sk_sp<SkData> expectedResultData2(expected.detachAsData());
SkString result = emit_to_string(*stream);
#ifndef SK_PDF_LESS_COMPRESSION
assert_eql(reporter,
bool dumpAsHex, const char* str) {
SkDynamicMemoryWStream wStream;
path.dump(&wStream, force, dumpAsHex);
- sk_sp<SkData> data(wStream.copyToData());
+ sk_sp<SkData> data = wStream.detachAsData();
REPORTER_ASSERT(reporter, data->size() == strlen(str));
if (strlen(str) > 0) {
REPORTER_ASSERT(reporter, !memcmp(data->data(), str, strlen(str)));
SkAutoTUnref<SkPixelSerializer> serializer(
SkImageEncoder::CreatePixelSerializer());
picture->serialize(&wStream, serializer);
- return sk_sp<SkData>(wStream.copyToData());
+ return wStream.detachAsData();
}
struct ErrorContext {
if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
return;
}
- sk_sp<SkData> data(wStream.copyToData());
+ sk_sp<SkData> data = wStream.detachAsData();
SkBitmap bm;
bool installSuccess = SkDEPRECATED_InstallDiscardablePixelRef(data.get(), &bm);
REPORTER_ASSERT(reporter, ds.getOffset() == 100 * 26);
{
- sk_sp<SkData> data(ds.copyToData());
+ sk_sp<SkData> data = ds.snapshotAsData();
REPORTER_ASSERT(reporter, 100 * 26 == data->size());
REPORTER_ASSERT(reporter, memcmp(dst, data->data(), data->size()) == 0);
}
{
- // Test that this works after a copyToData.
+ // Test that this works after a snapshot.
SkAutoTDelete<SkStreamAsset> stream(ds.detachAsStream());
REPORTER_ASSERT(reporter, ds.getOffset() == 0);
test_loop_stream(reporter, stream.get(), s, 26, 100);
static void TestDereferencingData(SkMemoryStream* memStream) {
memStream->read(nullptr, 0);
memStream->getMemoryBase();
- sk_sp<SkData> data(memStream->copyToData());
+ (void)memStream->asData();
}
static void TestNullData() {
- SkData* nullData = nullptr;
- SkMemoryStream memStream(nullData);
+ SkMemoryStream memStream(nullptr);
TestDereferencingData(&memStream);
- memStream.setData(nullData);
+ memStream.setData(nullptr);
TestDereferencingData(&memStream);
}
ERRORF(reporter, "SkStreamCopy failed");
return;
}
- sk_sp<SkData> data(tgt.copyToData());
- tgt.reset();
+ sk_sp<SkData> data(tgt.detachAsData());
if (data->size() != N) {
ERRORF(reporter, "SkStreamCopy incorrect size");
return;
uint16_t weight, uint16_t width, SkData* data)
{
sk_sp<SkData> dataCopy;
- SkData* dataToUse = data;
- if (!dataToUse->unique()) {
+ if (!data->unique()) {
dataCopy = SkData::MakeWithCopy(data->data(), data->size());
- dataToUse = dataCopy.get();
+ data = dataCopy.get();
}
- SkSFNTHeader* sfntHeader = static_cast<SkSFNTHeader*>(dataToUse->writable_data());
+ SkSFNTHeader* sfntHeader = static_cast<SkSFNTHeader*>(data->writable_data());
SkSFNTHeader::TableDirectoryEntry* tableEntry =
SkTAfter<SkSFNTHeader::TableDirectoryEntry>(sfntHeader);
using WidthType = SkOTTableOS2_V0::WidthClass::Value;
os2Table->usWidthClass.value = static_cast<WidthType>(SkEndian_SwapBE16(width));
- sk_sp<SkTypeface> newTypeface(SkTypeface::MakeFromStream(new SkMemoryStream(dataToUse)));
+ sk_sp<SkTypeface> newTypeface(SkTypeface::MakeFromStream(new SkMemoryStream(sk_ref_sp(data))));
SkASSERT_RELEASE(newTypeface);
SkFontStyle newStyle = newTypeface->fontStyle();
SkDynamicMemoryWStream out;
SkDrawCommand::WritePNG((const png_bytep) encodedBitmap->bytes(), image.width(), image.height(),
out, false);
- SkData* encoded = out.copyToData();
+ sk_sp<SkData> encoded = out.detachAsData();
Json::Value jsonData;
encode_data(encoded->data(), encoded->size(), "image/png", urlDataManager, &jsonData);
(*target)[SKDEBUGCANVAS_ATTRIBUTE_DATA] = jsonData;
- encoded->unref();
return true;
}
srand(0);
draw(document->beginPage(options.size.width(), options.size.height()));
document->close();
- pdfData.reset(pdfStream.copyToData());
+ pdfData = pdfStream.detachAsData();
}
}
if (options.skp) {
auto picture = recorder.finishRecordingAsPicture();
SkDynamicMemoryWStream skpStream;
picture->serialize(&skpStream);
- skpData.reset(skpStream.copyToData());
+ skpData = skpStream.detachAsData();
}
printf("{\n");
gSeen.add(digest);
sk_sp<SkData> data(SkData::MakeWithoutCopy(ptr, len));
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
if (!codec) {
// FIXME: This code is currently unreachable because we create an empty generator when
// we fail to create a codec.
if (resource.fBitmap.empty() && !DiffResource::isStatusFailed(resource.fStatus)) {
sk_sp<SkData> fileBits(read_file(resource.fFullPath.c_str()));
if (fileBits) {
- get_bitmap(fileBits.get(), resource, true);
+ get_bitmap(fileBits, resource, true);
} else {
SkDebugf("WARNING: couldn't read %s file <%s>\n", name, resource.fFullPath.c_str());
resource.fStatus = DiffResource::kCouldNotRead_Status;
VERBOSE_STATUS("MATCH", ANSI_COLOR_GREEN, baseFiles[i]);
} else {
AutoReleasePixels arp(drp);
- get_bitmap(baseFileBits.get(), drp->fBase, false);
- get_bitmap(comparisonFileBits.get(), drp->fComparison, false);
+ get_bitmap(baseFileBits, drp->fBase, false);
+ get_bitmap(comparisonFileBits, drp->fComparison, false);
VERBOSE_STATUS("DIFFERENT", ANSI_COLOR_RED, baseFiles[i]);
if (DiffResource::kDecoded_Status == drp->fBase.fStatus &&
DiffResource::kDecoded_Status == drp->fComparison.fStatus) {
return data;
}
-bool get_bitmap(SkData* fileBits, DiffResource& resource, bool sizeOnly) {
+bool get_bitmap(sk_sp<SkData> fileBits, DiffResource& resource, bool sizeOnly) {
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(fileBits));
if (!codec) {
SkDebugf("ERROR: could not create codec for <%s>\n", resource.fFullPath.c_str());
sk_sp<SkData> read_file(const char* file_path);
/** Decodes the fileBits into the resource.fBitmap. Returns false on failure. */
-bool get_bitmap(SkData* fileBits, DiffResource& resource, bool sizeOnly);
+bool get_bitmap(sk_sp<SkData> fileBits, DiffResource& resource, bool sizeOnly);
/** Writes the bitmap as a PNG to the path specified. */
bool write_bitmap(const SkString& path, const SkBitmap& bitmap);
SkDynamicMemoryWStream buffer;
SkDrawCommand::WritePNG((const png_bytep) encodedBitmap->bytes(), bmp->width(), bmp->height(),
buffer, true);
- return sk_sp<SkData>(buffer.copyToData());
+ return buffer.detachAsData();
}
SkCanvas* Request::getCanvas() {
SkAutoTUnref<SkPixelSerializer> serializer(SkImageEncoder::CreatePixelSerializer());
picture->serialize(&outStream, serializer);
- return sk_sp<SkData>(outStream.copyToData());
+ return outStream.detachAsData();
}
GrContext* Request::getContext() {
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(root).c_str());
- return sk_sp<SkData>(stream.copyToData());
+ return stream.detachAsData();
}
sk_sp<SkData> Request::getJsonBatchList(int n) {
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(result).c_str());
- return sk_sp<SkData>(stream.copyToData());
+ return stream.detachAsData();
}
sk_sp<SkData> Request::getJsonInfo(int n) {
// Convert to format suitable for inspection
sk_sp<SkData> encodedBitmap = sk_tools::encode_bitmap_for_png(*bitmap);
- SkASSERT(encodedBitmap.get());
+ SkASSERT(encodedBitmap);
const uint8_t* start = encodedBitmap->bytes() + ((y * bitmap->width() + x) * 4);
SkColor result = SkColorSetARGB(start[3], start[0], start[1], start[2]);
canvas->restoreToCount(saveCount);
SkDynamicMemoryWStream stream;
stream.writeText(Json::FastWriter().write(response).c_str());
- sk_sp<SkData> data(stream.copyToData());
- return SendData(connection, data.get(), "application/json");
+ return SendData(connection, stream.detachAsData().get(), "application/json");
}
void ImageSlide::load(SkScalar, SkScalar) {
sk_sp<SkData> encoded = SkData::MakeFromFileName(fPath.c_str());
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(encoded));
if (!codec) {
return;
}
SkDebugf("Cannot find input image.\n");
return -1;
}
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data));
if (!codec) {
SkDebugf("Invalid input image.\n");
return -1;