Move off SK_SUPPORT_LEGACY_DATA_FACTORIES.
This moves Skia code off of SK_SUPPORT_LEGACY_DATA_FACTORIES.
GOLD_TRYBOT_URL= https://gold.skia.org/search?issue=2206633004
Review-Url: https://codereview.chromium.org/2206633004
diff --git a/tests/AnnotationTest.cpp b/tests/AnnotationTest.cpp
index 400d488..a4109c5 100644
--- a/tests/AnnotationTest.cpp
+++ b/tests/AnnotationTest.cpp
@@ -31,7 +31,7 @@
SkCanvas canvas(bm);
SkRect r = SkRect::MakeWH(SkIntToScalar(10), SkIntToScalar(10));
- SkAutoDataUnref data(SkData::NewWithCString("http://www.gooogle.com"));
+ sk_sp<SkData> data(SkData::MakeWithCString("http://www.gooogle.com"));
REPORTER_ASSERT(reporter, 0 == *bm.getAddr32(0, 0));
SkAnnotateRectWithURL(&canvas, r, data.get());
@@ -47,11 +47,11 @@
SkRect r = SkRect::MakeXYWH(SkIntToScalar(72), SkIntToScalar(72),
SkIntToScalar(288), SkIntToScalar(72));
- SkAutoDataUnref data(SkData::NewWithCString("http://www.gooogle.com"));
+ sk_sp<SkData> data(SkData::MakeWithCString("http://www.gooogle.com"));
SkAnnotateRectWithURL(canvas, r, data.get());
REPORTER_ASSERT(reporter, doc->close());
- SkAutoDataUnref out(outStream.copyToData());
+ sk_sp<SkData> out(outStream.copyToData());
const char* rawOutput = (const char*)out->data();
REPORTER_ASSERT(reporter, ContainsString(rawOutput, out->size(), "/Annots "));
@@ -65,11 +65,11 @@
REPORTER_ASSERT(reporter, canvas);
SkPoint p = SkPoint::Make(SkIntToScalar(72), SkIntToScalar(72));
- SkAutoDataUnref data(SkData::NewWithCString("example"));
+ sk_sp<SkData> data(SkData::MakeWithCString("example"));
SkAnnotateNamedDestination(canvas, p, data.get());
REPORTER_ASSERT(reporter, doc->close());
- SkAutoDataUnref out(outStream.copyToData());
+ sk_sp<SkData> out(outStream.copyToData());
const char* rawOutput = (const char*)out->data();
REPORTER_ASSERT(reporter,
diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index da4a111..1c89895 100644
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -107,7 +107,7 @@
};
for (size_t i = 0; i < SK_ARRAY_COUNT(types); i++) {
SkImageEncoder::Type type = types[i];
- SkAutoDataUnref 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;
diff --git a/tests/CodecPriv.h b/tests/CodecPriv.h
index 1123a41..4e42731 100644
--- a/tests/CodecPriv.h
+++ b/tests/CodecPriv.h
@@ -10,7 +10,7 @@
#include "SkData.h"
inline bool decode_memory(const void* mem, size_t size, SkBitmap* bm) {
- SkAutoTUnref<SkData> data(SkData::NewWithoutCopy(mem, size));
+ sk_sp<SkData> data(SkData::MakeWithoutCopy(mem, size));
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromData(data.get()));
if (!codec) {
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index b8b957f..7e1b594 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -208,8 +208,8 @@
bool isIncomplete = supportsIncomplete;
if (isIncomplete) {
size_t size = stream->getLength();
- SkAutoTUnref<SkData> data((SkData::NewFromStream(stream, 2 * size / 3)));
- codec.reset(SkCodec::NewFromData(data));
+ sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
+ codec.reset(SkCodec::NewFromData(data.get()));
} else {
codec.reset(SkCodec::NewFromStream(stream.release()));
}
@@ -337,8 +337,8 @@
SkAutoTDelete<SkAndroidCodec> androidCodec(nullptr);
if (isIncomplete) {
size_t size = stream->getLength();
- SkAutoTUnref<SkData> data((SkData::NewFromStream(stream, 2 * size / 3)));
- androidCodec.reset(SkAndroidCodec::NewFromData(data));
+ sk_sp<SkData> data((SkData::MakeFromStream(stream, 2 * size / 3)));
+ androidCodec.reset(SkAndroidCodec::NewFromData(data.get()));
} else {
androidCodec.reset(SkAndroidCodec::NewFromStream(stream.release()));
}
@@ -356,8 +356,9 @@
if (!isIncomplete) {
// Test SkCodecImageGenerator
SkAutoTDelete<SkStream> stream(resource(path));
- SkAutoTUnref<SkData> fullData(SkData::NewFromStream(stream, stream->getLength()));
- SkAutoTDelete<SkImageGenerator> gen(SkCodecImageGenerator::NewFromEncodedCodec(fullData));
+ sk_sp<SkData> fullData(SkData::MakeFromStream(stream, stream->getLength()));
+ SkAutoTDelete<SkImageGenerator> gen(
+ SkCodecImageGenerator::NewFromEncodedCodec(fullData.get()));
SkBitmap bm;
bm.allocPixels(info);
SkAutoLockPixels autoLockPixels(bm);
@@ -365,8 +366,8 @@
compare_to_good_digest(r, codecDigest, bm);
// Test using SkFrontBufferedStream, as Android does
- SkStream* bufferedStream = SkFrontBufferedStream::Create(new SkMemoryStream(fullData),
- SkCodec::MinBufferedBytesNeeded());
+ SkStream* bufferedStream = SkFrontBufferedStream::Create(
+ new SkMemoryStream(std::move(fullData)), SkCodec::MinBufferedBytesNeeded());
REPORTER_ASSERT(r, bufferedStream);
codec.reset(SkCodec::NewFromStream(bufferedStream));
REPORTER_ASSERT(r, codec);
@@ -887,7 +888,7 @@
// Stream that is not an asset stream (!hasPosition() or !hasLength())
class NotAssetMemStream : public SkStream {
public:
- NotAssetMemStream(SkData* data) : fStream(data) {}
+ NotAssetMemStream(sk_sp<SkData> data) : fStream(std::move(data)) {}
bool hasPosition() const override {
return false;
@@ -920,13 +921,13 @@
DEF_TEST(Codec_raw_notseekable, r) {
const char* path = "dng_with_preview.dng";
SkString fullPath(GetResourcePath(path));
- SkAutoTUnref<SkData> data(SkData::NewFromFileName(fullPath.c_str()));
+ sk_sp<SkData> data(SkData::MakeFromFileName(fullPath.c_str()));
if (!data) {
SkDebugf("Missing resource '%s'\n", path);
return;
}
- SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(data)));
+ SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(std::move(data))));
REPORTER_ASSERT(r, codec);
test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
diff --git a/tests/DataRefTest.cpp b/tests/DataRefTest.cpp
index 03f66c5..59b56fb 100644
--- a/tests/DataRefTest.cpp
+++ b/tests/DataRefTest.cpp
@@ -149,11 +149,11 @@
delete[] data;
}
-static void assert_len(skiatest::Reporter* reporter, SkData* ref, size_t len) {
+static void assert_len(skiatest::Reporter* reporter, const sk_sp<SkData>& ref, size_t len) {
REPORTER_ASSERT(reporter, ref->size() == len);
}
-static void assert_data(skiatest::Reporter* reporter, SkData* ref,
+static void assert_data(skiatest::Reporter* reporter, const sk_sp<SkData>& ref,
const void* data, size_t len) {
REPORTER_ASSERT(reporter, ref->size() == len);
REPORTER_ASSERT(reporter, !memcmp(ref->data(), data, len));
@@ -163,12 +163,12 @@
const char str[] = "Hello world";
size_t len = strlen(str);
- SkAutoTUnref<SkData> r0(SkData::NewWithCopy(str, len + 1));
- SkAutoTUnref<SkData> r1(SkData::NewWithCString(str));
+ sk_sp<SkData> r0(SkData::MakeWithCopy(str, len + 1));
+ sk_sp<SkData> r1(SkData::MakeWithCString(str));
- REPORTER_ASSERT(reporter, r0->equals(r1));
+ REPORTER_ASSERT(reporter, r0->equals(r1.get()));
- SkAutoTUnref<SkData> r2(SkData::NewWithCString(nullptr));
+ sk_sp<SkData> r2(SkData::MakeWithCString(nullptr));
REPORTER_ASSERT(reporter, 1 == r2->size());
REPORTER_ASSERT(reporter, 0 == *r2->bytes());
}
@@ -192,13 +192,13 @@
}
FILE* file = sk_fopen(path.c_str(), kRead_SkFILE_Flag);
- SkAutoTUnref<SkData> r1(SkData::NewFromFILE(file));
+ sk_sp<SkData> r1(SkData::MakeFromFILE(file));
REPORTER_ASSERT(reporter, r1.get() != nullptr);
REPORTER_ASSERT(reporter, r1->size() == 26);
REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r1->data()), s, 26) == 0);
int fd = sk_fileno(file);
- SkAutoTUnref<SkData> r2(SkData::NewFromFD(fd));
+ sk_sp<SkData> r2(SkData::MakeFromFD(fd));
REPORTER_ASSERT(reporter, r2.get() != nullptr);
REPORTER_ASSERT(reporter, r2->size() == 26);
REPORTER_ASSERT(reporter, strncmp(static_cast<const char*>(r2->data()), s, 26) == 0);
@@ -208,11 +208,10 @@
const char* str = "We the people, in order to form a more perfect union.";
const int N = 10;
- SkAutoTUnref<SkData> r0(SkData::NewEmpty());
- SkAutoTUnref<SkData> r1(SkData::NewWithCopy(str, strlen(str)));
- SkAutoTUnref<SkData> r2(SkData::NewWithProc(new int[N], N*sizeof(int),
- delete_int_proc, gGlobal));
- SkAutoTUnref<SkData> r3(SkData::NewSubset(r1, 7, 6));
+ sk_sp<SkData> r0(SkData::MakeEmpty());
+ sk_sp<SkData> r1(SkData::MakeWithCopy(str, strlen(str)));
+ sk_sp<SkData> r2(SkData::MakeWithProc(new int[N], N*sizeof(int), delete_int_proc, gGlobal));
+ sk_sp<SkData> r3(SkData::MakeSubset(r1.get(), 7, 6));
assert_len(reporter, r0, 0);
assert_len(reporter, r1, strlen(str));
@@ -222,12 +221,10 @@
assert_data(reporter, r1, str, strlen(str));
assert_data(reporter, r3, "people", 6);
- SkData* tmp = SkData::NewSubset(r1, strlen(str), 10);
+ sk_sp<SkData> tmp(SkData::MakeSubset(r1.get(), strlen(str), 10));
assert_len(reporter, tmp, 0);
- tmp->unref();
- tmp = SkData::NewSubset(r1, 0, 0);
+ tmp = SkData::MakeSubset(r1.get(), 0, 0);
assert_len(reporter, tmp, 0);
- tmp->unref();
test_cstring(reporter);
test_files(reporter);
diff --git a/tests/ImageGeneratorTest.cpp b/tests/ImageGeneratorTest.cpp
index 3d750b2..63a47e4 100644
--- a/tests/ImageGeneratorTest.cpp
+++ b/tests/ImageGeneratorTest.cpp
@@ -19,21 +19,21 @@
static void test_imagegenerator_factory(skiatest::Reporter* reporter) {
// just need a non-empty data to test things
- SkAutoTUnref<SkData> data(SkData::NewWithCString("test_imagegenerator_factory"));
+ sk_sp<SkData> data(SkData::MakeWithCString("test_imagegenerator_factory"));
gMyFactoryWasCalled = false;
SkImageGenerator* gen;
REPORTER_ASSERT(reporter, !gMyFactoryWasCalled);
- gen = SkImageGenerator::NewFromEncoded(data);
+ gen = SkImageGenerator::NewFromEncoded(data.get());
REPORTER_ASSERT(reporter, nullptr == gen);
REPORTER_ASSERT(reporter, !gMyFactoryWasCalled);
// Test is racy, in that it hopes no other thread is changing this global...
SkGraphics::ImageGeneratorFromEncodedFactory prev =
SkGraphics::SetImageGeneratorFromEncodedFactory(my_factory);
- gen = SkImageGenerator::NewFromEncoded(data);
+ gen = SkImageGenerator::NewFromEncoded(data.get());
REPORTER_ASSERT(reporter, nullptr == gen);
REPORTER_ASSERT(reporter, gMyFactoryWasCalled);
SkGraphics::SetImageGeneratorFromEncodedFactory(prev);
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 72dc943..4f77fbd 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -73,22 +73,22 @@
draw_image_test_pattern(surface->getCanvas());
return surface->makeImageSnapshot();
}
-static SkData* create_image_data(SkImageInfo* info) {
+static sk_sp<SkData> create_image_data(SkImageInfo* info) {
*info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
const size_t rowBytes = info->minRowBytes();
- SkAutoTUnref<SkData> data(SkData::NewUninitialized(rowBytes * info->height()));
+ sk_sp<SkData> data(SkData::MakeUninitialized(rowBytes * info->height()));
{
SkBitmap bm;
bm.installPixels(*info, data->writable_data(), rowBytes);
SkCanvas canvas(bm);
draw_image_test_pattern(&canvas);
}
- return data.release();
+ return data;
}
static sk_sp<SkImage> create_data_image() {
SkImageInfo info;
sk_sp<SkData> data(create_image_data(&info));
- return SkImage::MakeRasterData(info, data, info.minRowBytes());
+ return SkImage::MakeRasterData(info, std::move(data), info.minRowBytes());
}
#if SK_SUPPORT_GPU // not gpu-specific but currently only used in GPU tests
static sk_sp<SkImage> create_image_565() {
@@ -134,7 +134,7 @@
// Want to ensure that our Release is called when the owning image is destroyed
struct RasterDataHolder {
RasterDataHolder() : fReleaseCount(0) {}
- SkAutoTUnref<SkData> fData;
+ sk_sp<SkData> fData;
int fReleaseCount;
static void Release(const void* pixels, void* context) {
RasterDataHolder* self = static_cast<RasterDataHolder*>(context);
@@ -145,19 +145,17 @@
static sk_sp<SkImage> create_rasterproc_image(RasterDataHolder* dataHolder) {
SkASSERT(dataHolder);
SkImageInfo info;
- SkAutoTUnref<SkData> data(create_image_data(&info));
- dataHolder->fData.reset(SkRef(data.get()));
- return SkImage::MakeFromRaster(SkPixmap(info, data->data(), info.minRowBytes()),
+ dataHolder->fData = create_image_data(&info);
+ return SkImage::MakeFromRaster(SkPixmap(info, dataHolder->fData->data(), info.minRowBytes()),
RasterDataHolder::Release, dataHolder);
}
static sk_sp<SkImage> create_codec_image() {
SkImageInfo info;
- SkAutoTUnref<SkData> data(create_image_data(&info));
+ sk_sp<SkData> data(create_image_data(&info));
SkBitmap bitmap;
bitmap.installPixels(info, data->writable_data(), info.minRowBytes());
- sk_sp<SkData> src(
- SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
- return SkImage::MakeFromEncoded(src);
+ sk_sp<SkData> src(SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
+ return SkImage::MakeFromEncoded(std::move(src));
}
#if SK_SUPPORT_GPU
static sk_sp<SkImage> create_gpu_image(GrContext* context) {
@@ -231,7 +229,7 @@
class MockSerializer : public SkPixelSerializer {
public:
- MockSerializer(SkData* (*func)()) : fFunc(func), fDidEncode(false) { }
+ MockSerializer(sk_sp<SkData> (*func)()) : fFunc(func), fDidEncode(false) { }
bool didEncode() const { return fDidEncode; }
@@ -242,11 +240,11 @@
SkData* onEncode(const SkPixmap&) override {
fDidEncode = true;
- return fFunc();
+ return fFunc().release();
}
private:
- SkData* (*fFunc)();
+ sk_sp<SkData> (*fFunc)();
bool fDidEncode;
typedef SkPixelSerializer INHERITED;
@@ -256,15 +254,17 @@
// Test that SkImage encoding observes custom pixel serializers.
DEF_TEST(Image_Encode_Serializer, reporter) {
- MockSerializer serializer([]() -> SkData* { return SkData::NewWithCString(kSerializedData); });
+ MockSerializer serializer([]() -> sk_sp<SkData> {
+ return SkData::MakeWithCString(kSerializedData);
+ });
sk_sp<SkImage> image(create_image());
- SkAutoTUnref<SkData> encoded(image->encode(&serializer));
- SkAutoTUnref<SkData> reference(SkData::NewWithCString(kSerializedData));
+ sk_sp<SkData> encoded(image->encode(&serializer));
+ sk_sp<SkData> reference(SkData::MakeWithCString(kSerializedData));
REPORTER_ASSERT(reporter, serializer.didEncode());
REPORTER_ASSERT(reporter, encoded);
REPORTER_ASSERT(reporter, encoded->size() > 0);
- REPORTER_ASSERT(reporter, encoded->equals(reference));
+ REPORTER_ASSERT(reporter, encoded->equals(reference.get()));
}
// Test that image encoding failures do not break picture serialization/deserialization.
@@ -281,8 +281,8 @@
REPORTER_ASSERT(reporter, picture);
REPORTER_ASSERT(reporter, picture->approximateOpCount() > 0);
- MockSerializer emptySerializer([]() -> SkData* { return SkData::NewEmpty(); });
- MockSerializer nullSerializer([]() -> SkData* { return nullptr; });
+ MockSerializer emptySerializer([]() -> sk_sp<SkData> { return SkData::MakeEmpty(); });
+ MockSerializer nullSerializer([]() -> sk_sp<SkData> { return nullptr; });
MockSerializer* serializers[] = { &emptySerializer, &nullSerializer };
for (size_t i = 0; i < SK_ARRAY_COUNT(serializers); ++i) {
diff --git a/tests/MallocPixelRefTest.cpp b/tests/MallocPixelRefTest.cpp
index 2e6c07d..adc6914 100644
--- a/tests/MallocPixelRefTest.cpp
+++ b/tests/MallocPixelRefTest.cpp
@@ -32,18 +32,18 @@
{
size_t rowBytes = info.minRowBytes() - 1;
size_t size = info.getSafeSize(rowBytes);
- SkAutoDataUnref data(SkData::NewUninitialized(size));
+ sk_sp<SkData> data(SkData::MakeUninitialized(size));
SkAutoTUnref<SkMallocPixelRef> pr(
- SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data));
+ SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data.get()));
// rowbytes too small.
REPORTER_ASSERT(reporter, nullptr == pr.get());
}
{
size_t rowBytes = info.minRowBytes() + 2;
size_t size = info.getSafeSize(rowBytes) - 1;
- SkAutoDataUnref data(SkData::NewUninitialized(size));
+ sk_sp<SkData> data(SkData::MakeUninitialized(size));
SkAutoTUnref<SkMallocPixelRef> pr(
- SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data));
+ SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data.get()));
// data too small.
REPORTER_ASSERT(reporter, nullptr == pr.get());
}
@@ -93,7 +93,7 @@
REPORTER_ASSERT(reporter, addr == pr->pixels());
}
{
- SkAutoDataUnref data(SkData::NewUninitialized(size));
+ sk_sp<SkData> data(SkData::MakeUninitialized(size));
SkData* dataPtr = data.get();
REPORTER_ASSERT(reporter, dataPtr->unique());
SkAutoTUnref<SkMallocPixelRef> pr(
diff --git a/tests/PDFGlyphsToUnicodeTest.cpp b/tests/PDFGlyphsToUnicodeTest.cpp
index 529c972..f0425d9 100644
--- a/tests/PDFGlyphsToUnicodeTest.cpp
+++ b/tests/PDFGlyphsToUnicodeTest.cpp
@@ -13,7 +13,7 @@
static bool stream_equals(const SkDynamicMemoryWStream& stream, size_t offset,
const char* buffer, size_t len) {
- SkAutoDataUnref data(stream.copyToData());
+ sk_sp<SkData> data(stream.copyToData());
if (offset + len > data->size()) {
return false;
}
diff --git a/tests/PDFJpegEmbedTest.cpp b/tests/PDFJpegEmbedTest.cpp
index 5ef4a2d..6b10f04 100644
--- a/tests/PDFJpegEmbedTest.cpp
+++ b/tests/PDFJpegEmbedTest.cpp
@@ -38,10 +38,10 @@
}
-static SkData* load_resource(
+static sk_sp<SkData> load_resource(
skiatest::Reporter* r, const char* test, const char* filename) {
SkString path(GetResourcePath(filename));
- SkData* data = SkData::NewFromFileName(path.c_str());
+ sk_sp<SkData> data(SkData::MakeFromFileName(path.c_str()));
if (!data) {
INFOF(r, "\n%s: Resource '%s' can not be found.\n",
test, filename);
@@ -124,13 +124,12 @@
{"mandrill_512_q075.jpg", true, SkJFIFInfo::kYCbCr},
{"randPixels.jpg", true, SkJFIFInfo::kYCbCr}};
for (size_t i = 0; i < SK_ARRAY_COUNT(kTests); ++i) {
- SkAutoTUnref<SkData> data(
- load_resource(r, "JpegIdentification", kTests[i].path));
+ sk_sp<SkData> data(load_resource(r, "JpegIdentification", kTests[i].path));
if (!data) {
continue;
}
SkJFIFInfo info;
- bool isJfif = SkIsJFIF(data, &info);
+ bool isJfif = SkIsJFIF(data.get(), &info);
if (isJfif != kTests[i].isJfif) {
ERRORF(r, "%s failed isJfif test", kTests[i].path);
continue;
diff --git a/tests/PDFPrimitivesTest.cpp b/tests/PDFPrimitivesTest.cpp
index 2ee90b9..6d89dd1 100644
--- a/tests/PDFPrimitivesTest.cpp
+++ b/tests/PDFPrimitivesTest.cpp
@@ -112,7 +112,7 @@
compressedByteStream.writeToStream(&expected);
compressedByteStream.reset();
expected.writeText("\nendstream");
- SkAutoDataUnref expectedResultData2(expected.copyToData());
+ sk_sp<SkData> expectedResultData2(expected.copyToData());
SkString result = emit_to_string(*stream);
assert_eql(reporter,
result,
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index cb330c5..c762760 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -4036,7 +4036,7 @@
bool dumpAsHex, const char* str) {
SkDynamicMemoryWStream wStream;
path.dump(&wStream, force, dumpAsHex);
- SkAutoDataUnref data(wStream.copyToData());
+ sk_sp<SkData> data(wStream.copyToData());
REPORTER_ASSERT(reporter, data->size() == strlen(str));
if (strlen(str) > 0) {
REPORTER_ASSERT(reporter, !memcmp(data->data(), str, strlen(str)));
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 8f5ebd3..749bd6e 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -621,7 +621,7 @@
}
#endif
-static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
+static sk_sp<SkData> serialized_picture_from_bitmap(const SkBitmap& bitmap) {
SkPictureRecorder recorder;
SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(bitmap.width()),
SkIntToScalar(bitmap.height()));
@@ -632,7 +632,7 @@
SkAutoTUnref<SkPixelSerializer> serializer(
SkImageEncoder::CreatePixelSerializer());
picture->serialize(&wStream, serializer);
- return wStream.copyToData();
+ return sk_sp<SkData>(wStream.copyToData());
}
struct ErrorContext {
@@ -670,18 +670,18 @@
if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
return;
}
- SkAutoDataUnref data(wStream.copyToData());
+ sk_sp<SkData> data(wStream.copyToData());
SkBitmap bm;
- bool installSuccess = SkDEPRECATED_InstallDiscardablePixelRef(data, &bm);
+ bool installSuccess = SkDEPRECATED_InstallDiscardablePixelRef(data.get(), &bm);
REPORTER_ASSERT(reporter, installSuccess);
// Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
// Flattening original will follow the old path of performing an encode, while flattening bm
// will use the already encoded data.
- SkAutoDataUnref picture1(serialized_picture_from_bitmap(original));
- SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
- REPORTER_ASSERT(reporter, picture1->equals(picture2));
+ sk_sp<SkData> picture1(serialized_picture_from_bitmap(original));
+ sk_sp<SkData> picture2(serialized_picture_from_bitmap(bm));
+ REPORTER_ASSERT(reporter, picture1->equals(picture2.get()));
// Now test that a parse error was generated when trying to create a new SkPicture without
// providing a function to decode the bitmap.
@@ -689,7 +689,7 @@
context.fErrors = 0;
context.fReporter = reporter;
SkSetErrorCallback(assert_one_parse_error_cb, &context);
- SkMemoryStream pictureStream(picture1);
+ SkMemoryStream pictureStream(std::move(picture1));
SkClearLastError();
sk_sp<SkPicture> pictureFromStream(SkPicture::MakeFromStream(&pictureStream, nullptr));
REPORTER_ASSERT(reporter, pictureFromStream.get() != nullptr);
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index bd2bb2f..289fdd9 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -871,8 +871,7 @@
make_unique_key<0>(&key2, 0);
SkAutoTUnref<TestResource> d(new TestResource(context->getGpu()));
int foo = 4132;
- SkAutoTUnref<SkData> data(SkData::NewWithCopy(&foo, sizeof(foo)));
- key2.setCustomData(data.get());
+ key2.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo)));
d->resourcePriv().setUniqueKey(key2);
}
@@ -1262,8 +1261,7 @@
make_unique_key<0>(&key1, 1);
make_unique_key<0>(&key2, 2);
int foo = 4132;
- SkAutoTUnref<SkData> data(SkData::NewWithCopy(&foo, sizeof(foo)));
- key1.setCustomData(data.get());
+ key1.setCustomData(SkData::MakeWithCopy(&foo, sizeof(foo)));
REPORTER_ASSERT(reporter, *(int*) key1.getCustomData()->data() == 4132);
REPORTER_ASSERT(reporter, key2.getCustomData() == nullptr);
@@ -1283,7 +1281,7 @@
// Call all the public methods on resource in the abandoned state. They shouldn't crash.
int foo = 4132;
- SkAutoTUnref<SkData> data(SkData::NewWithCopy(&foo, sizeof(foo)));
+ sk_sp<SkData> data(SkData::MakeWithCopy(&foo, sizeof(foo)));
resource->setCustomData(data.get());
resource->getCustomData();
resource->getUniqueID();
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index a6be188..0e53ac6 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -634,7 +634,7 @@
struct AnnotationRec {
const SkRect fRect;
const char* fKey;
- SkData* fValue;
+ sk_sp<SkData> fValue;
};
class TestAnnotationCanvas : public SkCanvas {
@@ -661,7 +661,7 @@
REPORTER_ASSERT(fReporter, fCurrIndex < fCount);
REPORTER_ASSERT(fReporter, rect == fRec[fCurrIndex].fRect);
REPORTER_ASSERT(fReporter, !strcmp(key, fRec[fCurrIndex].fKey));
- REPORTER_ASSERT(fReporter, value->equals(fRec[fCurrIndex].fValue));
+ REPORTER_ASSERT(fReporter, value->equals(fRec[fCurrIndex].fValue.get()));
fCurrIndex += 1;
}
};
@@ -676,23 +676,23 @@
const char* str0 = "rect-with-url";
const SkRect r0 = SkRect::MakeWH(10, 10);
- SkAutoTUnref<SkData> d0(SkData::NewWithCString(str0));
- SkAnnotateRectWithURL(recordingCanvas, r0, d0);
+ sk_sp<SkData> d0(SkData::MakeWithCString(str0));
+ SkAnnotateRectWithURL(recordingCanvas, r0, d0.get());
const char* str1 = "named-destination";
const SkRect r1 = SkRect::MakeXYWH(5, 5, 0, 0); // collapsed to a point
- SkAutoTUnref<SkData> d1(SkData::NewWithCString(str1));
- SkAnnotateNamedDestination(recordingCanvas, {r1.x(), r1.y()}, d1);
+ sk_sp<SkData> d1(SkData::MakeWithCString(str1));
+ SkAnnotateNamedDestination(recordingCanvas, {r1.x(), r1.y()}, d1.get());
const char* str2 = "link-to-destination";
const SkRect r2 = SkRect::MakeXYWH(20, 20, 5, 6);
- SkAutoTUnref<SkData> d2(SkData::NewWithCString(str2));
- SkAnnotateLinkToDestination(recordingCanvas, r2, d2);
+ sk_sp<SkData> d2(SkData::MakeWithCString(str2));
+ SkAnnotateLinkToDestination(recordingCanvas, r2, d2.get());
const AnnotationRec recs[] = {
- { r0, SkAnnotationKeys::URL_Key(), d0 },
- { r1, SkAnnotationKeys::Define_Named_Dest_Key(), d1 },
- { r2, SkAnnotationKeys::Link_Named_Dest_Key(), d2 },
+ { r0, SkAnnotationKeys::URL_Key(), std::move(d0) },
+ { r1, SkAnnotationKeys::Define_Named_Dest_Key(), std::move(d1) },
+ { r2, SkAnnotationKeys::Link_Named_Dest_Key(), std::move(d2) },
};
sk_sp<SkPicture> pict0(recorder.finishRecordingAsPicture());
diff --git a/tests/StreamTest.cpp b/tests/StreamTest.cpp
index fe4da0f..50523ff 100644
--- a/tests/StreamTest.cpp
+++ b/tests/StreamTest.cpp
@@ -174,7 +174,7 @@
static void TestDereferencingData(SkMemoryStream* memStream) {
memStream->read(nullptr, 0);
memStream->getMemoryBase();
- SkAutoDataUnref data(memStream->copyToData());
+ sk_sp<SkData> data(memStream->copyToData());
}
static void TestNullData() {
@@ -361,7 +361,7 @@
dynamicMemoryWStream.write(buffer, size);
}
SkAutoTDelete<SkStreamAsset> asset(dynamicMemoryWStream.detachAsStream());
- SkAutoTUnref<SkData> expected(SkData::NewUninitialized(asset->getLength()));
+ sk_sp<SkData> expected(SkData::MakeUninitialized(asset->getLength()));
uint8_t* expectedPtr = static_cast<uint8_t*>(expected->writable_data());
valueSource.setSeed(kSeed); // reseed.
// We want the exact same same "random" string of numbers to put
@@ -370,7 +370,7 @@
for (size_t i = 0; i < asset->getLength(); ++i) {
expectedPtr[i] = valueSource.nextU() & 0xFF;
}
- stream_peek_test(rep, asset, expected);
+ stream_peek_test(rep, asset, expected.get());
}
namespace {
diff --git a/tests/TextureCompressionTest.cpp b/tests/TextureCompressionTest.cpp
index e1992a0..06be9ce 100644
--- a/tests/TextureCompressionTest.cpp
+++ b/tests/TextureCompressionTest.cpp
@@ -64,7 +64,7 @@
if (!compresses_a8(fmt)) {
continue;
}
- SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
+ sk_sp<SkData> data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
REPORTER_ASSERT(reporter, nullptr == data);
}
}
@@ -93,7 +93,7 @@
if (!compresses_a8(fmt)) {
continue;
}
- SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
+ sk_sp<SkData> data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
REPORTER_ASSERT(reporter, nullptr == data);
}
}
@@ -154,7 +154,7 @@
continue;
}
- SkAutoDataUnref data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
+ sk_sp<SkData> data(SkTextureCompressor::CompressBitmapToFormat(pixmap, fmt));
REPORTER_ASSERT(reporter, data);
if (nullptr == data) {
continue;
@@ -212,7 +212,7 @@
pixels[i] = lum;
}
- SkAutoDataUnref latcData(
+ sk_sp<SkData> latcData(
SkTextureCompressor::CompressBitmapToFormat(pixmap, kLATCFormat));
REPORTER_ASSERT(reporter, latcData);
if (nullptr == latcData) {
diff --git a/tests/Writer32Test.cpp b/tests/Writer32Test.cpp
index ac932e1..3eab94c 100644
--- a/tests/Writer32Test.cpp
+++ b/tests/Writer32Test.cpp
@@ -267,13 +267,13 @@
DEF_TEST(Writer32_data, reporter) {
const char* str = "0123456789";
- SkAutoTUnref<SkData> data0(SkData::NewWithCString(str));
- SkAutoTUnref<SkData> data1(SkData::NewEmpty());
+ sk_sp<SkData> data0(SkData::MakeWithCString(str));
+ sk_sp<SkData> data1(SkData::MakeEmpty());
const size_t sizes[] = {
SkWriter32::WriteDataSize(nullptr),
- SkWriter32::WriteDataSize(data0),
- SkWriter32::WriteDataSize(data1),
+ SkWriter32::WriteDataSize(data0.get()),
+ SkWriter32::WriteDataSize(data1.get()),
};
SkSWriter32<1000> writer;
@@ -283,11 +283,11 @@
sizeWritten += sizes[0];
REPORTER_ASSERT(reporter, sizeWritten == writer.bytesWritten());
- writer.writeData(data0);
+ writer.writeData(data0.get());
sizeWritten += sizes[1];
REPORTER_ASSERT(reporter, sizeWritten == writer.bytesWritten());
- writer.writeData(data1);
+ writer.writeData(data1.get());
sizeWritten += sizes[2];
REPORTER_ASSERT(reporter, sizeWritten == writer.bytesWritten());