stop calling SkCanvas::getDevice

tests/ReadPixelsTest.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"
 #include "SkMathPriv.h"
 #include "SkRegion.h"
+#include "SkSurface.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #include "SkGpuDevice.h"
 #endif
 
 static const int DEV_W = 100, DEV_H = 100;
 static const SkIRect DEV_RECT = SkIRect::MakeWH(DEV_W, DEV_H);
 static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1,
@@ skipping 267 matching lines @@
         SkIRect::MakeLTRB(3 * DEV_W / 4, -10, DEV_W + 10, DEV_H + 10),
     };
 
     for (int dtype = 0; dtype < 3; ++dtype) {
         int glCtxTypeCnt = 1;
 #if SK_SUPPORT_GPU
         if (0 != dtype)  {
             glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
         }
 #endif
+        const SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
         for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
-            SkAutoTUnref<SkBaseDevice> device;
+            SkAutoTUnref<SkSurface> surface;
             if (0 == dtype) {
-                SkImageInfo info = SkImageInfo::MakeN32Premul(DEV_W, DEV_H);
-                device.reset(SkBitmapDevice::Create(info));
+                surface.reset(SkSurface::NewRaster(info));
             } else {
 #if SK_SUPPORT_GPU
                 GrContextFactory::GLContextType type =
                     static_cast<GrContextFactory::GLContextType>(glCtxType);
                 if (!GrContextFactory::IsRenderingGLContext(type)) {
                     continue;
                 }
                 GrContext* context = factory->get(type);
                 if (NULL == context) {
                     continue;
                 }
                 GrTextureDesc desc;
+                surface.reset(SkSurface::NewScratchRenderTarget(context, info));

[bsalomon, 2014/06/30 13:24:33]

You don't need this line and line 323. The code at line 323 exercises using
different origins for the texture. So I think this one should be scrapped.

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

Yes. Don't know why I had that line.

                 desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
                 desc.fWidth = DEV_W;
                 desc.fHeight = DEV_H;
                 desc.fConfig = kSkia8888_GrPixelConfig;
-                desc.fOrigin = 1 == dtype ? kBottomLeft_GrSurfaceOrigin
-                                          : kTopLeft_GrSurfaceOrigin;
+                desc.fOrigin = 1 == dtype ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
                 GrAutoScratchTexture ast(context, desc, GrContext::kExact_ScratchTexMatch);
                 SkAutoTUnref<GrTexture> tex(ast.detach());
-                device.reset(new SkGpuDevice(context, tex));
+                surface.reset(SkSurface::NewRenderTargetDirect(tex->asRenderTarget()));
 #else
                 continue;
 #endif
             }
-            SkCanvas canvas(device);
+            SkCanvas& canvas = *surface->getCanvas();
             fillCanvas(&canvas);
 
             static const struct {
                 SkColorType fColorType;
                 SkAlphaType fAlphaType;
             } gReadConfigs[] = {
                 { kRGBA_8888_SkColorType,   kPremul_SkAlphaType },
                 { kRGBA_8888_SkColorType,   kUnpremul_SkAlphaType },
                 { kBGRA_8888_SkColorType,   kPremul_SkAlphaType },
                 { kBGRA_8888_SkColorType,   kUnpremul_SkAlphaType },
             };
             for (size_t rect = 0; rect < SK_ARRAY_COUNT(testRects); ++rect) {
                 const SkIRect& srcRect = testRects[rect];
                 for (BitmapInit bmi = kFirstBitmapInit; bmi < kBitmapInitCnt; bmi = nextBMI(bmi)) {
                     for (size_t c = 0; c < SK_ARRAY_COUNT(gReadConfigs); ++c) {
                         SkBitmap bmp;
                         init_bitmap(&bmp, srcRect, bmi,
                                     gReadConfigs[c].fColorType, gReadConfigs[c].fAlphaType);
 
                         // if the bitmap has pixels allocated before the readPixels,
                         // note that and fill them with pattern
                         bool startsWithPixels = !bmp.isNull();
                         if (startsWithPixels) {
                             fillBitmap(&bmp);
                         }
-                        uint32_t idBefore = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        uint32_t idBefore = surface->generationID();
                         bool success = canvas.readPixels(&bmp, srcRect.fLeft, srcRect.fTop);
-                        uint32_t idAfter = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        uint32_t idAfter = surface->generationID();
 
                         // we expect to succeed when the read isn't fully clipped
                         // out.
                         bool expectSuccess = SkIRect::Intersects(srcRect, DEV_RECT);
                         // determine whether we expected the read to succeed.
                         REPORTER_ASSERT(reporter, success == expectSuccess);
                         // read pixels should never change the gen id
                         REPORTER_ASSERT(reporter, idBefore == idAfter);
 
                         if (success || startsWithPixels) {
@@ skipping 17 matching lines @@
                         checkRead(reporter, wkbmp, clippedRect.fLeft,
                                   clippedRect.fTop, true, false);
                     } else {
                         REPORTER_ASSERT(reporter, !success);
                     }
                 }
             }
         }
     }
 }