Revert "Revert[2] "clean up (partially) colortable api"""
This reverts commit 9920b10f5292838f00600f676c4578cd11705e60.
Reason for revert: trying to get details on w2k failure
https://chromium-swarm.appspot.com/task?id=354345d34ba3b310&refresh=10
Caught exception 3221225477 EXCEPTION_ACCESS_VIOLATION, was running:
unit test HugeBlurImageFilter
unit test FontNames
unit test Codec_PngRoundTrip
unit test ClampRange
unit test FontHost
unit test ColorMatrixFilter
f16 image scaled_codec_premul abnormal.wbmp
565 image brd_android_codec_divisor_0.167 interlaced3.png_0.167
unit test Codec_png
unit test ImageFilterBlurLargeImage
unit test FontObj
unit test DrawText
unit test GrShape
565 image brd_android_codec_divisor_0.333 interlaced2.png_0.333
unit test PathOpsOpCubicsThreaded
unit test PathOpsOpLoopsThreaded
unit test FontMgr
unit test ColorToHSVRoundTrip
unit test Image_Serialize_Encoding_Failure
Likely culprit:
unit test Image_Serialize_Encoding_Failure
step returned non-zero exit code: -1073741819
Original change's description:
> Revert[2] "clean up (partially) colortable api""
>
> This reverts commit 1d1165ca6575e082b892c5460492c411618783ad.
>
> Bug: skia:
> Change-Id: Idbc0634ae3cec2e79f592d252de8751b077e6408
> Reviewed-on: https://skia-review.googlesource.com/11024
> Reviewed-by: Mike Reed <reed@google.com>
> Commit-Queue: Mike Reed <reed@google.com>
>
TBR=reed@google.com,reviews@skia.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
Change-Id: Ia4e73434b083224baa36092c69526c2f59bb16aa
Reviewed-on: https://skia-review.googlesource.com/11025
Reviewed-by: Mike Reed <reed@google.com>
Commit-Queue: Mike Reed <reed@google.com>
diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index fdf17e9..8e881a6 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -44,8 +44,10 @@
}
}
}
+ SkColorTable* ctable = new SkColorTable(storage, 216);
dst->allocPixels(SkImageInfo::Make(src.width(), src.height(), kIndex_8_SkColorType, aType),
- SkColorTable::Make(storage, 216));
+ nullptr, ctable);
+ ctable->unref();
SkAutoLockPixels alps(src);
SkAutoLockPixels alpd(*dst);
diff --git a/bench/RepeatTileBench.cpp b/bench/RepeatTileBench.cpp
index df58a14..33e9178 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp
@@ -62,9 +62,11 @@
}
}
}
+ SkColorTable* ctable = new SkColorTable(storage, 216);
dst->allocPixels(SkImageInfo::Make(src.width(), src.height(),
kIndex_8_SkColorType, kOpaque_SkAlphaType),
- SkColorTable::Make(storage, 216));
+ nullptr, ctable);
+ ctable->unref();
SkAutoLockPixels alps(src);
SkAutoLockPixels alpd(*dst);
diff --git a/dm/DMSrcSink.cpp b/dm/DMSrcSink.cpp
index f505bb7..eb9ba41 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -1445,9 +1445,11 @@
SkAlphaType alphaType = kPremul_SkAlphaType;
(void)SkColorTypeValidateAlphaType(fColorType, alphaType, &alphaType);
+ SkMallocPixelRef::ZeroedPRFactory factory;
dst->allocPixels(SkImageInfo::Make(size.width(), size.height(),
fColorType, alphaType, fColorSpace),
- nullptr/*colortable*/, SkBitmap::kZeroPixels_AllocFlag);
+ &factory,
+ nullptr/*colortable*/);
SkCanvas canvas(*dst);
return src.draw(&canvas);
}
diff --git a/fuzz/fuzz.cpp b/fuzz/fuzz.cpp
index 8e2a733..8374f95 100644
--- a/fuzz/fuzz.cpp
+++ b/fuzz/fuzz.cpp
@@ -224,10 +224,11 @@
}
SkBitmap bitmap;
+ SkMallocPixelRef::ZeroedPRFactory zeroFactory;
SkCodec::Options options;
options.fZeroInitialized = SkCodec::kYes_ZeroInitialized;
- if (!bitmap.tryAllocPixels(decodeInfo, colorTable, SkBitmap::kZeroPixels_AllocFlag)) {
+ if (!bitmap.tryAllocPixels(decodeInfo, &zeroFactory, colorTable.get())) {
SkDebugf("[terminated] Could not allocate memory. Image might be too large (%d x %d)",
decodeInfo.width(), decodeInfo.height());
return;
diff --git a/gm/all_bitmap_configs.cpp b/gm/all_bitmap_configs.cpp
index 60aec88..ea7b734 100644
--- a/gm/all_bitmap_configs.cpp
+++ b/gm/all_bitmap_configs.cpp
@@ -124,9 +124,10 @@
pmColors[i] = premultiply_color(colors[i]);
}
SkBitmap bm;
+ sk_sp<SkColorTable> ctable(new SkColorTable(pmColors, SK_ARRAY_COUNT(pmColors)));
SkImageInfo info = SkImageInfo::Make(SCALE, SCALE, kIndex_8_SkColorType,
kPremul_SkAlphaType);
- bm.allocPixels(info, SkColorTable::Make(pmColors, SK_ARRAY_COUNT(pmColors)));
+ bm.allocPixels(info, nullptr, ctable.get());
SkAutoLockPixels autoLockPixels1(n32bitmap);
SkAutoLockPixels autoLockPixels2(bm);
for (int y = 0; y < SCALE; ++y) {
diff --git a/gm/bitmapfilters.cpp b/gm/bitmapfilters.cpp
index 22e5d09..2cded98 100644
--- a/gm/bitmapfilters.cpp
+++ b/gm/bitmapfilters.cpp
@@ -17,9 +17,12 @@
for (size_t i = 0; i < SK_ARRAY_COUNT(colors); ++i) {
colorsPM[i] = SkPreMultiplyColor(colors[i]);
}
+ SkColorTable* ctable = new SkColorTable(colorsPM, 4);
+
bm->allocPixels(SkImageInfo::Make(2, 2, kIndex_8_SkColorType,
kPremul_SkAlphaType),
- SkColorTable::Make(colorsPM, 4));
+ nullptr, ctable);
+ ctable->unref();
*bm->getAddr8(0, 0) = 0;
*bm->getAddr8(1, 0) = 1;
diff --git a/gm/encode-srgb.cpp b/gm/encode-srgb.cpp
index 894b0ef..f62d48a 100644
--- a/gm/encode-srgb.cpp
+++ b/gm/encode-srgb.cpp
@@ -67,9 +67,10 @@
pmColors[i] = toPMColor(colors[i]);
}
+ sk_sp<SkColorTable> colorTable(new SkColorTable(pmColors, SK_ARRAY_COUNT(pmColors)));
SkImageInfo info = SkImageInfo::Make(imageWidth, imageHeight, kIndex_8_SkColorType,
alphaType, colorSpace);
- bitmap->allocPixels(info, SkColorTable::Make(pmColors, SK_ARRAY_COUNT(pmColors)));
+ bitmap->allocPixels(info, nullptr, colorTable.get());
for (int y = 0; y < imageHeight; y++) {
for (int x = 0; x < imageWidth; x++) {
*bitmap->getAddr8(x, y) = (x / div_round_up(imageWidth, 2)) +
diff --git a/gm/image_pict.cpp b/gm/image_pict.cpp
index f23b89e..792173c 100644
--- a/gm/image_pict.cpp
+++ b/gm/image_pict.cpp
@@ -199,7 +199,8 @@
SkImageInfo info = SkImageInfo::Make(100, 100, kIndex_8_SkColorType, kPremul_SkAlphaType);
SkBitmap bm2;
- bm2.allocPixels(info, SkColorTable::Make(colors, count));
+ sk_sp<SkColorTable> ct(new SkColorTable(colors, count));
+ bm2.allocPixels(info, nullptr, ct.get());
for (int y = 0; y < info.height(); ++y) {
for (int x = 0; x < info.width(); ++x) {
*bm2.getAddr8(x, y) = find_closest(*bm.getAddr32(x, y), colors, count);
diff --git a/gm/tinybitmap.cpp b/gm/tinybitmap.cpp
index 1640cb2..0f0f137 100644
--- a/gm/tinybitmap.cpp
+++ b/gm/tinybitmap.cpp
@@ -15,11 +15,13 @@
static SkBitmap make_bitmap() {
const SkPMColor c[] = { SkPackARGB32(0x80, 0x80, 0, 0) };
+ SkColorTable* ctable = new SkColorTable(c, SK_ARRAY_COUNT(c));
SkBitmap bm;
bm.allocPixels(SkImageInfo::Make(1, 1, kIndex_8_SkColorType,
kPremul_SkAlphaType),
- SkColorTable::Make(c, SK_ARRAY_COUNT(c)));
+ nullptr, ctable);
+ ctable->unref();
bm.lockPixels();
*bm.getAddr8(0, 0) = 0;
diff --git a/gn/android_framework_defines.gni b/gn/android_framework_defines.gni
index a1db28d..f84c275 100644
--- a/gn/android_framework_defines.gni
+++ b/gn/android_framework_defines.gni
@@ -16,5 +16,4 @@
"SK_SUPPORT_LEGACY_SHADER_ISABITMAP",
"SK_SUPPORT_LEGACY_EMBOSSMASKFILTER",
"SK_SUPPORT_LEGACY_CANVAS_HELPERS",
- "SK_SUPPORT_LEGACY_PIXELREFFACTORY",
]
diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index faff35a..fd25a23 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -238,20 +238,16 @@
bool setInfo(const SkImageInfo&, size_t rowBytes = 0);
- enum AllocFlags {
- kZeroPixels_AllocFlag = 1 << 0,
- };
/**
* Allocate the bitmap's pixels to match the requested image info. If the Factory
* is non-null, call it to allcoate the pixelref. If the ImageInfo requires
- * a colortable, then ColorTable must be non-null.
- *
+ * a colortable, then ColorTable must be non-null, and will be ref'd.
* On failure, the bitmap will be set to empty and return false.
*/
- bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo& info, sk_sp<SkColorTable> ctable,
- uint32_t flags = 0);
- void allocPixels(const SkImageInfo& info, sk_sp<SkColorTable> ctable, uint32_t flags = 0) {
- if (!this->tryAllocPixels(info, std::move(ctable), flags)) {
+ bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo&, SkPixelRefFactory*, SkColorTable*);
+
+ void allocPixels(const SkImageInfo& info, SkPixelRefFactory* factory, SkColorTable* ctable) {
+ if (!this->tryAllocPixels(info, factory, ctable)) {
sk_throw();
}
}
diff --git a/include/core/SkColorTable.h b/include/core/SkColorTable.h
index 40919d3..07dfd67 100644
--- a/include/core/SkColorTable.h
+++ b/include/core/SkColorTable.h
@@ -24,12 +24,10 @@
*/
class SK_API SkColorTable : public SkRefCnt {
public:
- static sk_sp<SkColorTable> Make(const SkPMColor colors[], int count);
-
/** Copy up to 256 colors into a new SkColorTable.
*/
SkColorTable(const SkPMColor colors[], int count);
- ~SkColorTable() override;
+ virtual ~SkColorTable();
/** Returns the number of colors in the table.
*/
@@ -54,7 +52,7 @@
void writeToBuffer(SkWriteBuffer&) const;
// may return null
- static sk_sp<SkColorTable> Create(SkReadBuffer&);
+ static SkColorTable* Create(SkReadBuffer&);
private:
enum AllocatedWithMalloc {
diff --git a/include/core/SkMallocPixelRef.h b/include/core/SkMallocPixelRef.h
index 2e4c4e6..bb07fa2 100644
--- a/include/core/SkMallocPixelRef.h
+++ b/include/core/SkMallocPixelRef.h
@@ -22,10 +22,12 @@
* lifetime of the pixel storage buffer, as this pixelref will not try
* to delete it.
*
+ * The pixelref will ref() the colortable (if not NULL).
+ *
* Returns NULL on failure.
*/
- static sk_sp<SkPixelRef> MakeDirect(const SkImageInfo&, void* addr,
- size_t rowBytes, sk_sp<SkColorTable>);
+ static SkMallocPixelRef* NewDirect(const SkImageInfo&, void* addr,
+ size_t rowBytes, SkColorTable*);
/**
* Return a new SkMallocPixelRef, automatically allocating storage for the
@@ -37,18 +39,22 @@
*
* Returns NULL on failure.
*/
- static sk_sp<SkPixelRef> MakeAllocate(const SkImageInfo&, size_t rowBytes, sk_sp<SkColorTable>);
+ static SkMallocPixelRef* NewAllocate(const SkImageInfo& info,
+ size_t rowBytes, SkColorTable*);
/**
- * Identical to MakeAllocate, except all pixel bytes are zeroed.
+ * Identical to NewAllocate, except all pixel bytes are zeroed.
*/
- static sk_sp<SkPixelRef> MakeZeroed(const SkImageInfo&, size_t rowBytes, sk_sp<SkColorTable>);
+ static SkMallocPixelRef* NewZeroed(const SkImageInfo& info,
+ size_t rowBytes, SkColorTable*);
/**
* Return a new SkMallocPixelRef with the provided pixel storage,
* rowBytes, and optional colortable. On destruction, ReleaseProc
* will be called.
*
+ * This pixelref will ref() the specified colortable (if not NULL).
+ *
* If ReleaseProc is NULL, the pixels will never be released. This
* can be useful if the pixels were stack allocated. However, such an
* SkMallocPixelRef must not live beyond its pixels (e.g. by copying
@@ -57,10 +63,10 @@
* Returns NULL on failure.
*/
typedef void (*ReleaseProc)(void* addr, void* context);
- static sk_sp<SkPixelRef> MakeWithProc(const SkImageInfo& info,
- size_t rowBytes, sk_sp<SkColorTable>,
- void* addr, ReleaseProc proc,
- void* context);
+ static SkMallocPixelRef* NewWithProc(const SkImageInfo& info,
+ size_t rowBytes, SkColorTable*,
+ void* addr, ReleaseProc proc,
+ void* context);
/**
* Return a new SkMallocPixelRef that will use the provided
@@ -68,38 +74,27 @@
* The SkData will be ref()ed and on destruction of the PielRef,
* the SkData will be unref()ed.
*
+ * This pixelref will ref() the specified colortable (if not NULL).
+ *
* Returns NULL on failure.
*/
- static sk_sp<SkPixelRef> MakeWithData(const SkImageInfo& info,
- size_t rowBytes,
- sk_sp<SkColorTable>,
- sk_sp<SkData> data);
-
-#ifdef SK_SUPPORT_LEGACY_PIXELREFFACTORY
- static SkMallocPixelRef* NewDirect(const SkImageInfo& info, void* addr,
- size_t rowBytes, SkColorTable* ctable) {
- return (SkMallocPixelRef*)MakeDirect(info, addr, rowBytes, sk_ref_sp(ctable)).release();
- }
- static SkMallocPixelRef* NewAllocate(const SkImageInfo& info, size_t rb, SkColorTable* ct) {
- return (SkMallocPixelRef*)MakeAllocate(info, rb, sk_ref_sp(ct)).release();
- }
- static SkMallocPixelRef* NewZeroed(const SkImageInfo& info, size_t rowBytes, SkColorTable* ct) {
- return (SkMallocPixelRef*)MakeZeroed(info, rowBytes, sk_ref_sp(ct)).release();
- }
- static SkMallocPixelRef* NewWithProc(const SkImageInfo& info,
- size_t rowBytes, SkColorTable* ctable,
- void* addr, ReleaseProc proc,
- void* ctx) {
- return (SkMallocPixelRef*)MakeWithProc(info, rowBytes, sk_ref_sp(ctable), addr, proc, ctx).release();
- }
static SkMallocPixelRef* NewWithData(const SkImageInfo& info,
size_t rowBytes,
SkColorTable* ctable,
SkData* data);
-#endif
void* getAddr() const { return fStorage; }
+ class PRFactory : public SkPixelRefFactory {
+ public:
+ SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) override;
+ };
+
+ class ZeroedPRFactory : public SkPixelRefFactory {
+ public:
+ SkPixelRef* create(const SkImageInfo&, size_t rowBytes, SkColorTable*) override;
+ };
+
protected:
// The ownPixels version of this constructor is deprecated.
SkMallocPixelRef(const SkImageInfo&, void* addr, size_t rb, SkColorTable*,
@@ -112,18 +107,18 @@
private:
// Uses alloc to implement NewAllocate or NewZeroed.
- static sk_sp<SkPixelRef> MakeUsing(void*(*alloc)(size_t),
- const SkImageInfo&,
- size_t rowBytes,
- sk_sp<SkColorTable>);
+ static SkMallocPixelRef* NewUsing(void*(*alloc)(size_t),
+ const SkImageInfo&,
+ size_t rowBytes,
+ SkColorTable*);
- void* fStorage;
- sk_sp<SkColorTable> fCTable;
- size_t fRB;
- ReleaseProc fReleaseProc;
- void* fReleaseProcContext;
+ void* fStorage;
+ SkColorTable* fCTable;
+ size_t fRB;
+ ReleaseProc fReleaseProc;
+ void* fReleaseProcContext;
- SkMallocPixelRef(const SkImageInfo&, void* addr, size_t rb, sk_sp<SkColorTable>,
+ SkMallocPixelRef(const SkImageInfo&, void* addr, size_t rb, SkColorTable*,
ReleaseProc proc, void* context);
typedef SkPixelRef INHERITED;
diff --git a/public.bzl b/public.bzl
index ca95091..4373738 100644
--- a/public.bzl
+++ b/public.bzl
@@ -657,7 +657,6 @@
# Temporarily Disable analytic AA for Google3
"SK_NO_ANALYTIC_AA",
"SK_SUPPORT_LEGACY_BITMAP_SETPIXELREF",
- "SK_SUPPORT_LEGACY_PIXELREFFACTORY",
]
################################################################################
diff --git a/samplecode/SampleBlur.cpp b/samplecode/SampleBlur.cpp
index c43dc9b..7e6a325 100644
--- a/samplecode/SampleBlur.cpp
+++ b/samplecode/SampleBlur.cpp
@@ -4,7 +4,6 @@
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
-
#include "SampleCode.h"
#include "SkBlurMask.h"
#include "SkBlurMaskFilter.h"
@@ -21,9 +20,12 @@
}
SkBitmap bm;
+ SkColorTable* ctable = new SkColorTable(c, 256);
+
bm.allocPixels(SkImageInfo::Make(256, 256, kIndex_8_SkColorType,
kPremul_SkAlphaType),
- SkColorTable::Make(c, 256));
+ nullptr, ctable);
+ ctable->unref();
bm.lockPixels();
const float cx = bm.width() * 0.5f;
diff --git a/samplecode/SampleDitherBitmap.cpp b/samplecode/SampleDitherBitmap.cpp
index bdd3071..676d4c3 100644
--- a/samplecode/SampleDitherBitmap.cpp
+++ b/samplecode/SampleDitherBitmap.cpp
@@ -56,9 +56,12 @@
for (int i = 0; i < 256; i++) {
c[i] = SkPackARGB32(0xFF, i, 0, 0);
}
+ SkColorTable* ctable = new SkColorTable(c, 256);
+
SkBitmap bm;
bm.allocPixels(SkImageInfo::Make(256, 32, kIndex_8_SkColorType, kPremul_SkAlphaType),
- SkColorTable::Make(c, 256));
+ nullptr, ctable);
+ ctable->unref();
bm.lockPixels();
for (int y = 0; y < bm.height(); y++) {
diff --git a/samplecode/SampleFilter.cpp b/samplecode/SampleFilter.cpp
index d12f804..66de8f3 100644
--- a/samplecode/SampleFilter.cpp
+++ b/samplecode/SampleFilter.cpp
@@ -26,9 +26,11 @@
SkPreMultiplyColor(SK_ColorRED), SkPreMultiplyColor(SK_ColorGREEN),
SkPreMultiplyColor(SK_ColorBLUE), SkPreMultiplyColor(SK_ColorWHITE)
};
+ SkColorTable* ctable = new SkColorTable(colors, 4);
bm->allocPixels(SkImageInfo::Make(2, 2, kIndex_8_SkColorType,
kOpaque_SkAlphaType),
- SkColorTable::Make(colors, 4));
+ nullptr, ctable);
+ ctable->unref();
*bm->getAddr8(0, 0) = 0;
*bm->getAddr8(1, 0) = 1;
diff --git a/samplecode/SampleTinyBitmap.cpp b/samplecode/SampleTinyBitmap.cpp
index 6b01d11..4fb508b 100644
--- a/samplecode/SampleTinyBitmap.cpp
+++ b/samplecode/SampleTinyBitmap.cpp
@@ -19,11 +19,13 @@
for (int i = 0; i < N; i++) {
c[i] = SkPackARGB32(0x80, 0x80, 0, 0);
}
+ SkColorTable* ctable = new SkColorTable(c, N);
SkBitmap bm;
bm.allocPixels(SkImageInfo::Make(1, 1, kIndex_8_SkColorType,
kPremul_SkAlphaType),
- SkColorTable::Make(c, N));
+ nullptr, ctable);
+ ctable->unref();
bm.lockPixels();
for (int y = 0; y < bm.height(); y++) {
diff --git a/src/core/SkBitmap.cpp b/src/core/SkBitmap.cpp
index df3b24e..0a999ce 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -300,7 +300,8 @@
return;
}
- this->setPixelRef(SkMallocPixelRef::MakeDirect(fInfo, p, fRowBytes, sk_ref_sp(ctable)), 0, 0);
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewDirect(fInfo, p, fRowBytes, ctable));
+ this->setPixelRef(std::move(pr), 0, 0);
if (!fPixelRef) {
return;
}
@@ -333,7 +334,9 @@
// setInfo may have computed a valid rowbytes if 0 were passed in
rowBytes = this->rowBytes();
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(correctedInfo, rowBytes, nullptr);
+ SkMallocPixelRef::PRFactory defaultFactory;
+
+ sk_sp<SkPixelRef> pr(defaultFactory.create(correctedInfo, rowBytes, nullptr));
if (!pr) {
return reset_return_false(this);
}
@@ -347,8 +350,8 @@
return true;
}
-bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, sk_sp<SkColorTable> ctable,
- uint32_t allocFlags) {
+bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, SkPixelRefFactory* factory,
+ SkColorTable* ctable) {
if (kIndex_8_SkColorType == requestedInfo.colorType() && nullptr == ctable) {
return reset_return_false(this);
}
@@ -359,14 +362,18 @@
// setInfo may have corrected info (e.g. 565 is always opaque).
const SkImageInfo& correctedInfo = this->info();
- sk_sp<SkPixelRef> pr = (allocFlags & kZeroPixels_AllocFlag) ?
- SkMallocPixelRef::MakeZeroed(correctedInfo, correctedInfo.minRowBytes(), ctable) :
- SkMallocPixelRef::MakeAllocate(correctedInfo, correctedInfo.minRowBytes(), ctable);
+ SkMallocPixelRef::PRFactory defaultFactory;
+ if (nullptr == factory) {
+ factory = &defaultFactory;
+ }
+
+ sk_sp<SkPixelRef> pr(factory->create(correctedInfo, correctedInfo.minRowBytes(), ctable));
if (!pr) {
return reset_return_false(this);
}
this->setPixelRef(std::move(pr), 0, 0);
+ // TODO: lockPixels could/should return bool or void*/nullptr
this->lockPixels();
if (nullptr == this->getPixels()) {
return reset_return_false(this);
@@ -396,8 +403,8 @@
// setInfo may have corrected info (e.g. 565 is always opaque).
const SkImageInfo& correctedInfo = this->info();
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeWithProc(correctedInfo, rb, sk_ref_sp(ct),
- pixels, releaseProc, context);
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewWithProc(correctedInfo, rb, ct, pixels, releaseProc,
+ context));
if (!pr) {
this->reset();
return false;
@@ -466,7 +473,7 @@
return false;
}
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(info, dst->rowBytes(), sk_ref_sp(ctable));
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewAllocate(info, dst->rowBytes(), ctable));
if (!pr) {
return false;
}
@@ -1007,7 +1014,7 @@
sk_sp<SkColorTable> ctable;
if (buffer->readBool()) {
- ctable = SkColorTable::Create(*buffer);
+ ctable.reset(SkColorTable::Create(*buffer));
if (!ctable) {
return false;
}
@@ -1031,9 +1038,9 @@
}
}
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeWithData(info, info.minRowBytes(),
- std::move(ctable), std::move(data));
- if (!pr) {
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewWithData(info, info.minRowBytes(),
+ ctable.get(), data.get()));
+ if (!pr.get()) {
return false;
}
bitmap->setInfo(pr->info());
diff --git a/src/core/SkBitmapDevice.cpp b/src/core/SkBitmapDevice.cpp
index 95ea45c..3be63ba 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -121,8 +121,9 @@
}
} else {
// This bitmap has transparency, so we'll zero the pixels (to transparent).
- // We use the flag as a faster alloc-then-eraseColor(SK_ColorTRANSPARENT).
- if (!bitmap.tryAllocPixels(info, nullptr/*colortable*/, SkBitmap::kZeroPixels_AllocFlag)) {
+ // We use a ZeroedPRFactory as a faster alloc-then-eraseColor(SK_ColorTRANSPARENT).
+ SkMallocPixelRef::ZeroedPRFactory factory;
+ if (!bitmap.tryAllocPixels(info, &factory, nullptr/*color table*/)) {
return nullptr;
}
}
diff --git a/src/core/SkColorTable.cpp b/src/core/SkColorTable.cpp
index 928f515..9710346 100644
--- a/src/core/SkColorTable.cpp
+++ b/src/core/SkColorTable.cpp
@@ -23,7 +23,11 @@
SkColorTable::SkColorTable(const SkPMColor colors[], int count) {
SkASSERT(0 == count || colors);
- SkASSERT(count >= 0 && count <= 256);
+ if (count < 0) {
+ count = 0;
+ } else if (count > 256) {
+ count = 256;
+ }
this->init(colors, count);
}
@@ -52,16 +56,6 @@
return f16BitCache;
}
-sk_sp<SkColorTable> SkColorTable::Make(const SkPMColor colors[], int count) {
- if (count < 0 || count > 256) {
- return nullptr;
- }
- if (count && !colors) {
- return nullptr;
- }
- return sk_make_sp<SkColorTable>(colors, count);
-}
-
///////////////////////////////////////////////////////////////////////////////
#if 0
@@ -91,14 +85,14 @@
buffer.writeColorArray(fColors, fCount);
}
-sk_sp<SkColorTable> SkColorTable::Create(SkReadBuffer& buffer) {
+SkColorTable* SkColorTable::Create(SkReadBuffer& buffer) {
if (buffer.isVersionLT(SkReadBuffer::kRemoveColorTableAlpha_Version)) {
/*fAlphaType = */buffer.readUInt();
}
const int count = buffer.getArrayCount();
if (0 == count) {
- return sk_sp<SkColorTable>(new SkColorTable(nullptr, 0));
+ return new SkColorTable(nullptr, 0);
}
if (count < 0 || count > 256) {
@@ -112,5 +106,5 @@
return nullptr;
}
- return sk_sp<SkColorTable>(new SkColorTable(colors.release(), count, kAllocatedWithMalloc));
+ return new SkColorTable(colors.release(), count, kAllocatedWithMalloc);
}
diff --git a/src/core/SkImageCacherator.cpp b/src/core/SkImageCacherator.cpp
index e3c97d3..76da0e7 100644
--- a/src/core/SkImageCacherator.cpp
+++ b/src/core/SkImageCacherator.cpp
@@ -157,7 +157,7 @@
allocator)) {
return false;
}
- if (!bitmap->tryAllocPixels(decodeInfo, sk_ref_sp(full.getColorTable()))) {
+ if (!bitmap->tryAllocPixels(decodeInfo, nullptr, full.getColorTable())) {
return false;
}
return full.readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(),
diff --git a/src/core/SkMallocPixelRef.cpp b/src/core/SkMallocPixelRef.cpp
index 7197aeb..0d758fc 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -37,23 +37,22 @@
return true;
}
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeDirect(const SkImageInfo& info,
- void* addr,
- size_t rowBytes,
- sk_sp<SkColorTable> ctable) {
- if (!is_valid(info, ctable.get())) {
+SkMallocPixelRef* SkMallocPixelRef::NewDirect(const SkImageInfo& info,
+ void* addr,
+ size_t rowBytes,
+ SkColorTable* ctable) {
+ if (!is_valid(info, ctable)) {
return nullptr;
}
- return sk_sp<SkPixelRef>(new SkMallocPixelRef(info, addr, rowBytes, std::move(ctable),
- nullptr, nullptr));
+ return new SkMallocPixelRef(info, addr, rowBytes, ctable, nullptr, nullptr);
}
- sk_sp<SkPixelRef> SkMallocPixelRef::MakeUsing(void*(*alloc)(size_t),
- const SkImageInfo& info,
- size_t requestedRowBytes,
- sk_sp<SkColorTable> ctable) {
- if (!is_valid(info, ctable.get())) {
+ SkMallocPixelRef* SkMallocPixelRef::NewUsing(void*(*alloc)(size_t),
+ const SkImageInfo& info,
+ size_t requestedRowBytes,
+ SkColorTable* ctable) {
+ if (!is_valid(info, ctable)) {
return nullptr;
}
@@ -85,59 +84,62 @@
return nullptr;
}
- return sk_sp<SkPixelRef>(new SkMallocPixelRef(info, addr, rowBytes, std::move(ctable),
- sk_free_releaseproc, nullptr));
+ return new SkMallocPixelRef(info, addr, rowBytes, ctable, sk_free_releaseproc, nullptr);
}
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeAllocate(const SkImageInfo& info,
+SkMallocPixelRef* SkMallocPixelRef::NewAllocate(const SkImageInfo& info,
size_t rowBytes,
- sk_sp<SkColorTable> ctable) {
+ SkColorTable* ctable) {
auto sk_malloc_nothrow = [](size_t size) { return sk_malloc_flags(size, 0); };
- return MakeUsing(sk_malloc_nothrow, info, rowBytes, std::move(ctable));
+ return NewUsing(sk_malloc_nothrow, info, rowBytes, ctable);
}
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeZeroed(const SkImageInfo& info,
- size_t rowBytes,
- sk_sp<SkColorTable> ctable) {
- return MakeUsing(sk_calloc, info, rowBytes, std::move(ctable));
+SkMallocPixelRef* SkMallocPixelRef::NewZeroed(const SkImageInfo& info,
+ size_t rowBytes,
+ SkColorTable* ctable) {
+ return NewUsing(sk_calloc, info, rowBytes, ctable);
+}
+
+SkMallocPixelRef* SkMallocPixelRef::NewWithProc(const SkImageInfo& info,
+ size_t rowBytes,
+ SkColorTable* ctable,
+ void* addr,
+ SkMallocPixelRef::ReleaseProc proc,
+ void* context) {
+ if (!is_valid(info, ctable)) {
+ if (proc) {
+ proc(addr, context);
+ }
+ return nullptr;
+ }
+ return new SkMallocPixelRef(info, addr, rowBytes, ctable, proc, context);
}
static void sk_data_releaseproc(void*, void* dataPtr) {
(static_cast<SkData*>(dataPtr))->unref();
}
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeWithProc(const SkImageInfo& info,
- size_t rowBytes,
- sk_sp<SkColorTable> ctable,
- void* addr,
- SkMallocPixelRef::ReleaseProc proc,
- void* context) {
- if (!is_valid(info, ctable.get())) {
- if (proc) {
- proc(addr, context);
- }
- return nullptr;
- }
- return sk_sp<SkPixelRef>(new SkMallocPixelRef(info, addr, rowBytes, std::move(ctable),
- proc, context));
-}
-
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeWithData(const SkImageInfo& info,
+SkMallocPixelRef* SkMallocPixelRef::NewWithData(const SkImageInfo& info,
size_t rowBytes,
- sk_sp<SkColorTable> ctable,
- sk_sp<SkData> data) {
+ SkColorTable* ctable,
+ SkData* data) {
SkASSERT(data != nullptr);
- if (!is_valid(info, ctable.get())) {
+ if (!is_valid(info, ctable)) {
return nullptr;
}
if ((rowBytes < info.minRowBytes())
|| (data->size() < info.getSafeSize(rowBytes))) {
return nullptr;
}
- SkPixelRef* pr = new SkMallocPixelRef(info, const_cast<void*>(data->data()), rowBytes,
- std::move(ctable), sk_data_releaseproc, data.release());
- pr->setImmutable(); // since we were created with (immutable) data
- return sk_sp<SkPixelRef>(pr);
+ data->ref();
+ SkMallocPixelRef* pr =
+ new SkMallocPixelRef(info, const_cast<void*>(data->data()), rowBytes, ctable,
+ sk_data_releaseproc, static_cast<void*>(data));
+ SkASSERT(pr != nullptr);
+ // We rely on the immutability of the pixels to make the
+ // const_cast okay.
+ pr->setImmutable();
+ return pr;
}
///////////////////////////////////////////////////////////////////////////////
@@ -146,47 +148,50 @@
size_t rowBytes, SkColorTable* ctable,
bool ownsPixels)
: INHERITED(info)
- , fCTable(sk_ref_sp(ctable))
, fReleaseProc(ownsPixels ? sk_free_releaseproc : nullptr)
, fReleaseProcContext(nullptr) {
// This constructor is now DEPRICATED.
- SkASSERT(is_valid(info, fCTable.get()));
+ SkASSERT(is_valid(info, ctable));
SkASSERT(rowBytes >= info.minRowBytes());
if (kIndex_8_SkColorType != info.colorType()) {
- fCTable = nullptr;
+ ctable = nullptr;
}
fStorage = storage;
+ fCTable = ctable;
fRB = rowBytes;
+ SkSafeRef(ctable);
- this->setPreLocked(fStorage, rowBytes, fCTable.get());
+ this->setPreLocked(fStorage, rowBytes, fCTable);
}
SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage,
- size_t rowBytes, sk_sp<SkColorTable> ctable,
+ size_t rowBytes, SkColorTable* ctable,
SkMallocPixelRef::ReleaseProc proc,
void* context)
: INHERITED(info)
, fReleaseProc(proc)
, fReleaseProcContext(context)
{
- SkASSERT(is_valid(info, ctable.get()));
+ SkASSERT(is_valid(info, ctable));
SkASSERT(rowBytes >= info.minRowBytes());
if (kIndex_8_SkColorType != info.colorType()) {
- ctable.reset(nullptr);
+ ctable = nullptr;
}
fStorage = storage;
- fCTable = std::move(ctable);
+ fCTable = ctable;
fRB = rowBytes;
+ SkSafeRef(ctable);
- this->setPreLocked(fStorage, rowBytes, fCTable.get());
+ this->setPreLocked(fStorage, rowBytes, fCTable);
}
SkMallocPixelRef::~SkMallocPixelRef() {
+ SkSafeUnref(fCTable);
if (fReleaseProc != nullptr) {
fReleaseProc(fStorage, fReleaseProcContext);
}
@@ -195,7 +200,7 @@
bool SkMallocPixelRef::onNewLockPixels(LockRec* rec) {
rec->fPixels = fStorage;
rec->fRowBytes = fRB;
- rec->fColorTable = fCTable.get();
+ rec->fColorTable = fCTable;
return true;
}
@@ -207,11 +212,14 @@
return this->info().getSafeSize(fRB);
}
-#ifdef SK_SUPPORT_LEGACY_PIXELREFFACTORY
-SkMallocPixelRef* SkMallocPixelRef::NewWithData(const SkImageInfo& info,
- size_t rowBytes,
- SkColorTable* ctable,
- SkData* data) {
- return (SkMallocPixelRef*)MakeWithData(info, rowBytes, sk_ref_sp(ctable), sk_ref_sp(data)).release();
+///////////////////////////////////////////////////////////////////////////////
+
+SkPixelRef* SkMallocPixelRef::PRFactory::create(const SkImageInfo& info, size_t rowBytes,
+ SkColorTable* ctable) {
+ return SkMallocPixelRef::NewAllocate(info, rowBytes, ctable);
}
-#endif
+
+SkPixelRef* SkMallocPixelRef::ZeroedPRFactory::create(const SkImageInfo& info, size_t rowBytes,
+ SkColorTable* ctable) {
+ return SkMallocPixelRef::NewZeroed(info, rowBytes, ctable);
+}
diff --git a/src/core/SkSpecialSurface.cpp b/src/core/SkSpecialSurface.cpp
index 40afb57..1f396a7 100644
--- a/src/core/SkSpecialSurface.cpp
+++ b/src/core/SkSpecialSurface.cpp
@@ -98,8 +98,8 @@
sk_sp<SkSpecialSurface> SkSpecialSurface::MakeRaster(const SkImageInfo& info,
const SkSurfaceProps* props) {
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeZeroed(info, 0, nullptr);
- if (!pr) {
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewZeroed(info, 0, nullptr));
+ if (nullptr == pr.get()) {
return nullptr;
}
diff --git a/src/effects/gradients/SkGradientShader.cpp b/src/effects/gradients/SkGradientShader.cpp
index be60dee..0840d7c 100644
--- a/src/effects/gradients/SkGradientShader.cpp
+++ b/src/effects/gradients/SkGradientShader.cpp
@@ -10,7 +10,6 @@
#include "SkGradientShaderPriv.h"
#include "SkHalf.h"
#include "SkLinearGradient.h"
-#include "SkMallocPixelRef.h"
#include "SkRadialGradient.h"
#include "SkTwoPointConicalGradient.h"
#include "SkSweepGradient.h"
@@ -411,9 +410,12 @@
{
// Only initialize the cache in getCache32.
fCache32 = nullptr;
+ fCache32PixelRef = nullptr;
}
-SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() {}
+SkGradientShaderBase::GradientShaderCache::~GradientShaderCache() {
+ SkSafeUnref(fCache32PixelRef);
+}
/*
* r,g,b used to be SkFixed, but on gcc (4.2.1 mac and 4.6.3 goobuntu) in
@@ -582,8 +584,8 @@
const SkImageInfo info = SkImageInfo::MakeN32Premul(kCache32Count, kNumberOfDitherRows);
SkASSERT(nullptr == cache->fCache32PixelRef);
- cache->fCache32PixelRef = SkMallocPixelRef::MakeAllocate(info, 0, nullptr);
- cache->fCache32 = (SkPMColor*)cache->fCache32PixelRef->pixels();
+ cache->fCache32PixelRef = SkMallocPixelRef::NewAllocate(info, 0, nullptr);
+ cache->fCache32 = (SkPMColor*)cache->fCache32PixelRef->getAddr();
if (cache->fShader.fColorCount == 2) {
Build32bitCache(cache->fCache32, cache->fShader.fOrigColors[0],
cache->fShader.fOrigColors[1], kCache32Count, cache->fCacheAlpha,
diff --git a/src/effects/gradients/SkGradientShaderPriv.h b/src/effects/gradients/SkGradientShaderPriv.h
index ec75bdc..f64b439 100644
--- a/src/effects/gradients/SkGradientShaderPriv.h
+++ b/src/effects/gradients/SkGradientShaderPriv.h
@@ -16,6 +16,7 @@
#include "SkClampRange.h"
#include "SkColorPriv.h"
#include "SkColorSpace.h"
+#include "SkMallocPixelRef.h"
#include "SkOnce.h"
#include "SkReadBuffer.h"
#include "SkShader.h"
@@ -128,7 +129,7 @@
const SkPMColor* getCache32();
- SkPixelRef* getCache32PixelRef() const { return fCache32PixelRef.get(); }
+ SkMallocPixelRef* getCache32PixelRef() const { return fCache32PixelRef; }
unsigned getAlpha() const { return fCacheAlpha; }
bool getDither() const { return fCacheDither; }
@@ -137,7 +138,7 @@
// Working pointer. If it's nullptr, we need to recompute the cache values.
SkPMColor* fCache32;
- sk_sp<SkPixelRef> fCache32PixelRef;
+ SkMallocPixelRef* fCache32PixelRef;
const unsigned fCacheAlpha; // The alpha value we used when we computed the cache.
// Larger than 8bits so we can store uninitialized
// value.
diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp
index 92f5301..4fae0f0 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -209,7 +209,7 @@
return nullptr;
}
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeZeroed(info, rowBytes, nullptr);
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewZeroed(info, rowBytes, nullptr));
if (!pr) {
return nullptr;
}
diff --git a/tests/BitmapCopyTest.cpp b/tests/BitmapCopyTest.cpp
index 4578bbb..70958ca 100644
--- a/tests/BitmapCopyTest.cpp
+++ b/tests/BitmapCopyTest.cpp
@@ -62,11 +62,11 @@
}
}
-static sk_sp<SkColorTable> init_ctable() {
+static SkColorTable* init_ctable() {
static const SkColor colors[] = {
SK_ColorBLACK, SK_ColorRED, SK_ColorGREEN, SK_ColorBLUE, SK_ColorWHITE
};
- return SkColorTable::Make(colors, SK_ARRAY_COUNT(colors));
+ return new SkColorTable(colors, SK_ARRAY_COUNT(colors));
}
struct Pair {
@@ -194,13 +194,16 @@
static void setup_src_bitmaps(SkBitmap* srcOpaque, SkBitmap* srcPremul,
SkColorType ct) {
- sk_sp<SkColorTable> ctable;
+ SkColorTable* ctable = nullptr;
if (kIndex_8_SkColorType == ct) {
ctable = init_ctable();
}
- srcOpaque->allocPixels(SkImageInfo::Make(W, H, ct, kOpaque_SkAlphaType), ctable);
- srcPremul->allocPixels(SkImageInfo::Make(W, H, ct, kPremul_SkAlphaType), ctable);
+ srcOpaque->allocPixels(SkImageInfo::Make(W, H, ct, kOpaque_SkAlphaType),
+ nullptr, ctable);
+ srcPremul->allocPixels(SkImageInfo::Make(W, H, ct, kPremul_SkAlphaType),
+ nullptr, ctable);
+ SkSafeUnref(ctable);
init_src(*srcOpaque);
init_src(*srcPremul);
}
@@ -375,7 +378,7 @@
// Create bitmap to act as source for copies and subsets.
SkBitmap src, subset;
- sk_sp<SkColorTable> ct;
+ SkColorTable* ct = nullptr;
if (kIndex_8_SkColorType == src.colorType()) {
ct = init_ctable();
}
@@ -391,6 +394,7 @@
kPremul_SkAlphaType))) {
// failure is fine, as we will notice later on
}
+ SkSafeUnref(ct);
// Either copy src or extract into 'subset', which is used
// for subsequent calls to copyPixelsTo/From.
diff --git a/tests/BitmapTest.cpp b/tests/BitmapTest.cpp
index 76621e6..9342d26 100644
--- a/tests/BitmapTest.cpp
+++ b/tests/BitmapTest.cpp
@@ -44,7 +44,7 @@
SkBitmap bm;
REPORTER_ASSERT(reporter, !bm.tryAllocPixels(info));
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(info, info.minRowBytes(), nullptr);
+ SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, info.minRowBytes(), nullptr);
REPORTER_ASSERT(reporter, !pr);
}
diff --git a/tests/CodecPriv.h b/tests/CodecPriv.h
index cfa794e..50c205c 100644
--- a/tests/CodecPriv.h
+++ b/tests/CodecPriv.h
@@ -29,7 +29,7 @@
colorCountPtr = &maxColors;
}
- bm->allocPixels(codec->getInfo(), colorTable);
+ bm->allocPixels(codec->getInfo(), nullptr, colorTable.get());
const SkCodec::Result result = codec->getPixels(codec->getInfo(), bm->getPixels(),
bm->rowBytes(), nullptr, colorPtr, colorCountPtr);
return result == SkCodec::kSuccess || result == SkCodec::kIncompleteInput;
diff --git a/tests/CodecTest.cpp b/tests/CodecTest.cpp
index f3a393d..dd11ff8 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -700,7 +700,8 @@
} else if (SkCodec::kUnimplemented == result) {
// New method should be supported:
SkBitmap bm;
- bm.allocPixels(info, SkColorTable::Make(colorStorage, 256));
+ sk_sp<SkColorTable> colorTable(new SkColorTable(colorStorage, 256));
+ bm.allocPixels(info, nullptr, colorTable.get());
result = decoder->startIncrementalDecode(info, bm.getPixels(), bm.rowBytes(), nullptr,
colorStorage, &colorCount);
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
@@ -1107,8 +1108,8 @@
static void check_round_trip(skiatest::Reporter* r, SkCodec* origCodec, const SkImageInfo& info) {
SkBitmap bm1;
SkPMColor colors[256];
- sk_sp<SkColorTable> colorTable1 = SkColorTable::Make(colors, 256);
- bm1.allocPixels(info, colorTable1);
+ sk_sp<SkColorTable> colorTable1(new SkColorTable(colors, 256));
+ bm1.allocPixels(info, nullptr, colorTable1.get());
int numColors;
SkCodec::Result result = origCodec->getPixels(info, bm1.getPixels(), bm1.rowBytes(), nullptr,
const_cast<SkPMColor*>(colorTable1->readColors()),
@@ -1125,8 +1126,8 @@
REPORTER_ASSERT(r, alpha_type_match(info.alphaType(), codec->getInfo().alphaType()));
SkBitmap bm2;
- sk_sp<SkColorTable> colorTable2 = SkColorTable::Make(colors, 256);
- bm2.allocPixels(info, colorTable2);
+ sk_sp<SkColorTable> colorTable2(new SkColorTable(colors, 256));
+ bm2.allocPixels(info, nullptr, colorTable2.get());
result = codec->getPixels(info, bm2.getPixels(), bm2.rowBytes(), nullptr,
const_cast<SkPMColor*>(colorTable2->readColors()), &numColors);
REPORTER_ASSERT(r, SkCodec::kSuccess == result);
diff --git a/tests/GifTest.cpp b/tests/GifTest.cpp
index 0168d89..dae2bc9 100644
--- a/tests/GifTest.cpp
+++ b/tests/GifTest.cpp
@@ -256,7 +256,7 @@
options.fColorCount = colorCountPtr;
SkBitmap bm;
- bm.allocPixels(codec->getInfo(), colorTable);
+ bm.allocPixels(codec->getInfo(), nullptr, colorTable.get());
const SkCodec::Result result = codec->getAndroidPixels(codec->getInfo(), bm.getPixels(),
bm.rowBytes(), &options);
REPORTER_ASSERT(r, result == SkCodec::kSuccess);
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 492985c..ba49000 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -568,8 +568,10 @@
DEF_TEST(ImageFromIndex8Bitmap, r) {
SkPMColor pmColors[1] = {SkPreMultiplyColor(SK_ColorWHITE)};
SkBitmap bm;
+ sk_sp<SkColorTable> ctable( new SkColorTable(pmColors, SK_ARRAY_COUNT(pmColors)));
SkImageInfo info = SkImageInfo::Make(1, 1, kIndex_8_SkColorType, kPremul_SkAlphaType);
- bm.allocPixels(info, SkColorTable::Make(pmColors, SK_ARRAY_COUNT(pmColors)));
+ bm.allocPixels(info, nullptr, ctable.get());
+ SkAutoLockPixels autoLockPixels(bm);
*bm.getAddr8(0, 0) = 0;
sk_sp<SkImage> img(SkImage::MakeFromBitmap(bm));
REPORTER_ASSERT(r, img != nullptr);
diff --git a/tests/MallocPixelRefTest.cpp b/tests/MallocPixelRefTest.cpp
index 096e3e6..b89d121 100644
--- a/tests/MallocPixelRefTest.cpp
+++ b/tests/MallocPixelRefTest.cpp
@@ -25,8 +25,8 @@
REPORTER_ASSERT(reporter, true);
SkImageInfo info = SkImageInfo::MakeN32Premul(10, 13);
{
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeAllocate(info, info.minRowBytes() - 1, nullptr));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewAllocate(info, info.minRowBytes() - 1, nullptr));
// rowbytes too small.
REPORTER_ASSERT(reporter, nullptr == pr.get());
}
@@ -34,8 +34,8 @@
size_t rowBytes = info.minRowBytes() - 1;
size_t size = info.getSafeSize(rowBytes);
sk_sp<SkData> data(SkData::MakeUninitialized(size));
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeWithData(info, rowBytes, nullptr, data));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data.get()));
// rowbytes too small.
REPORTER_ASSERT(reporter, nullptr == pr.get());
}
@@ -43,8 +43,8 @@
size_t rowBytes = info.minRowBytes() + 2;
size_t size = info.getSafeSize(rowBytes) - 1;
sk_sp<SkData> data(SkData::MakeUninitialized(size));
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeWithData(info, rowBytes, nullptr, data));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data.get()));
// data too small.
REPORTER_ASSERT(reporter, nullptr == pr.get());
}
@@ -52,32 +52,32 @@
size_t size = info.getSafeSize(rowBytes) + 9;
{
SkAutoMalloc memory(size);
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeDirect(info, memory.get(), rowBytes, nullptr));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewDirect(info, memory.get(), rowBytes, nullptr));
REPORTER_ASSERT(reporter, pr.get() != nullptr);
REPORTER_ASSERT(reporter, memory.get() == pr->pixels());
}
{
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeAllocate(info, rowBytes, nullptr));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewAllocate(info, rowBytes, nullptr));
REPORTER_ASSERT(reporter, pr.get() != nullptr);
REPORTER_ASSERT(reporter, pr->pixels());
}
{
void* addr = static_cast<void*>(new uint8_t[size]);
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeWithProc(info, rowBytes, nullptr, addr,
- delete_uint8_proc, nullptr));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithProc(info, rowBytes, nullptr, addr,
+ delete_uint8_proc, nullptr));
REPORTER_ASSERT(reporter, pr.get() != nullptr);
REPORTER_ASSERT(reporter, addr == pr->pixels());
}
{
int x = 0;
SkAutoMalloc memory(size);
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeWithProc(info, rowBytes, nullptr,
- memory.get(), set_to_one_proc,
- static_cast<void*>(&x)));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithProc(info, rowBytes, nullptr,
+ memory.get(), set_to_one_proc,
+ static_cast<void*>(&x)));
REPORTER_ASSERT(reporter, pr.get() != nullptr);
REPORTER_ASSERT(reporter, memory.get() == pr->pixels());
REPORTER_ASSERT(reporter, 0 == x);
@@ -88,10 +88,10 @@
{
int x = 0;
SkAutoMalloc memory(size);
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeWithProc(SkImageInfo::MakeN32Premul(-1, -1), rowBytes, nullptr,
- memory.get(), set_to_one_proc,
- static_cast<void*>(&x)));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithProc(SkImageInfo::MakeN32Premul(-1, -1), rowBytes, nullptr,
+ memory.get(), set_to_one_proc,
+ static_cast<void*>(&x)));
REPORTER_ASSERT(reporter, pr.get() == nullptr);
// make sure that set_to_one_proc was called.
REPORTER_ASSERT(reporter, 1 == x);
@@ -99,16 +99,17 @@
{
void* addr = static_cast<void*>(new uint8_t[size]);
REPORTER_ASSERT(reporter, addr != nullptr);
- sk_sp<SkPixelRef> pr(
- SkMallocPixelRef::MakeWithProc(info, rowBytes, nullptr, addr,
- delete_uint8_proc, nullptr));
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithProc(info, rowBytes, nullptr, addr,
+ delete_uint8_proc, nullptr));
REPORTER_ASSERT(reporter, addr == pr->pixels());
}
{
sk_sp<SkData> data(SkData::MakeUninitialized(size));
SkData* dataPtr = data.get();
REPORTER_ASSERT(reporter, dataPtr->unique());
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeWithData(info, rowBytes, nullptr, data);
+ sk_sp<SkMallocPixelRef> pr(
+ SkMallocPixelRef::NewWithData(info, rowBytes, nullptr, data.get()));
REPORTER_ASSERT(reporter, !(dataPtr->unique()));
data.reset(nullptr);
REPORTER_ASSERT(reporter, dataPtr->unique());
diff --git a/tests/PixelRefTest.cpp b/tests/PixelRefTest.cpp
index 683e249..487e519 100644
--- a/tests/PixelRefTest.cpp
+++ b/tests/PixelRefTest.cpp
@@ -69,7 +69,7 @@
DEF_TEST(PixelRef_GenIDChange, r) {
SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
- sk_sp<SkPixelRef> pixelRef = SkMallocPixelRef::MakeAllocate(info, 0, nullptr);
+ sk_sp<SkPixelRef> pixelRef(SkMallocPixelRef::NewAllocate(info, 0, nullptr));
// Register a listener.
int count = 0;
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index cace6b1..c38e4d6 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -263,7 +263,7 @@
if (!bm->setInfo(info, rowBytes)) {
return false;
}
- sk_sp<SkPixelRef> pr = SkMallocPixelRef::MakeAllocate(info, rowBytes, nullptr);
+ sk_sp<SkPixelRef> pr(SkMallocPixelRef::NewAllocate(info, rowBytes, nullptr));
bm->setPixelRef(std::move(pr), 0, 0);
return true;
}
diff --git a/tools/Resources.cpp b/tools/Resources.cpp
index 224bf3f..d7f9018 100644
--- a/tools/Resources.cpp
+++ b/tools/Resources.cpp
@@ -34,10 +34,9 @@
return false;
}
SkPMColor ctStorage[256];
- auto ctable = SkColorTable::Make(ctStorage, 256);
+ sk_sp<SkColorTable> ctable(new SkColorTable(ctStorage, 256));
int count = ctable->count();
- // ICK -- gotta clean up this pattern of writing to the ctable
- return dst->tryAllocPixels(gen->getInfo(), ctable) &&
+ return dst->tryAllocPixels(gen->getInfo(), nullptr, ctable.get()) &&
gen->getPixels(gen->getInfo().makeColorSpace(nullptr), dst->getPixels(), dst->rowBytes(),
const_cast<SkPMColor*>(ctable->readColors()), &count);
}