remove (unused by chrome) SkDeferredCanvas(device) factory signature

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"
 #include "SkBitmapDevice.h"
 #include "SkBitmapProcShader.h"
 #include "SkDeferredCanvas.h"
 #include "SkGradientShader.h"
 #include "SkShader.h"
+#include "SkSurface.h"
 #include "Test.h"
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #else
 class GrContextFactory;
 #endif
 
 static const int gWidth = 2;
 static const int gHeight = 2;
 
 static void create(SkBitmap* bm, SkBitmap::Config config, SkColor color) {
     bm->setConfig(config, gWidth, gHeight);
     bm->allocPixels();
     bm->eraseColor(color);
 }
 
+static SkSurface* createSurface(SkColor color) {
+    SkSurface* surface = SkSurface::NewRasterPMColor(gWidth, gHeight);
+    surface->getCanvas()->clear(color);
+    return surface;
+}
+
+static SkPMColor read_pixel(SkSurface* surface, int x, int y) {
+    SkPMColor pixel = 0;
+    SkBitmap bitmap;
+    bitmap.installPixels(SkImageInfo::MakeN32Premul(1, 1), &pixel, 4, NULL, NULL);
+    SkCanvas canvas(bitmap);
+
+    SkPaint paint;
+    paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+    surface->draw(&canvas, -x, -y, &paint);
+    return pixel;
+}
+
 static void TestDeferredCanvasBitmapAccess(skiatest::Reporter* reporter) {
     SkBitmap store;
 
-    create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
-    SkBitmapDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
-
+    SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
+    
     canvas->clear(0x00000000);
 
-    SkAutoLockPixels alp(store);
-    REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
+    // verify that the clear() was deferred
+    REPORTER_ASSERT(reporter, 0xFFFFFFFF == read_pixel(surface, 0, 0));
+
     SkBitmap accessed = canvas->getDevice()->accessBitmap(false);
-    REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
-    REPORTER_ASSERT(reporter, accessed.pixelRef() == store.pixelRef());
+
+    // 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.setConfig(SkBitmap::kARGB_8888_Config, width, height);
         fBitmap.allocPixels();
     }
 
@@ skipping 193 matching lines @@
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
     REPORTER_ASSERT(reporter, 1 == surface->fRetainCount);
 
     surface->clearCounts();
     canvas->flush();
     REPORTER_ASSERT(reporter, 0 == surface->fDiscardCount);
     REPORTER_ASSERT(reporter, 0 == surface->fRetainCount);
 }
 
 static void TestDeferredCanvasFlush(skiatest::Reporter* reporter) {
-    SkBitmap store;
-
-    create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
-    SkBitmapDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
+    SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     canvas->clear(0x00000000);
 
-    SkAutoLockPixels alp(store);
-    REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
+    // verify that clear was deferred
+    REPORTER_ASSERT(reporter, 0xFFFFFFFF == read_pixel(surface, 0, 0));
+
     canvas->flush();
-    REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
+
+    // verify that clear was executed
+    REPORTER_ASSERT(reporter, 0 == read_pixel(surface, 0, 0));
 }
 
 static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
-    SkBitmap store;
     SkRect fullRect;
     fullRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(gWidth),
         SkIntToScalar(gHeight));
     SkRect partialRect;
     partialRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0),
         SkIntToScalar(1), SkIntToScalar(1));
-    create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
-    SkBitmapDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
+
+    SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     // verify that frame is intially fresh
     REPORTER_ASSERT(reporter, canvas->isFreshFrame());
     // no clearing op since last call to isFreshFrame -> not fresh
     REPORTER_ASSERT(reporter, !canvas->isFreshFrame());
 
     // Verify that clear triggers a fresh frame
     canvas->clear(0x00000000);
     REPORTER_ASSERT(reporter, canvas->isFreshFrame());
 
