Hide SkMallocPixelRef class befind SkPixelRef factory functions.

include/core/SkPixelRef.h

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPixelRef_DEFINED
 #define SkPixelRef_DEFINED
 
@@ skipping 32 matching lines @@
     This class is the smart container for pixel memory, and is used with
     SkBitmap. A pixelref is installed into a bitmap, and then the bitmap can
     access the actual pixel memory by calling lockPixels/unlockPixels.
 
     This class can be shared/accessed between multiple threads.
 */
 class SK_API SkPixelRef : public SkFlattenable {
 public:
     SK_DECLARE_INST_COUNT(SkPixelRef)
 
+    /**
+     *  Return a new pre-locked SkPixelRef, automatically allocating
+     *  storage for the pixels. If rowBytes are 0, an optimal value
+     *  will be chosen automatically.  If rowBytes is > 0, then it
+     *  will be respected, or NULL will be returned if rowBytes is
+     *  invalid for the specified info.
+     *
+     *  This pixelref will ref() the specified colortable (if not NULL).
+     *
+     *  Returns NULL on failure.
+     */
+    static SkPixelRef* NewPrelockedAllocate(

[scroggo, 2014/04/04 21:21:06]

I know the goal is to hide SkMallocPixelRef, but I have to say I think
SkPrelockedPixelRef would be much better!

+            const SkImageInfo& info,
+            size_t rowBytes,
+            SkColorTable* colorTable);
+
+    /**
+     *  Return a new pre-locked immutable SkPixelRef that will use
+     *  the provided SkData, rowBytes, and optional colortable as
+     *  pixel storage.  The SkData will be ref()ed, and on destruction
+     *  of the PixelRef, the SkData will be unref()ed.
+     *
+     *  @param offset (in bytes) into the provided SkData that the
+     *         first pixel is located at.
+     *
+     *  This pixelref will ref() the specified colortable (if not NULL).
+     *
+     *  Returns NULL on failure.
+     */
+    static SkPixelRef* NewPrelockedWithData(

[scroggo, 2014/04/04 21:21:06]

I thought Mike wanted to move people away from dealing with SkPixelRef directly.
Am I misremembering that?

+            const SkImageInfo& info,
+            size_t rowBytes,
+            SkColorTable* colorTable,
+            SkData* data,
+            size_t offset = 0);

[scroggo, 2014/04/04 21:21:06]

This seems like an odd choice, given that we switched SkBitmap to take an x,y.
That said, perhaps a byte offset is more logical here because we're talking
about an offset into an SkData?

[hal.canary, 2014/04/07 14:43:02]

Look at our existing use of SkMallocPixelRef::NewWithData in dm/DMWriteTask.cpp.
 a size_t offset is exactly what we want there.

[mtklein, 2014/04/07 14:51:01]

Yep, exactly.  x and y don't make sense until you're at an offset where there
are pixels.  E.g. an 8888 image after a 6 byte header.

+
+    /**
+     *  Return a new pre-locked SkPixelRef with the provided pixel
+     *  storage, rowBytes, and optional colortable. On destruction,
+     *  ReleaseProc will be called. If this function fails,
+     *  ReleaseProc will be called before returning NULL.
+     *
+     *  This pixelref will ref() the specified colortable (if not NULL).
+     *
+     *  Returns NULL on failure.
+     */
+    static SkPixelRef* NewPrelockedDirectWithProc(
+            const SkImageInfo& info,
+            size_t rowBytes,
+            SkColorTable* colorTable,
+            void* pixelAddress,
+            void (*releaseProcedure)(void* pixelAddress, void* context),
+            void* releaseProcedureContext);
+
+    /**
+     *  Return a new pre-locked SkPixelRef with the provided pixel
+     *  storage, rowBytes, and optional colortable. The caller is
+     *  responsible for managing the 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 SkPixelRef* NewPrelockedDirect(
+            const SkImageInfo& info,
+            size_t rowBytes,
+            SkColorTable* colorTable,
+            void* pixelAddress) {
+        return SkPixelRef::NewPrelockedDirectWithProc(
+                info, rowBytes, colorTable, pixelAddress, NULL, NULL);
+    }
+
     explicit SkPixelRef(const SkImageInfo&);
     SkPixelRef(const SkImageInfo&, SkBaseMutex* mutex);
     virtual ~SkPixelRef();
 
     const SkImageInfo& info() const {
         return fInfo;
     }
 
     /** Return the pixel memory returned from lockPixels, or null if the
         lockCount is 0.
@@ skipping 308 matching lines @@
     /**
      *  Allocate a new pixelref matching the specified ImageInfo, allocating
      *  the memory for the pixels. If the ImageInfo requires a ColorTable,
      *  the pixelref will ref() the colortable.
      *  On failure return NULL.
      */
     virtual SkPixelRef* create(const SkImageInfo&, SkColorTable*) = 0;
 };
 
 #endif