Sk_API for SkImageGenerator and SkInstallDiscardablePixelRef

Added SK_API to SkImageGenerator (already in include/).

Moved SkDiscardablePixelRef::Install to SkInstallDiscardablePixelRef,
added SK_API to that function, and moved declaration to
SkImageGenerator.h

This keeps the SkDiscardablePixelRef internal to Skia, but exposes a
method to install it into a bitmap.

Modifed tests that rely on this functio to use new version.

BUG=
R=mtklein@google.com, reed@google.com

Review URL: https://codereview.chromium.org/111713002

git-svn-id: http://skia.googlecode.com/svn/trunk@12612 2bbb7eff-a529-9590-31e7-b0007b416f81

diff --git a/include/core/SkImageGenerator.h b/include/core/SkImageGenerator.h
index c56e62a9d671642be8b1db78b187e2a22aea73fc..d56f8f8bbbad311e9aa58f8285b5d52781d24a48 100644 (file)
--- a/include/core/SkImageGenerator.h
+++ b/include/core/SkImageGenerator.h
@@ -8,15 +8,43 @@
 #ifndef SkImageGenerator_DEFINED
 #define SkImageGenerator_DEFINED
 
+#include "SkDiscardableMemory.h"
 #include "SkImageInfo.h"
 
+class SkBitmap;
 class SkData;
+class SkImageGenerator;
+
+/**
+ *  Takes ownership of SkImageGenerator.  If this method fails for
+ *  whatever reason, it will return false and immediatetely delete
+ *  the generator.  If it succeeds, it will modify destination
+ *  bitmap.
+ *
+ *  If this fails or when the SkDiscardablePixelRef that is
+ *  installed into destination is destroyed, it will call
+ *  SkDELETE() on the generator.  Therefore, generator should be
+ *  allocated with SkNEW() or SkNEW_ARGS().
+ *
+ *  @param destination Upon success, this bitmap will be
+ *  configured and have a pixelref installed.
+ *
+ *  @param factory If not NULL, this object will be used as a
+ *  source of discardable memory when decoding.  If NULL, then
+ *  SkDiscardableMemory::Create() will be called.
+ *
+ *  @return true iff successful.
+ */
+SK_API bool SkInstallDiscardablePixelRef(SkImageGenerator* generator,
+                                         SkBitmap* destination,
+                                         SkDiscardableMemory::Factory* factory = NULL);
+
 
 /**
  *  An interface that allows a purgeable PixelRef (such as a
  *  SkDiscardablePixelRef) to decode and re-decode an image as needed.
  */