@@ skipping 148 matching lines @@
                             const SkMatrix&, const SkPaint&) SK_OVERRIDE {
         fDrawBitmapCallCount++;
     }
 
     int fDrawBitmapCallCount;
 };
 
 // Verifies that the deferred canvas triggers a flush when its memory
 // limit is exceeded
 static void TestDeferredCanvasMemoryLimit(skiatest::Reporter* reporter) {
+#if 0   // TODO -- need a surface-oriented way to exercise this.

[Justin Novosad, 2014/02/03 21:33:47]

You could register an SkDeferredCanvas::NotificationClient and verify that
flushedDrawCommands() get called on the notification client after the 4th
drawBitmap.

[reed1, 2014/02/03 21:52:40]

Done.

     SkBitmap store;
     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
     store.allocPixels();
     MockDevice mockDevice(store);
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&mockDevice));
     canvas->setMaxRecordingStorage(160000);
 
     SkBitmap sourceImage;
     // 100 by 100 image, takes 40,000 bytes in memory
     sourceImage.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
     sourceImage.allocPixels();
 
     for (int i = 0; i < 5; i++) {
         sourceImage.notifyPixelsChanged(); // to force re-serialization
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
     }
 
     REPORTER_ASSERT(reporter, mockDevice.fDrawBitmapCallCount == 4);
+#endif
 }
 
 class NotificationCounter : public SkDeferredCanvas::NotificationClient {
 public:
     NotificationCounter() {
         fPrepareForDrawCount = fStorageAllocatedChangedCount =
             fFlushedDrawCommandsCount = fSkippedPendingDrawCommandsCount = 0;
     }
 
     virtual void prepareForDraw() SK_OVERRIDE {
@@ skipping 12 matching lines @@
     int fPrepareForDrawCount;
     int fStorageAllocatedChangedCount;
     int fFlushedDrawCommandsCount;
     int fSkippedPendingDrawCommandsCount;
 
 private:
     typedef SkDeferredCanvas::NotificationClient INHERITED;
 };
 
 static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
-    SkBitmap store;
-    store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    store.allocPixels();
-    SkBitmapDevice device(store);
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
+
     NotificationCounter notificationCounter;
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
     canvas->setNotificationClient(&notificationCounter);
 
     const int imageCount = 2;
     SkBitmap sourceImages[imageCount];
     for (int i = 0; i < imageCount; i++)
     {
         sourceImages[i].setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
         sourceImages[i].allocPixels();
     }
 
@@ skipping 57 matching lines @@
     canvas->drawBitmap(sourceImages[1], 0, 0, NULL);
     sourceImages[1].notifyPixelsChanged();
     canvas->drawBitmap(sourceImages[1], 0, 0, NULL);
     REPORTER_ASSERT(reporter, canvas->storageAllocatedForRecording() > 2*bitmapSize);
 
     // Verify that nothing in this test caused commands to be skipped
     REPORTER_ASSERT(reporter, 0 == notificationCounter.fSkippedPendingDrawCommandsCount);
 }
 
 static void TestDeferredCanvasSkip(skiatest::Reporter* reporter) {
-    SkBitmap store;
-    store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    store.allocPixels();
-    SkBitmapDevice device(store);
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
+
     NotificationCounter notificationCounter;
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
     canvas->setNotificationClient(&notificationCounter);
     canvas->clear(0x0);
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fSkippedPendingDrawCommandsCount);
     REPORTER_ASSERT(reporter, 0 == notificationCounter.fFlushedDrawCommandsCount);
     canvas->flush();
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fSkippedPendingDrawCommandsCount);
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fFlushedDrawCommandsCount);
 
 }
 
 static void TestDeferredCanvasBitmapShaderNoLeak(skiatest::Reporter* reporter) {
     // This is a regression test for crbug.com/155875
     // This test covers a code path that inserts bitmaps into the bitmap heap through the
     // flattening of SkBitmapProcShaders. The refcount in the bitmap heap is maintained through
     // the flattening and unflattening of the shader.
-    SkBitmap store;
-    store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    store.allocPixels();
-    SkBitmapDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
     // test will fail if nbIterations is not in sync with
     // BITMAPS_TO_KEEP in SkGPipeWrite.cpp
     const int nbIterations = 5;
     size_t bytesAllocated = 0;
     for(int pass = 0; pass < 2; ++pass) {
         for(int i = 0; i < nbIterations; ++i) {
             SkPaint paint;
             SkBitmap paintPattern;
             paintPattern.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
             paintPattern.allocPixels();
@@ skipping 13 matching lines @@
                 REPORTER_ASSERT(reporter, newBytesAllocated == bytesAllocated);
             }
         }
     }
     // All cached resources should be evictable since last canvas call was flush()
     canvas->freeMemoryIfPossible(~0U);
     REPORTER_ASSERT(reporter, 0 == canvas->storageAllocatedForRecording());
 }
 
 static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter) {
-    SkBitmap store;
-    store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    store.allocPixels();
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
 
     SkBitmap sourceImage;
     // 100 by 100 image, takes 40,000 bytes in memory
     sourceImage.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
     sourceImage.allocPixels();
 
     // 1 under : should not store the image
     {
-        SkBitmapDevice device(store);
-        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
+        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
         canvas->setBitmapSizeThreshold(39999);
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
         REPORTER_ASSERT(reporter, newBytesAllocated == 0);
     }
 
     // exact value : should store the image
     {
-        SkBitmapDevice device(store);
-        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
+        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
         canvas->setBitmapSizeThreshold(40000);
         canvas->drawBitmap(sourceImage, 0, 0, NULL);
         size_t newBytesAllocated = canvas->storageAllocatedForRecording();
         REPORTER_ASSERT(reporter, newBytesAllocated > 0);
     }
 
     // 1 over : should still store the image
     {
-        SkBitmapDevice device(store);
-        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
+        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;
 // Returns an opaque pointer which, either points to a GrTexture or RAM pixel
@@ skipping 117 matching lines @@
     REPORTER_ASSERT(reporter, getSurfacePixelPtr(surface, useGpu) == pixels1);
     REPORTER_ASSERT(reporter, getSurfacePixelPtr(alternateSurface, useGpu) == pixels2);
     // Verify that a flushed draw command will trigger a copy on write on alternateSurface.
     canvas->clear(SK_ColorWHITE);
     canvas->flush();
     REPORTER_ASSERT(reporter, getSurfacePixelPtr(surface, useGpu) == pixels1);
     REPORTER_ASSERT(reporter, getSurfacePixelPtr(alternateSurface, useGpu) != pixels2);
 }
 
 static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
-    SkBitmap store;
-    store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
-    store.allocPixels();
-    SkBitmapDevice device(store);
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
+
     NotificationCounter notificationCounter;
-    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
     canvas->setNotificationClient(&notificationCounter);
+
     SkAutoTUnref<SkBaseDevice> secondaryDevice(canvas->createCompatibleDevice(
-        SkBitmap::kARGB_8888_Config, 10, 10, device.isOpaque()));
+        SkBitmap::kARGB_8888_Config, 10, 10, false));
     SkCanvas secondaryCanvas(secondaryDevice.get());
     SkRect rect = SkRect::MakeWH(5, 5);
     SkPaint paint;
     // After spawning a compatible canvas:
     // 1) Verify that secondary canvas is usable and does not report to the notification client.
     secondaryCanvas.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);
@@ skipping 10 matching lines @@
     TestDeferredCanvasBitmapSizeThreshold(reporter);
     TestDeferredCanvasCreateCompatibleDevice(reporter);
     TestDeferredCanvasWritePixelsToSurface(reporter);
     TestDeferredCanvasSurface(reporter, NULL);
     TestDeferredCanvasSetSurface(reporter, NULL);
     if (NULL != factory) {
         TestDeferredCanvasSurface(reporter, factory);
         TestDeferredCanvasSetSurface(reporter, factory);
     }
 }