stop calling SkCanvas::getDevice

tests/DeferredCanvasTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "../src/image/SkImagePriv.h"
 #include "../src/image/SkSurface_Base.h"
 #include "SkBitmap.h"
@@ skipping 31 matching lines @@
     SkBitmap bitmap;
     bitmap.installPixels(SkImageInfo::MakeN32Premul(1, 1), &pixel, 4);
     SkCanvas canvas(bitmap);
 
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kSrc_Mode);
     surface->draw(&canvas, -SkIntToScalar(x), -SkIntToScalar(y), &paint);
     return pixel;
 }
 
-static void TestDeferredCanvasBitmapAccess(skiatest::Reporter* reporter) {
-    SkBitmap store;
-
-    SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
-
-    canvas->clear(0x00000000);
-
-    // verify that the clear() was deferred
-    REPORTER_ASSERT(reporter, 0xFFFFFFFF == read_pixel(surface, 0, 0));
-
-    SkBitmap accessed = canvas->getDevice()->accessBitmap(false);
-
-    // verify that clear was executed
-    REPORTER_ASSERT(reporter, 0 == read_pixel(surface, 0, 0));
-}
-
 class MockSurface : public SkSurface_Base {
 public:
     MockSurface(int width, int height) : SkSurface_Base(width, height) {
         clearCounts();
         fBitmap.allocN32Pixels(width, height);
     }
 
     virtual SkCanvas* onNewCanvas() SK_OVERRIDE {
         return SkNEW_ARGS(SkCanvas, (fBitmap));
     }
@@ skipping 595 matching lines @@
     {
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
         canvas->setBitmapSizeThreshold(40001);
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
         REPORTER_ASSERT(reporter, newBytesAllocated > 0);
     }
 }
 
 
-typedef void* PixelPtr;
+typedef const void* PixelPtr;
 // Returns an opaque pointer which, either points to a GrTexture or RAM pixel
 // buffer. Used to test pointer equality do determine whether a surface points
 // to the same pixel data storage as before.

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

get_surface_pixelptr ?

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

Done.

 static PixelPtr getSurfacePixelPtr(SkSurface* surface, bool useGpu) {
-    return useGpu ? surface->getCanvas()->getDevice()->accessBitmap(false).getTexture() :
-        surface->getCanvas()->getDevice()->accessBitmap(false).getPixels();
+    if (useGpu) {
+        return surface->getCanvas()->internal_private_accessTopLayerRenderTarget()->asTexture();
+    } else {
+        return surface->peekPixels(NULL, NULL);
+    }
 }
 
 static void TestDeferredCanvasSurface(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkImageInfo imageSpec = SkImageInfo::MakeN32Premul(10, 10);
     SkSurface* surface;
     bool useGpu = NULL != factory;
 #if SK_SUPPORT_GPU
     if (useGpu) {
         GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
         if (NULL == context) {
@@ skipping 113 matching lines @@
     // After spawning a compatible canvas:
     // 1) Verify that secondary canvas is usable and does not report to the notification client.
     surface->getCanvas()->drawRect(rect, paint);
     REPORTER_ASSERT(reporter, notificationCounter.fStorageAllocatedChangedCount == 0);
     // 2) Verify that original canvas is usable and still reports to the notification client.
     canvas->drawRect(rect, paint);
     REPORTER_ASSERT(reporter, notificationCounter.fStorageAllocatedChangedCount == 1);
 }
 
 DEF_TEST(DeferredCanvas_CPU, reporter) {
-    TestDeferredCanvasBitmapAccess(reporter);
     TestDeferredCanvasFlush(reporter);
     TestDeferredCanvasSilentFlush(reporter);
     TestDeferredCanvasFreshFrame(reporter);
     TestDeferredCanvasMemoryLimit(reporter);
     TestDeferredCanvasBitmapCaching(reporter);
     TestDeferredCanvasSkip(reporter);
     TestDeferredCanvasBitmapShaderNoLeak(reporter);
     TestDeferredCanvasBitmapSizeThreshold(reporter);
     TestDeferredCanvasCreateCompatibleDevice(reporter);
     TestDeferredCanvasWritePixelsToSurface(reporter);
     TestDeferredCanvasSurface(reporter, NULL);
     TestDeferredCanvasSetSurface(reporter, NULL);
 }
 
 DEF_GPUTEST(DeferredCanvas_GPU, reporter, factory) {
     if (factory != NULL) {
         TestDeferredCanvasSurface(reporter, factory);
         TestDeferredCanvasSetSurface(reporter, factory);
     }
 }