PixelRef now returns (nearly) everything that is currently in SkBitmap. The goal is to refactor bitmap later to remove redundancy, and more interestingly, remove the chance for a disconnect between the actual (pixelref) rowbytes and config, and the one claimed by the bitmap.

R=mtklein@google.com, scroggo@google.com

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

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

4 files changed, 39 insertions, 46 deletions

diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index 9289e11ea8..7049c0c299 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -44,12 +44,19 @@ public:
 // Crashing in skia when a pixelref fails in lockPixels
 //
 static void test_faulty_pixelref(skiatest::Reporter* reporter) {
+    SkImageInfo info;
+    info.fWidth = 100;
+    info.fHeight = 100;
+    info.fColorType = kPMColor_SkColorType;
+    info.fAlphaType = kPremul_SkAlphaType;
+
     // need a cache, but don't expect to use it, so the budget is not critical
     SkAutoTUnref<SkDiscardableMemoryPool> pool(SkNEW_ARGS(SkDiscardableMemoryPool,
                                                           (10 * 1000, NULL)));
     SkBitmap bm;
     bool installSuccess = SkDiscardablePixelRef::Install(SkNEW(FailureImageGenerator), &bm, pool);
     REPORTER_ASSERT(reporter, installSuccess);
+
     // now our bitmap has a pixelref, but we know it will fail to lock
 
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(200, 200));
diff --git a/tests/PictureTest.cpp b/tests/PictureTest.cpp
index 9ef4bb06bd..3c53dd3838 100644
--- a/tests/PictureTest.cpp
+++ b/tests/PictureTest.cpp
@@ -9,6 +9,7 @@
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
+#include "SkDecodingImageGenerator.h"
 #include "SkError.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
@@ -335,32 +336,6 @@ static void test_bad_bitmap() {
 }
 #endif
 
-#include "SkData.h"
-#include "SkImageRef_GlobalPool.h"
-// Class to test SkPixelRef::onRefEncodedData, since there are currently no implementations in skia.
-class SkDataImageRef : public SkImageRef_GlobalPool {
-
-public:
-    SkDataImageRef(SkMemoryStream* stream)
-        : SkImageRef_GlobalPool(stream, SkBitmap::kNo_Config) {
-        SkASSERT(stream != NULL);
-        fData = stream->copyToData();
-        this->setImmutable();
-    }
-
-    ~SkDataImageRef() {
-        fData->unref();
-    }
-
-    virtual SkData* onRefEncodedData() SK_OVERRIDE {
-        fData->ref();
-        return fData;
-    }
-
-private:
-    SkData* fData;
-};
-
 #include "SkImageEncoder.h"
 
 static SkData* encode_bitmap_to_data(size_t* offset, const SkBitmap& bm) {
@@ -402,14 +377,10 @@ static void test_bitmap_with_encoded_data(skiatest::Reporter* reporter) {
         return;
     }
     SkAutoDataUnref data(wStream.copyToData());
-    SkMemoryStream memStream;
-    memStream.setData(data);
 
-    // Use the encoded bitmap as the data for an image ref.
     SkBitmap bm;
-    SkAutoTUnref<SkDataImageRef> imageRef(SkNEW_ARGS(SkDataImageRef, (&memStream)));
-    imageRef->getInfo(&bm);
-    bm.setPixelRef(imageRef);
+    bool installSuccess = SkDecodingImageGenerator::Install(data, &bm);
+    REPORTER_ASSERT(reporter, installSuccess);
 
     // Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
     // Flattening original will follow the old path of performing an encode, while flattening bm
diff --git a/tests/PixelRefTest.cpp b/tests/PixelRefTest.cpp
index ce2575e830..f3625bd64d 100644
--- a/tests/PixelRefTest.cpp
+++ b/tests/PixelRefTest.cpp
@@ -17,33 +17,35 @@ private:
 }  // namespace
 
 DEF_TEST(PixelRef_GenIDChange, r) {
-    SkMallocPixelRef pixelRef(NULL, 0, NULL);  // We don't really care about the pixels here.
+    SkImageInfo info = { 10, 10, kPMColor_SkColorType, kPremul_SkAlphaType };
+
+    SkAutoTUnref<SkPixelRef> pixelRef(SkMallocPixelRef::NewAllocate(info, 0, NULL));
 
     // Register a listener.
     int count = 0;
-    pixelRef.addGenIDChangeListener(SkNEW_ARGS(TestListener, (&count)));
+    pixelRef->addGenIDChangeListener(SkNEW_ARGS(TestListener, (&count)));
     REPORTER_ASSERT(r, 0 == count);
 
     // No one has looked at our pixelRef's generation ID, so invalidating it doesn't make sense.
     // (An SkPixelRef tree falls in the forest but there's nobody around to hear it.  Do we care?)
-    pixelRef.notifyPixelsChanged();
+    pixelRef->notifyPixelsChanged();
     REPORTER_ASSERT(r, 0 == count);
 
     // Force the generation ID to be calculated.
-    REPORTER_ASSERT(r, 0 != pixelRef.getGenerationID());
+    REPORTER_ASSERT(r, 0 != pixelRef->getGenerationID());
 
     // Our listener was dropped in the first call to notifyPixelsChanged().  This is a no-op.
-    pixelRef.notifyPixelsChanged();
+    pixelRef->notifyPixelsChanged();
     REPORTER_ASSERT(r, 0 == count);
 
     // Force the generation ID to be recalculated, then add a listener.
-    REPORTER_ASSERT(r, 0 != pixelRef.getGenerationID());
-    pixelRef.addGenIDChangeListener(SkNEW_ARGS(TestListener, (&count)));
-    pixelRef.notifyPixelsChanged();
+    REPORTER_ASSERT(r, 0 != pixelRef->getGenerationID());
+    pixelRef->addGenIDChangeListener(SkNEW_ARGS(TestListener, (&count)));
+    pixelRef->notifyPixelsChanged();
     REPORTER_ASSERT(r, 1 == count);
 
     // Quick check that NULL is safe.
-    REPORTER_ASSERT(r, 0 != pixelRef.getGenerationID());
-    pixelRef.addGenIDChangeListener(NULL);
-    pixelRef.notifyPixelsChanged();
+    REPORTER_ASSERT(r, 0 != pixelRef->getGenerationID());
+    pixelRef->addGenIDChangeListener(NULL);
+    pixelRef->notifyPixelsChanged();
 }
