unify peekPixels around pixmap parameter

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
 #include "DMGpuSupport.h"
@@ skipping 14 matching lines @@
 #include "SkUtils.h"
 #include "Test.h"
 
 static void assert_equal(skiatest::Reporter* reporter, SkImage* a, const SkIRect* subsetA,
                          SkImage* b) {
     const int widthA = subsetA ? subsetA->width() : a->width();
     const int heightA = subsetA ? subsetA->height() : a->height();
 
     REPORTER_ASSERT(reporter, widthA == b->width());
     REPORTER_ASSERT(reporter, heightA == b->height());
-#if 0
-    // see https://bug.skia.org/3965
-    bool AO = a->isOpaque();
-    bool BO = b->isOpaque();
-    REPORTER_ASSERT(reporter, AO == BO);
-#endif
+    REPORTER_ASSERT(reporter, a->isOpaque() == b->isOpaque());
 
     SkImageInfo info = SkImageInfo::MakeN32(widthA, heightA,
                                         a->isOpaque() ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
     SkAutoPixmapStorage pmapA, pmapB;
     pmapA.alloc(info);
     pmapB.alloc(info);
 
     const int srcX = subsetA ? subsetA->x() : 0;
     const int srcY = subsetA ? subsetA->y() : 0;
 
@@ skipping 18 matching lines @@
     return surface->newImageSnapshot();
 }
 #if 0
 static SkImage* create_image_565() {
     const SkImageInfo info = SkImageInfo::Make(20, 20, kRGB_565_SkColorType, kOpaque_SkAlphaType);
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRaster(info));
     draw_image_test_pattern(surface->getCanvas());
     return surface->newImageSnapshot();
 }
 #endif
-#if 0
 static SkImage* create_image_ct() {
     SkPMColor colors[] = {
         SkPreMultiplyARGB(0xFF, 0xFF, 0xFF, 0x00),
         SkPreMultiplyARGB(0x80, 0x00, 0xA0, 0xFF),
         SkPreMultiplyARGB(0xFF, 0xBB, 0x00, 0xBB)
     };
     SkAutoTUnref<SkColorTable> colorTable(new SkColorTable(colors, SK_ARRAY_COUNT(colors)));
     uint8_t data[] = {
         0, 0, 0, 0, 0,
         0, 1, 1, 1, 0,
         0, 1, 2, 1, 0,
         0, 1, 1, 1, 0,
         0, 0, 0, 0, 0
     };
     SkImageInfo info = SkImageInfo::Make(5, 5, kIndex_8_SkColorType, kPremul_SkAlphaType);
     return SkImage::NewRasterCopy(info, data, 5, colorTable);
 }
-#endif
 static SkData* create_image_data(SkImageInfo* info) {
     *info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
     const size_t rowBytes = info->minRowBytes();
     SkAutoTUnref<SkData> data(SkData::NewUninitialized(rowBytes * info->height()));
     {
         SkBitmap bm;
         bm.installPixels(*info, data->writable_data(), rowBytes);
         SkCanvas canvas(bm);
         draw_image_test_pattern(&canvas);
     }
@@ skipping 543 matching lines @@
         SkImage::kRW_LegacyBitmapMode,
     };
     for (auto& mode : modes) {
         SkAutoTUnref<SkImage> image(create_gpu_image(context));
         test_legacy_bitmap(reporter, image, mode);
     }
 }
 #endif
 
 static void test_peek(skiatest::Reporter* reporter, SkImage* image, bool expectPeekSuccess) {
-    SkImageInfo info;
-    size_t rowBytes;
-    const void* addr = image->peekPixels(&info, &rowBytes);
-    bool success = SkToBool(addr);
+    SkPixmap pm;
+    bool success = image->peekPixels(&pm);
     REPORTER_ASSERT(reporter, expectPeekSuccess == success);
     if (success) {
+        const SkImageInfo& info = pm.info();
         REPORTER_ASSERT(reporter, 20 == info.width());
         REPORTER_ASSERT(reporter, 20 == info.height());
         REPORTER_ASSERT(reporter, kN32_SkColorType == info.colorType());
         REPORTER_ASSERT(reporter, kPremul_SkAlphaType == info.alphaType() ||
                         kOpaque_SkAlphaType == info.alphaType());
-        REPORTER_ASSERT(reporter, info.minRowBytes() <= rowBytes);
-        REPORTER_ASSERT(reporter, SkPreMultiplyColor(SK_ColorWHITE) == *(const SkPMColor*)addr);
+        REPORTER_ASSERT(reporter, info.minRowBytes() <= pm.rowBytes());
+        REPORTER_ASSERT(reporter, SkPreMultiplyColor(SK_ColorWHITE) == *pm.addr32(0, 0));
     }
 }
 DEF_TEST(ImagePeek, reporter) {
     SkAutoTUnref<SkImage> image(create_image());
     test_peek(reporter, image, true);
 
     image.reset(create_data_image());
     test_peek(reporter, image, true);
 
     RasterDataHolder dataHolder;
@@ skipping 115 matching lines @@
             if (pixelA != pixelB) {
                 ERRORF(reporter, "Expected image pixels to be the same. At %d,%d 0x%08x != 0x%08x",
                        x, y, pixelA, pixelB);
                 return;
             }
         }
     }
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(NewTextureFromPixmap, reporter, context) {
-    for (auto create : {&create_image,
+    for (auto create : {&create_image
 #if 0 // read pixels failing for non RT formats (565 not a RT on some desktop GLs).
-                        &create_image_565
-#if 0 // peekPixels on color table images is currently broken.
+                        , &create_image_565
+#endif
                         , &create_image_ct
-#endif
-#endif
                         }) {
         SkAutoTUnref<SkImage> image((*create)());
         if (!image) {
             ERRORF(reporter, "Could not create image");
             return;
         }
 
         SkPixmap pixmap;
         if (!image->peekPixels(&pixmap)) {
             ERRORF(reporter, "peek failed");
         } else {
             SkAutoTUnref<SkImage> texImage(SkImage::NewTextureFromPixmap(context, pixmap,
                                                                          SkBudgeted::kNo));
             if (!texImage) {
                 ERRORF(reporter, "NewTextureFromPixmap failed.");
             } else {
                 check_images_same(reporter, image, texImage);
             }
         }
     }
 }
 
 #endif