-class SkImageGenerator {
+class SK_API SkImageGenerator {
 public:
     /**
      *  The PixelRef which takes ownership of this SkImageGenerator

diff --git a/src/images/SkDecodingImageGenerator.cpp b/src/images/SkDecodingImageGenerator.cpp
index 212104976f410dc8776170ea0297413d1d62e59c..a833c636ff9c8d30df1c1ade660743ea8b2a47d2 100644 (file)
--- a/src/images/SkDecodingImageGenerator.cpp
+++ b/src/images/SkDecodingImageGenerator.cpp
@@ -7,8 +7,8 @@
 
 #include "SkDecodingImageGenerator.h"
 #include "SkData.h"
-#include "SkDiscardablePixelRef.h"
 #include "SkImageDecoder.h"
+#include "SkImageGenerator.h"
 #include "SkImagePriv.h"
 #include "SkStream.h"
 
@@ -191,7 +191,7 @@ bool SkDecodingImageGenerator::Install(SkData* data, SkBitmap* dst,
     SkASSERT(data != NULL);
     SkASSERT(dst != NULL);
     SkImageGenerator* gen(SkNEW_ARGS(SkDecodingImageGenerator, (data)));
-    return SkDiscardablePixelRef::Install(gen, dst, factory);
+    return SkInstallDiscardablePixelRef(gen, dst, factory);
 }
 
 bool SkDecodingImageGenerator::Install(SkStreamRewindable* stream,
@@ -204,5 +204,5 @@ bool SkDecodingImageGenerator::Install(SkStreamRewindable* stream,
         return false;
     }
     SkImageGenerator* gen(SkNEW_ARGS(SkDecodingImageGenerator, (stream)));
-    return SkDiscardablePixelRef::Install(gen, dst, factory);
+    return SkInstallDiscardablePixelRef(gen, dst, factory);
 }

diff --git a/src/lazy/SkDiscardablePixelRef.cpp b/src/lazy/SkDiscardablePixelRef.cpp
index e614db37e98589678919002432f1d9feb687f6d5..6a9507c8c76a713bba3c7a85388e3f8e4c78d702 100644 (file)
--- a/src/lazy/SkDiscardablePixelRef.cpp
+++ b/src/lazy/SkDiscardablePixelRef.cpp
@@ -7,6 +7,7 @@
 
 #include "SkDiscardablePixelRef.h"
 #include "SkDiscardableMemory.h"
+#include "SkImageGenerator.h"
 
 SkDiscardablePixelRef::SkDiscardablePixelRef(SkImageGenerator* generator,
                                              const SkImageInfo& info,
@@ -62,18 +63,22 @@ void SkDiscardablePixelRef::onUnlockPixels() {
     }
 }
 
-bool SkDiscardablePixelRef::Install(SkImageGenerator* generator,
-                                    SkBitmap* dst,
-                                    SkDiscardableMemory::Factory* factory) {
+bool SkInstallDiscardablePixelRef(SkImageGenerator* generator,
+                                  SkBitmap* dst,
+                                  SkDiscardableMemory::Factory* factory) {
     SkImageInfo info;
     SkASSERT(generator != NULL);
     if ((NULL == generator)
         || (!generator->getInfo(&info))
-        || (!dst->setConfig(info, 0))
-        || (0 == dst->getSize())) {  // dst->getSize=0 Probably a bad config
+        || (!dst->setConfig(info, 0))) {
         SkDELETE(generator);
         return false;
     }
+    SkASSERT(dst->config() != SkBitmap::kNo_Config);
+    if (dst->empty()) { // Use a normal pixelref.
+        SkDELETE(generator);  // Do not need this anymore.
+        return dst->allocPixels(NULL, NULL);
+    }
     SkAutoTUnref<SkDiscardablePixelRef> ref(SkNEW_ARGS(SkDiscardablePixelRef,
                                                    (generator, info,
                                                     dst->getSize(),

diff --git a/src/lazy/SkDiscardablePixelRef.h b/src/lazy/SkDiscardablePixelRef.h
index 78dcd66791f3d430da2676f57570f68218e832ca..44c6df9637ab2db5dc503d9e872095c29a09ad02 100644 (file)
--- a/src/lazy/SkDiscardablePixelRef.h
+++ b/src/lazy/SkDiscardablePixelRef.h
@@ -9,43 +9,12 @@
 #define SkDiscardablePixelRef_DEFINED
 
 #include "SkDiscardableMemory.h"
-#include "SkPixelRef.h"
 #include "SkImageGenerator.h"
 #include "SkImageInfo.h"
-
-/**
- * An interface that allows a purgable PixelRef to re-decode an image.
- */
-
-typedef SkDiscardableMemory* (*SkDiscardableMemoryFactory)(size_t bytes);
-
+#include "SkPixelRef.h"
 
 class SkDiscardablePixelRef : public SkPixelRef {
 public:
-    /**
-     *  Takes ownership of SkImageGenerator.  If this method fails for
-     *  whatever reason, it will return false and immediatetely delete
-     *  the generator.  If it succeeds, it will modify destination
-     *  bitmap.
-     *
-     *  If Install fails or when the SkDiscardablePixelRef that is
-     *  installed into destination is destroyed, it will call
-     *  SkDELETE() on the generator.  Therefore, generator should be
-     *  allocated with SkNEW() or SkNEW_ARGS().
-     *
-     *  @param destination Upon success, this bitmap will be
-     *  configured and have a pixelref installed.
-     *
-     *  @param factory If not NULL, this object will be used as a
-     *  source of discardable memory when decoding.  If NULL, then
-     *  SkDiscardableMemory::Create() will be called.
-     *
-     *  @return true iff successful.
-     */
-    static bool Install(SkImageGenerator* generator,
-                        SkBitmap* destination,
-                        SkDiscardableMemory::Factory* factory = NULL);
-
     SK_DECLARE_UNFLATTENABLE_OBJECT()
 
 protected:
@@ -75,5 +44,9 @@ private:
                           size_t size,
                           size_t rowBytes,
                           SkDiscardableMemory::Factory* factory);
+    friend bool SkInstallDiscardablePixelRef(SkImageGenerator*,
+                                             SkBitmap*,
+                                             SkDiscardableMemory::Factory*);
+    typedef SkPixelRef INHERITED;
 };
 #endif  // SkDiscardablePixelRef_DEFINED

diff --git a/tests/CachedDecodingPixelRefTest.cpp b/tests/CachedDecodingPixelRefTest.cpp
index 1e4ab3f35db027181b0229867a48f526b6e6885b..f97e89361fab1b19d734fcdda64c9b959ba16295 100644 (file)
--- a/tests/CachedDecodingPixelRefTest.cpp
+++ b/tests/CachedDecodingPixelRefTest.cpp
@@ -9,7 +9,6 @@
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
-#include "SkDiscardablePixelRef.h"
 #include "SkDiscardableMemoryPool.h"
 #include "SkImageDecoder.h"
 #include "SkCachingPixelRef.h"
@@ -257,7 +256,7 @@ void CheckPixelRef(TestImageGenerator::TestType type,
         // Ignore factory; use global SkScaledImageCache.
         success = SkCachingPixelRef::Install(gen.detach(), &lazy);
     } else {
-        success = SkDiscardablePixelRef::Install(gen.detach(), &lazy, factory);
+        success = SkInstallDiscardablePixelRef(gen.detach(), &lazy, factory);
     }
     REPORTER_ASSERT(reporter, success
                     == (TestImageGenerator::kFailGetInfo_TestType != type));

diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index 9289e11ea8f6a6a9737275fab19dc4304d0e4b9f..642e2cedb98f178cda49c2b08796fbd532a996a0 100644 (file)
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -10,7 +10,7 @@
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkDiscardableMemoryPool.h"
-#include "SkDiscardablePixelRef.h"
+#include "SkImageGenerator.h"
 #include "SkPaint.h"
 #include "SkShader.h"
 #include "SkSurface.h"
@@ -48,7 +48,7 @@ static void test_faulty_pixelref(skiatest::Reporter* reporter) {
     SkAutoTUnref<SkDiscardableMemoryPool> pool(SkNEW_ARGS(SkDiscardableMemoryPool,
                                                           (10 * 1000, NULL)));
     SkBitmap bm;
-    bool installSuccess = SkDiscardablePixelRef::Install(SkNEW(FailureImageGenerator), &bm, pool);
+    bool installSuccess = SkInstallDiscardablePixelRef(SkNEW(FailureImageGenerator), &bm, pool);
     REPORTER_ASSERT(reporter, installSuccess);
     // now our bitmap has a pixelref, but we know it will fail to lock
 

diff --git a/tools/LazyDecodeBitmap.cpp b/tools/LazyDecodeBitmap.cpp
index f5ff1477d342afd8ef8d344fe46b5b4aeed406bb..9a4a36ffe85914360ff2db49af5701d574516382 100644 (file)
--- a/tools/LazyDecodeBitmap.cpp
+++ b/tools/LazyDecodeBitmap.cpp
@@ -10,7 +10,7 @@
 #include "SkData.h"
 #include "SkDecodingImageGenerator.h"
 #include "SkDiscardableMemoryPool.h"
-#include "SkDiscardablePixelRef.h"
+#include "SkImageGenerator.h"
 #include "SkForceLinking.h"
 
 #include "SkCommandLineFlags.h"
@@ -44,5 +44,5 @@ bool sk_tools::LazyDecodeBitmap(const void* src,
         // Only meaningful if platform has a default discardable
         // memory implementation that differs from the global DM pool.
     }
-    return SkDiscardablePixelRef::Install(gen.detach(), dst, pool);
+    return SkInstallDiscardablePixelRef(gen.detach(), dst, pool);
 }