diff --git a/tests/SerializationTest.cpp b/tests/SerializationTest.cpp
index e7bb437030..f8e4988b2e 100644
--- a/tests/SerializationTest.cpp
+++ b/tests/SerializationTest.cpp
@@ -148,6 +148,7 @@ static T* TestFlattenableSerialization(T* testObj, bool shouldSucceed,
     REPORTER_ASSERT(reporter, SkAlign4(bytesWritten) == bytesWritten);
 
     unsigned char dataWritten[1024];
+    SkASSERT(bytesWritten <= sizeof(dataWritten));
     writer.writeToMemory(dataWritten);
 
     // Make sure this fails when it should (test with smaller size, but still multiple of 4)
@@ -307,10 +308,22 @@ static void Tests(skiatest::Reporter* reporter) {
         TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
 
         // Create a bitmap with a pixel ref too small
+        SkImageInfo info;
+        info.fWidth = 256;
+        info.fHeight = 256;
+        info.fColorType = kPMColor_SkColorType;
+        info.fAlphaType = kPremul_SkAlphaType;
+
         SkBitmap invalidBitmap2;
-        invalidBitmap2.setConfig(SkBitmap::kARGB_8888_Config, 256, 256);
-        invalidBitmap2.setPixelRef(SkNEW_ARGS(SkMallocPixelRef,
-            (NULL, 256, NULL)))->unref();
+        invalidBitmap2.setConfig(info);
+        
+        // Hack to force invalid, by making the pixelref smaller than its
+        // owning bitmap.
+        info.fWidth = 32;
+        info.fHeight = 1;
+        
+        invalidBitmap2.setPixelRef(SkMallocPixelRef::NewAllocate(
+                        info, invalidBitmap2.rowBytes(), NULL))->unref();
 
         // The deserialization should detect the pixel ref being too small and fail
         TestBitmapSerialization(validBitmap, invalidBitmap2, false, reporter);