Revert[4] "clean up (partially) colortable api""""

Fixes:
- create temp api for android to pass nullptr
- don't release and access sk_sp<SkData> at the same time in parameters

This reverts commit b14131c1851eea6acbd34cc42a8f860daed36b21.

Bug: skia:
Change-Id: Ic0e4f62520ba9f35455499ed30d306ad19d998a8
Reviewed-on: https://skia-review.googlesource.com/11129
Commit-Queue: Mike Reed <reed@google.com>
Reviewed-by: Matt Sarett <msarett@google.com>

3 files changed, 62 insertions, 46 deletions

diff --git a/include/core/SkBitmap.h b/include/core/SkBitmap.h
index fd25a23cdd..1a2daf0845 100644
--- a/include/core/SkBitmap.h
+++ b/include/core/SkBitmap.h
@@ -238,20 +238,29 @@ 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, and will be ref'd.
+     *  a colortable, then ColorTable must be non-null.
+     *
      *  On failure, the bitmap will be set to empty and return false.
      */
-    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)) {
+    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)) {
             sk_throw();
         }
     }
 
+    // TEMPORARY -- remove after updating Android BitmapTests.cpp:35
+    void allocPixels(const SkImageInfo& info, std::nullptr_t, SkColorTable* ctable) {
+        this->allocPixels(info, sk_ref_sp(ctable));
+    }
+
     /**
      *  Allocate the bitmap's pixels to match the requested image info and
      *  rowBytes. If the request cannot be met (e.g. the info is invalid or
diff --git a/include/core/SkColorTable.h b/include/core/SkColorTable.h
index 07dfd675b2..40919d3bac 100644
--- a/include/core/SkColorTable.h
+++ b/include/core/SkColorTable.h
@@ -24,10 +24,12 @@
 */
 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);
-    virtual ~SkColorTable();
+    ~SkColorTable() override;
 
     /** Returns the number of colors in the table.
      */
@@ -52,7 +54,7 @@ public:
     void writeToBuffer(SkWriteBuffer&) const;
 
     // may return null
-    static SkColorTable* Create(SkReadBuffer&);
+    static sk_sp<SkColorTable> Create(SkReadBuffer&);
 
 private:
     enum AllocatedWithMalloc {
diff --git a/include/core/SkMallocPixelRef.h b/include/core/SkMallocPixelRef.h
index bb07fa2dab..2e4c4e69eb 100644
--- a/include/core/SkMallocPixelRef.h
+++ b/include/core/SkMallocPixelRef.h
@@ -22,12 +22,10 @@ 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 SkMallocPixelRef* NewDirect(const SkImageInfo&, void* addr,
-                                       size_t rowBytes, SkColorTable*);
+    static sk_sp<SkPixelRef> MakeDirect(const SkImageInfo&, void* addr,
+                                       size_t rowBytes, sk_sp<SkColorTable>);
 
     /**
      *  Return a new SkMallocPixelRef, automatically allocating storage for the
@@ -39,22 +37,18 @@ public:
      *
      *  Returns NULL on failure.
      */
-    static SkMallocPixelRef* NewAllocate(const SkImageInfo& info,
-                                         size_t rowBytes, SkColorTable*);
+    static sk_sp<SkPixelRef> MakeAllocate(const SkImageInfo&, size_t rowBytes, sk_sp<SkColorTable>);
 
     /**
-     *  Identical to NewAllocate, except all pixel bytes are zeroed.
+     *  Identical to MakeAllocate, except all pixel bytes are zeroed.
      */
-    static SkMallocPixelRef* NewZeroed(const SkImageInfo& info,
-                                       size_t rowBytes, SkColorTable*);
+    static sk_sp<SkPixelRef> MakeZeroed(const SkImageInfo&, size_t rowBytes, sk_sp<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
@@ -63,10 +57,10 @@ public:
      *  Returns NULL on failure.
      */
     typedef void (*ReleaseProc)(void* addr, void* context);
-    static SkMallocPixelRef* NewWithProc(const SkImageInfo& info,
-                                         size_t rowBytes, SkColorTable*,
-                                         void* addr, ReleaseProc proc,
-                                         void* context);
+    static sk_sp<SkPixelRef> MakeWithProc(const SkImageInfo& info,
+                                          size_t rowBytes, sk_sp<SkColorTable>,
+                                          void* addr, ReleaseProc proc,
+                                          void* context);
 
     /**
      *  Return a new SkMallocPixelRef that will use the provided
@@ -74,27 +68,38 @@ 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*,
@@ -107,18 +112,18 @@ protected:
 
 private:
     // Uses alloc to implement NewAllocate or NewZeroed.
-    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*,
+    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>,
                      ReleaseProc proc, void* context);
 
     typedef SkPixelRef INHERITED;