Revert "clean up (partially) colortable api"

This reverts commit 2e491a6a113c5e16a3b7bede5fa6f588deeb928d.

Reason for revert: Windows unit tests failing?

Original change's description:
> clean up (partially) colortable api
> 
> Needs this to land: https://codereview.chromium.org/2789853002/
> 
> Bug: skia:
> Change-Id: I38d916a546b7fa64d000d973e695ddda24a589e7
> Reviewed-on: https://skia-review.googlesource.com/10600
> Commit-Queue: Mike Reed <reed@google.com>
> Reviewed-by: Matt Sarett <msarett@google.com>
> 

TBR=msarett@google.com,scroggo@google.com,reed@google.com,reviews@skia.org
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Change-Id: I626e7edfcea82576a440dcaa851a04cedee6233f
Reviewed-on: https://skia-review.googlesource.com/10966
Reviewed-by: Mike Klein <mtklein@chromium.org>
Commit-Queue: Mike Klein <mtklein@chromium.org>

37 files changed, 248 insertions, 217 deletions

diff --git a/bench/BitmapBench.cpp b/bench/BitmapBench.cpp
index fdf17e90b1..8e881a665b 100644
--- a/bench/BitmapBench.cpp
+++ b/bench/BitmapBench.cpp
@@ -44,8 +44,10 @@ static void convertToIndex666(const SkBitmap& src, SkBitmap* dst, SkAlphaType aT
             }
         }
     }
+    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 df58a14d10..33e91780d9 100644
--- a/bench/RepeatTileBench.cpp
+++ b/bench/RepeatTileBench.cpp
@@ -62,9 +62,11 @@ static void convert_to_index666(const SkBitmap& src, SkBitmap* dst) {
             }
         }
     }
+    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 f505bb7476..eb9ba41d96 100644
--- a/dm/DMSrcSink.cpp
+++ b/dm/DMSrcSink.cpp
@@ -1445,9 +1445,11 @@ Error RasterSink::draw(const Src& src, SkBitmap* dst, SkWStream*, SkString*) con
     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 6764a62e44..d156680718 100644
--- a/fuzz/fuzz.cpp
+++ b/fuzz/fuzz.cpp
@@ -224,10 +224,11 @@ static void fuzz_img(sk_sp<SkData> bytes, uint8_t scale, uint8_t mode) {
     }
 
     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 60aec88ddf..ea7b73483b 100644
--- a/gm/all_bitmap_configs.cpp
+++ b/gm/all_bitmap_configs.cpp
@@ -124,9 +124,10 @@ static SkBitmap indexed_bitmap() {
         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 22e5d0943f..2cded98236 100644
--- a/gm/bitmapfilters.cpp
+++ b/gm/bitmapfilters.cpp
@@ -17,9 +17,12 @@ static void make_bm(SkBitmap* bm) {
     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 894b0ef8d5..f62d48ae2c 100644
--- a/gm/encode-srgb.cpp
+++ b/gm/encode-srgb.cpp
@@ -67,9 +67,10 @@ static void make_index8(SkBitmap* bitmap, SkAlphaType alphaType, sk_sp<SkColorSp
         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 f23b89e728..792173ce66 100644
--- a/gm/image_pict.cpp
+++ b/gm/image_pict.cpp
@@ -199,7 +199,8 @@ static std::unique_ptr<SkImageGenerator> make_ctable_generator(GrContext*, sk_sp
     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 1640cb23d1..0f0f1374ea 100644
--- a/gm/tinybitmap.cpp
+++ b/gm/tinybitmap.cpp
@@ -15,11 +15,13 @@ namespace skiagm {
 
 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 a1db28da96..f84c275294 100644
--- a/gn/android_framework_defines.gni
+++ b/gn/android_framework_defines.gni
@@ -16,5 +16,4 @@ android_framework_defines = [
   "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 faff35aebe..fd25a23cdd 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -238,20 +238,16 @@ public:
 
     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 40919d3bac..07dfd675b2 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 @@ public:
     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 2e4c4e69eb..bb07fa2dab 100644
--- a/include/core/SkMallocPixelRef.h
+++ b/include/core/SkMallocPixelRef.h
@@ -22,10 +22,12 @@ public:
      *  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 @@ public:
      *
      *  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 @@ public:
      *  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 @@ public:
      *  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 @@ protected:
 
 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>);
-
-    void*               fStorage;
-    sk_sp<SkColorTable> fCTable;
-    size_t              fRB;
-    ReleaseProc         fReleaseProc;
-    void*               fReleaseProcContext;
-
-    SkMallocPixelRef(const SkImageInfo&, void* addr, size_t rb, sk_sp<SkColorTable>,
+    static SkMallocPixelRef* NewUsing(void*(*alloc)(size_t),
+                                      const SkImageInfo&,
+                                      size_t rowBytes,
+                                      SkColorTable*);
+
+    void*           fStorage;
+    SkColorTable*   fCTable;
+    size_t          fRB;
+    ReleaseProc     fReleaseProc;
+    void*           fReleaseProcContext;
+
+    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 ca9509119d..4373738738 100644
--- a/public.bzl
+++ b/public.bzl
@@ -657,7 +657,6 @@ DEFINES_ALL = [
     # 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 c43dc9bd43..7e6a32562d 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 @@ static SkBitmap make_bitmap() {
     }
 
     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 bdd3071c0b..676d4c3530 100644
--- a/samplecode/SampleDitherBitmap.cpp
+++ b/samplecode/SampleDitherBitmap.cpp
@@ -56,9 +56,12 @@ static SkBitmap make_bitmap() {
     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 d12f804d19..66de8f317f 100644
--- a/samplecode/SampleFilter.cpp
+++ b/samplecode/SampleFilter.cpp
@@ -26,9 +26,11 @@ static void make_bm(SkBitmap* bm) {
         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 6b01d11d5a..4fb508b898 100644
--- a/samplecode/SampleTinyBitmap.cpp
+++ b/samplecode/SampleTinyBitmap.cpp
@@ -19,11 +19,13 @@ static SkBitmap make_bitmap() {
     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 df3b24ed11..0a999cee42 100644
--- a/src/core/SkBitmap.cpp
+++ b/src/core/SkBitmap.cpp
@@ -300,7 +300,8 @@ void SkBitmap::setPixels(void* p, SkColorTable* ctable) {
         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 @@ bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, size_t rowBytes)
     // 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 @@ bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, size_t rowBytes)
     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 @@ bool SkBitmap::tryAllocPixels(const SkImageInfo& requestedInfo, sk_sp<SkColorTab
     // 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 @@ bool SkBitmap::installPixels(const SkImageInfo& requestedInfo, void* pixels, siz
     // 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 @@ bool SkBitmap::HeapAllocator::allocPixelRef(SkBitmap* dst,
         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 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
 
     sk_sp<SkColorTable> ctable;
     if (buffer->readBool()) {
-        ctable = SkColorTable::Create(*buffer);
+        ctable.reset(SkColorTable::Create(*buffer));
         if (!ctable) {
             return false;
         }
@@ -1031,9 +1038,9 @@ bool SkBitmap::ReadRawPixels(SkReadBuffer* buffer, SkBitmap* bitmap) {
         }
     }
 
-    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 95ea45c29d..3be63ba66b 100644
--- a/src/core/SkBitmapDevice.cpp
+++ b/src/core/SkBitmapDevice.cpp
@@ -121,8 +121,9 @@ SkBitmapDevice* SkBitmapDevice::Create(const SkImageInfo& origInfo,
         }
     } 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 928f5158d4..97103463db 100644
--- a/src/core/SkColorTable.cpp
+++ b/src/core/SkColorTable.cpp
@@ -23,7 +23,11 @@ void SkColorTable::init(const SkPMColor colors[], int count) {
 
 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 @@ const uint16_t* SkColorTable::read16BitCache() const {
     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 @@ void SkColorTable::writeToBuffer(SkWriteBuffer& buffer) const {
     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 @@ sk_sp<SkColorTable> SkColorTable::Create(SkReadBuffer& buffer) {
         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 e3c97d390b..76da0e762e 100644
--- a/src/core/SkImageCacherator.cpp
+++ b/src/core/SkImageCacherator.cpp
@@ -157,7 +157,7 @@ bool SkImageCacherator::generateBitmap(SkBitmap* bitmap, const SkImageInfo& deco
                                           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 7197aebae5..0d758fcb3d 100644
--- a/src/core/SkMallocPixelRef.cpp
+++ b/src/core/SkMallocPixelRef.cpp
@@ -37,23 +37,22 @@ static bool is_valid(const SkImageInfo& info, SkColorTable* ctable) {
     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 @@ sk_sp<SkPixelRef> SkMallocPixelRef::MakeDirect(const SkImageInfo& info,
         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);
 }
 
-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())) {
+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 sk_sp<SkPixelRef>(new SkMallocPixelRef(info, addr, rowBytes, std::move(ctable),
-                                                  proc, context));
+    return new SkMallocPixelRef(info, addr, rowBytes, ctable, proc, context);
 }
 
-sk_sp<SkPixelRef> SkMallocPixelRef::MakeWithData(const SkImageInfo& info,
+static void sk_data_releaseproc(void*, void* dataPtr) {
+    (static_cast<SkData*>(dataPtr))->unref();
+}
+
+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 @@ SkMallocPixelRef::SkMallocPixelRef(const SkImageInfo& info, void* storage,
                                    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 @@ SkMallocPixelRef::~SkMallocPixelRef() {
 bool SkMallocPixelRef::onNewLockPixels(LockRec* rec) {
     rec->fPixels = fStorage;
     rec->fRowBytes = fRB;
-    rec->fColorTable = fCTable.get();
+    rec->fColorTable = fCTable;
     return true;
 }
 
@@ -207,11 +212,14 @@ size_t SkMallocPixelRef::getAllocatedSizeInBytes() const {
     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);
+}
+
+SkPixelRef* SkMallocPixelRef::ZeroedPRFactory::create(const SkImageInfo& info, size_t rowBytes,
+                                                      SkColorTable* ctable) {
+    return SkMallocPixelRef::NewZeroed(info, rowBytes, ctable);
 }
-#endif
diff --git a/src/core/SkSpecialSurface.cpp b/src/core/SkSpecialSurface.cpp
index 40afb57cec..1f396a7ac2 100644
--- a/src/core/SkSpecialSurface.cpp
+++ b/src/core/SkSpecialSurface.cpp
@@ -98,8 +98,8 @@ sk_sp<SkSpecialSurface> SkSpecialSurface::MakeFromBitmap(const SkIRect& subset,
 
 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 be60dee15e..0840d7c55e 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 @@ SkGradientShaderBase::GradientShaderCache::GradientShaderCache(
 {
     // 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 @@ void SkGradientShaderBase::GradientShaderCache::initCache32(GradientShaderCache*
     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 ec75bdc05a..f64b4396c2 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 @@ public:
 
         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 @@ public:
         // 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 92f5301061..4fae0f03c0 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -209,7 +209,7 @@ sk_sp<SkSurface> SkSurface::MakeRaster(const SkImageInfo& info, size_t rowBytes,
         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 4578bbb7d7..70958cae55 100644
--- a/tests/BitmapCopyTest.cpp
+++ b/tests/BitmapCopyTest.cpp
@@ -62,11 +62,11 @@ static void init_src(const SkBitmap& bitmap) {
     }
 }
 
-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 const int H = 33;
 
 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 @@ DEF_TEST(BitmapCopy, reporter) {
 
             // 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 @@ DEF_TEST(BitmapCopy, reporter) {
                                                      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 76621e6b38..9342d261c2 100644
--- a/tests/BitmapTest.cpp
+++ b/tests/BitmapTest.cpp
@@ -44,7 +44,7 @@ static void test_bigalloc(skiatest::Reporter* reporter) {
     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 cfa794ed68..50c205c16a 100644
--- a/tests/CodecPriv.h
+++ b/tests/CodecPriv.h
@@ -29,7 +29,7 @@ inline bool decode_memory(const void* mem, size_t size, SkBitmap* bm) {
         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 f3a393d7ac..dd11ff84fd 100644
--- a/tests/CodecTest.cpp
+++ b/tests/CodecTest.cpp
@@ -700,7 +700,8 @@ static void test_invalid_parameters(skiatest::Reporter* r, const char path[]) {
     } 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 bool alpha_type_match(SkAlphaType origAlphaType, SkAlphaType codecAlphaTy
 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 @@ static void check_round_trip(skiatest::Reporter* r, SkCodec* origCodec, const Sk
     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 0168d89d83..dae2bc9329 100644
--- a/tests/GifTest.cpp
+++ b/tests/GifTest.cpp
@@ -256,7 +256,7 @@ DEF_TEST(Gif_Sampled, r) {
     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 492985c18f..ba49000d9a 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -568,8 +568,10 @@ DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_drawAbandonedGpuImage, reporter, c
 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 096e3e69ee..b89d121579 100644
--- a/tests/MallocPixelRefTest.cpp
+++ b/tests/MallocPixelRefTest.cpp
@@ -25,8 +25,8 @@ DEF_TEST(MallocPixelRef, reporter) {
     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 @@ DEF_TEST(MallocPixelRef, reporter) {
         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 @@ DEF_TEST(MallocPixelRef, reporter) {
         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 @@ DEF_TEST(MallocPixelRef, reporter) {
     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 @@ DEF_TEST(MallocPixelRef, reporter) {
     {
         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 @@ DEF_TEST(MallocPixelRef, reporter) {
     {
         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 683e249626..487e5195f3 100644
--- a/tests/PixelRefTest.cpp
+++ b/tests/PixelRefTest.cpp
@@ -69,7 +69,7 @@ private:
 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 cace6b196e..c38e4d665d 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -263,7 +263,7 @@ static bool alloc_row_bytes(SkBitmap* bm, const SkImageInfo& info, size_t rowByt
     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 224bf3f66e..d7f90189a6 100644
--- a/tools/Resources.cpp
+++ b/tools/Resources.cpp
@@ -34,10 +34,9 @@ bool GetResourceAsBitmap(const char* resource, SkBitmap* dst) {
         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);
 }