unify peekPixels around pixmap parameter

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 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 "SkCanvas.h"
 #include "SkData.h"
@@ skipping 139 matching lines @@
     gpu->deleteTestingOnlyBackendTexture(texHandle);
 }
 #endif
 
 static void test_canvas_peek(skiatest::Reporter* reporter,
                              SkSurface* surface,
                              const SkImageInfo& requestInfo,
                              bool expectPeekSuccess) {
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
-    SkImageInfo info;
-    size_t rowBytes;
     surface->getCanvas()->clear(color);
 
-    const void* addr = surface->getCanvas()->peekPixels(&info, &rowBytes);
-    bool success = SkToBool(addr);
+    SkPixmap pmap;
+    bool success = surface->getCanvas()->peekPixels(&pmap);
     REPORTER_ASSERT(reporter, expectPeekSuccess == success);
 
-    SkImageInfo info2;
-    size_t rb2;
-    const void* addr2 = surface->peekPixels(&info2, &rb2);
+    SkPixmap pmap2;
+    const void* addr2 = surface->peekPixels(&pmap2) ? pmap2.addr() : nullptr;
 
     if (success) {
-        REPORTER_ASSERT(reporter, requestInfo == info);
-        REPORTER_ASSERT(reporter, requestInfo.minRowBytes() <= rowBytes);
-        REPORTER_ASSERT(reporter, pmcolor == *(const SkPMColor*)addr);
+        REPORTER_ASSERT(reporter, requestInfo == pmap.info());
+        REPORTER_ASSERT(reporter, requestInfo.minRowBytes() <= pmap.rowBytes());
+        REPORTER_ASSERT(reporter, pmcolor == *pmap.addr32());
 
-        REPORTER_ASSERT(reporter, addr2 == addr);
-        REPORTER_ASSERT(reporter, info2 == info);
-        REPORTER_ASSERT(reporter, rb2 == rowBytes);
+        REPORTER_ASSERT(reporter, pmap.addr() == pmap2.addr());
+        REPORTER_ASSERT(reporter, pmap.info() == pmap2.info());
+        REPORTER_ASSERT(reporter, pmap.rowBytes() == pmap2.rowBytes());
     } else {
         REPORTER_ASSERT(reporter, nullptr == addr2);
     }
 }
 DEF_TEST(SurfaceCanvasPeek, reporter) {
     for (auto& surface_func : { &create_surface, &create_direct_surface }) {
         SkImageInfo requestInfo;
         SkAutoTUnref<SkSurface> surface(surface_func(kPremul_SkAlphaType, &requestInfo));
         test_canvas_peek(reporter, surface, requestInfo, true);
     }
@@ skipping 190 matching lines @@
 }
 
 DEF_TEST(UniqueImageSnapshot, reporter) {
     auto getImageBackingStore = [reporter](SkImage* image) {
         SkPixmap pm;
         bool success = image->peekPixels(&pm);
         REPORTER_ASSERT(reporter, success);
         return reinterpret_cast<intptr_t>(pm.addr());
     };
     auto getSufaceBackingStore = [reporter](SkSurface* surface) {
-        SkImageInfo info;
-        size_t rowBytes;
-        const void* pixels = surface->getCanvas()->peekPixels(&info, &rowBytes);
+        SkPixmap pmap;
+        const void* pixels = surface->getCanvas()->peekPixels(&pmap) ? pmap.addr() : nullptr;
         REPORTER_ASSERT(reporter, pixels);
         return reinterpret_cast<intptr_t>(pixels);
     };
 
     SkAutoTUnref<SkSurface> surface(create_surface());
     test_unique_image_snap(reporter, surface, false, getImageBackingStore, getSufaceBackingStore);
     surface.reset(create_direct_surface());
     test_unique_image_snap(reporter, surface, true, getImageBackingStore, getSufaceBackingStore);
 }
 
@@ skipping 375 matching lines @@
                 SkAutoTUnref<SkSurface> surface(
                     surface_func(context, kPremul_SkAlphaType, nullptr));
                 test_func(reporter, surface, mode);
             }
         }
     }
 }
 #endif
 
 static void check_rowbytes_remain_consistent(SkSurface* surface, skiatest::Reporter* reporter) {
-    SkImageInfo info;
-    size_t rowBytes;
-    REPORTER_ASSERT(reporter, surface->peekPixels(&info, &rowBytes));
+    SkPixmap surfacePM;
+    REPORTER_ASSERT(reporter, surface->peekPixels(&surfacePM));
 
     SkAutoTUnref<SkImage> image(surface->newImageSnapshot());
-    SkImageInfo im_info;
-    size_t im_rowbytes;
-    REPORTER_ASSERT(reporter, image->peekPixels(&im_info, &im_rowbytes));
+    SkPixmap pm;
+    REPORTER_ASSERT(reporter, image->peekPixels(&pm));
 
-    REPORTER_ASSERT(reporter, rowBytes == im_rowbytes);
+    REPORTER_ASSERT(reporter, surfacePM.rowBytes() == pm.rowBytes());
 
     // trigger a copy-on-write
     surface->getCanvas()->drawPaint(SkPaint());
     SkAutoTUnref<SkImage> image2(surface->newImageSnapshot());
     REPORTER_ASSERT(reporter, image->uniqueID() != image2->uniqueID());
 
-    SkImageInfo im_info2;
-    size_t im_rowbytes2;
-    REPORTER_ASSERT(reporter, image2->peekPixels(&im_info2, &im_rowbytes2));
-
-    REPORTER_ASSERT(reporter, im_rowbytes2 == im_rowbytes);
+    SkPixmap pm2;
+    REPORTER_ASSERT(reporter, image2->peekPixels(&pm2));
+    REPORTER_ASSERT(reporter, pm2.rowBytes() == pm.rowBytes());
 }
 
 DEF_TEST(surface_rowbytes, reporter) {
     const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100);
 
     SkAutoTUnref<SkSurface> surf0(SkSurface::NewRaster(info));
     check_rowbytes_remain_consistent(surf0, reporter);
 
     // specify a larger rowbytes
     SkAutoTUnref<SkSurface> surf1(SkSurface::NewRaster(info, 500, nullptr));
@@ skipping 79 matching lines @@
         desc.fHeight = kHeight;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
 
         SkSurface* surface = SkSurface::NewFromBackendTexture(context, desc, nullptr);
         test_surface_clear(reporter, surface, grSurfaceGetter, 0xABABABAB);
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif