stop calling SkCanvas::getDevice

tests/WritePixelsTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapDevice.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
@@ skipping 167 matching lines @@
     int32_t bA = static_cast<int32_t>(SkGetPackedA32(b));
     int32_t bR = static_cast<int32_t>(SkGetPackedR32(b));
     int32_t bG = static_cast<int32_t>(SkGetPackedG32(b));
     int32_t bB = static_cast<int32_t>(SkGetPackedB32(b));
 
     return aA == bA &&
            SkAbs32(aR - bR) <= 1 &&
            SkAbs32(aG - bG) <= 1 &&
            SkAbs32(aB - bB) <= 1;
 }
 

[robertphillips, 2014/06/30 13:36:20]

check_write ?

[reed1, 2014/06/30 14:33:12]

Done.

 static bool checkWrite(skiatest::Reporter* reporter, SkCanvas* canvas, const SkBitmap& bitmap,
                        int writeX, int writeY) {
-    SkImageInfo canvasInfo;
+    const SkImageInfo canvasInfo = canvas->imageInfo();
     size_t canvasRowBytes;
     const uint32_t* canvasPixels;
 
     // Can't use canvas->peekPixels(), as we are trying to look at GPU pixels sometimes as well.
     // At some point this will be unsupported, as we won't allow accessBitmap() to magically call
     // readPixels for the client.
     SkBitmap secretDevBitmap;
-    {
-        SkBaseDevice* dev = canvas->getDevice();
-        if (!dev) {
-            return false;
-        }
-        secretDevBitmap = dev->accessBitmap(false);
-    }
+    canvas->readPixels(SkIRect::MakeWH(canvasInfo.width(), canvasInfo.height()), &secretDevBitmap);
+
     SkAutoLockPixels alp(secretDevBitmap);
-    canvasInfo = secretDevBitmap.info();
     canvasRowBytes = secretDevBitmap.rowBytes();
     canvasPixels = static_cast<const uint32_t*>(secretDevBitmap.getPixels());
 
     if (NULL == canvasPixels) {
         return false;
     }
 
     if (canvasInfo.width() != DEV_W ||
         canvasInfo.height() != DEV_H ||
         canvasInfo.colorType() != kN32_SkColorType) {
@@ skipping 74 matching lines @@
 //
 static bool allocRowBytes(SkBitmap* bm, const SkImageInfo& info, size_t rowBytes) {
     if (!bm->setInfo(info, rowBytes)) {
         return false;
     }
     SkPixelRef* pr = SkMallocPixelRef::NewAllocate(info, rowBytes, NULL);
     bm->setPixelRef(pr)->unref();
     return true;
 }
 
-static SkBaseDevice* createDevice(const CanvasConfig& c, GrContext* grCtx) {
+static void free_pixels(void* pixels, void* ctx) {
+    sk_free(pixels);
+}
+

[robertphillips, 2014/06/30 13:36:20]

create_surface ?

[reed1, 2014/06/30 14:33:12]

Done.

+static SkSurface* createSurface(const CanvasConfig& c, GrContext* grCtx) {
+    SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
     switch (c.fDevType) {
         case kRaster_DevType: {
-            SkBitmap bmp;
-            size_t rowBytes = c.fTightRowBytes ? 0 : 4 * DEV_W + 100;
-            SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
-            if (!allocRowBytes(&bmp, info, rowBytes)) {
-                sk_throw();
-                return NULL;
+            const size_t rowBytes = c.fTightRowBytes ? info.minRowBytes() : 4 * DEV_W + 100;
+            const size_t size = info.getSafeSize(rowBytes);
+            void* pixels = sk_malloc_throw(size);
+            // if rowBytes isn't tight then set the padding to a known value
+            if (!c.fTightRowBytes) {
+                memset(pixels, DEV_PAD, size);
             }
-            // if rowBytes isn't tight then set the padding to a known value
-            if (rowBytes) {
-                SkAutoLockPixels alp(bmp);
-                // We'd just use memset here but GCC 4.8.1 throws up a bogus warning when we do.
-                for (size_t i = 0; i < bmp.getSafeSize(); i++) {
-                    ((uint8_t*)bmp.getPixels())[i] = DEV_PAD;
-                }
-            }
-            return new SkBitmapDevice(bmp);
+            return SkSurface::NewRasterDirectReleaseProc(info, pixels, rowBytes, free_pixels, NULL);
         }
 #if SK_SUPPORT_GPU
         case kGpu_BottomLeft_DevType:
         case kGpu_TopLeft_DevType:
             GrTextureDesc desc;
             desc.fFlags = kRenderTarget_GrTextureFlagBit;
             desc.fWidth = DEV_W;
             desc.fHeight = DEV_H;
             desc.fConfig = kSkia8888_GrPixelConfig;
             desc.fOrigin = kGpu_TopLeft_DevType == c.fDevType ?
                 kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
             GrAutoScratchTexture ast(grCtx, desc, GrContext::kExact_ScratchTexMatch);
             SkAutoTUnref<GrTexture> tex(ast.detach());
-            return new SkGpuDevice(grCtx, tex);
+            return SkSurface::NewRenderTargetDirect(tex->asRenderTarget());
 #endif
     }
     return NULL;
 }
 
 static bool setupBitmap(SkBitmap* bm, SkColorType ct, SkAlphaType at, int w, int h, int tightRB) {
     size_t rowBytes = tightRB ? 0 : 4 * w + 60;
     SkImageInfo info = SkImageInfo::Make(w, h, ct, at);
     if (!allocRowBytes(bm, info, rowBytes)) {
         return false;
@@ skipping 92 matching lines @@
                 if (!GrContextFactory::IsRenderingGLContext(type)) {
                     continue;
                 }
                 context = factory->get(type);
                 if (NULL == context) {
                     continue;
                 }
             }
 #endif
 
-            SkAutoTUnref<SkBaseDevice> device(createDevice(gCanvasConfigs[i], context));
-            SkCanvas canvas(device);
+            SkAutoTUnref<SkSurface> surface(createSurface(gCanvasConfigs[i], context));
+            SkCanvas& canvas = *surface->getCanvas();
 
             static const struct {
                 SkColorType fColorType;
                 SkAlphaType fAlphaType;
             } gSrcConfigs[] = {
                 { kRGBA_8888_SkColorType, kPremul_SkAlphaType },
                 { kRGBA_8888_SkColorType, kUnpremul_SkAlphaType },
                 { kBGRA_8888_SkColorType, kPremul_SkAlphaType },
                 { kBGRA_8888_SkColorType, kUnpremul_SkAlphaType },
             };
             for (size_t r = 0; r < SK_ARRAY_COUNT(testRects); ++r) {
                 const SkIRect& rect = testRects[r];
                 for (int tightBmp = 0; tightBmp < 2; ++tightBmp) {
                     for (size_t c = 0; c < SK_ARRAY_COUNT(gSrcConfigs); ++c) {
                         const SkColorType ct = gSrcConfigs[c].fColorType;
                         const SkAlphaType at = gSrcConfigs[c].fAlphaType;
 
                         fillCanvas(&canvas);
                         SkBitmap bmp;
                         REPORTER_ASSERT(reporter, setupBitmap(&bmp, ct, at, rect.width(),
                                                               rect.height(), SkToBool(tightBmp)));
-                        uint32_t idBefore = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        uint32_t idBefore = surface->generationID();
 
                        // sk_tool_utils::write_pixels(&canvas, bmp, rect.fLeft, rect.fTop, ct, at);
                         canvas.writePixels(bmp, rect.fLeft, rect.fTop);
 
-                        uint32_t idAfter = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        uint32_t idAfter = surface->generationID();
                         REPORTER_ASSERT(reporter, checkWrite(reporter, &canvas, bmp, rect.fLeft, rect.fTop));
 
                         // we should change the genID iff pixels were actually written.
                         SkIRect canvasRect = SkIRect::MakeSize(canvas.getDeviceSize());
                         SkIRect writeRect = SkIRect::MakeXYWH(rect.fLeft, rect.fTop,
                                                               bmp.width(), bmp.height());
                         bool intersects = SkIRect::Intersects(canvasRect, writeRect) ;
                         REPORTER_ASSERT(reporter, intersects == (idBefore != idAfter));
                     }
                 }
             }
         }
     }
 }