Removing deprecated constructors and setDevice from SkDeferredCanvas

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 "Test.h"
 #include "SkBitmap.h"
 #include "SkBitmapProcShader.h"
@@ skipping 16 matching lines @@
     bm->setConfig(config, gWidth, gHeight);
     bm->allocPixels();
     bm->eraseColor(color);
 }
 
 static void TestDeferredCanvasBitmapAccess(skiatest::Reporter* reporter) {
     SkBitmap store;
 
     create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
     SkDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
 
     canvas->clear(0x00000000);
 
     SkAutoLockPixels alp(store);
     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
     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());
 }
 
@@ skipping 29 matching lines @@
         fDiscardCount = 0;
         fRetainCount = 0;
     }
 
     int fDiscardCount, fRetainCount;
     SkBitmap fBitmap;
 };
 
 static void TestDeferredCanvasWritePixelsToSurface(skiatest::Reporter* reporter) {
     SkAutoTUnref<MockSurface> surface(SkNEW_ARGS(MockSurface, (10, 10)));
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(surface.get()));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (surface.get())));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     SkBitmap srcBitmap;
     srcBitmap.setConfig(SkBitmap::kARGB_8888_Config, 10, 10);
     srcBitmap.allocPixels();
     srcBitmap.eraseColor(SK_ColorGREEN);
     // Tests below depend on this bitmap being recognized as opaque
 
     // Preliminary sanity check: no copy on write if no active snapshot
     surface->clearCounts();
     canvas->clear(SK_ColorWHITE);
@@ skipping 155 matching lines @@
     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);
     SkDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
 
     canvas->clear(0x00000000);
 
     SkAutoLockPixels alp(store);
     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0xFFFFFFFF); //verify that clear was deferred
     canvas->flush();
     REPORTER_ASSERT(reporter, store.getColor(0,0) == 0x00000000); //verify that clear was executed
 }
 
 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);
     SkDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
 
     // 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 152 matching lines @@
     int fDrawBitmapCallCount;
 };
 
 // Verifies that the deferred canvas triggers a flush when its memory
 // limit is exceeded
 static void TestDeferredCanvasMemoryLimit(skiatest::Reporter* reporter) {
     SkBitmap store;
     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
     store.allocPixels();
     MockDevice mockDevice(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&mockDevice));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&mockDevice)));
-#endif
+    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);
@@ skipping 30 matching lines @@
 private:
     typedef SkDeferredCanvas::NotificationClient INHERITED;
 };
 
 static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
     SkBitmap store;
     store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
     store.allocPixels();
     SkDevice device(store);
     NotificationCounter notificationCounter;
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    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 62 matching lines @@
     // 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();
     SkDevice device(store);
     NotificationCounter notificationCounter;
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    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();
     SkDevice device(store);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
     // 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 25 matching lines @@
     store.allocPixels();
 
     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
     {
         SkDevice device(store);
-        SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-            SkDeferredCanvas::Create(&device));
-#else
-            SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
         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
     {
         SkDevice device(store);
-        SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-            SkDeferredCanvas::Create(&device));
-#else
-            SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
         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
     {
         SkDevice device(store);
-        SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-            SkDeferredCanvas::Create(&device));
-#else
-            SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+        SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
         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 19 matching lines @@
         surface = SkSurface::NewRenderTarget(context, imageSpec);
     } else {
         surface = SkSurface::NewRaster(imageSpec);
     }
 #else
     SkASSERT(!useGpu);
     surface = SkSurface::NewRaster(imageSpec);
 #endif
     SkASSERT(NULL != surface);
     SkAutoTUnref<SkSurface> aur(surface);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(surface));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (surface)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface));
 
     SkImage* image1 = canvas->newImageSnapshot();
     SkAutoTUnref<SkImage> aur_i1(image1);
     PixelPtr pixels1 = getSurfacePixelPtr(surface, useGpu);
     // The following clear would normally trigger a copy on write, but
     // it won't because rendering is deferred.
     canvas->clear(SK_ColorBLACK);
     // Obtaining a snapshot directly from the surface (as opposed to the
     // SkDeferredCanvas) will not trigger a flush of deferred draw operations
     // and will therefore return the same image as the previous snapshot.
@@ skipping 54 matching lines @@
     SkASSERT(!useGpu);
     surface = SkSurface::NewRaster(imageSpec);
     alternateSurface = SkSurface::NewRaster(imageSpec);
 #endif
     SkASSERT(NULL != surface);
     SkASSERT(NULL != alternateSurface);
     SkAutoTUnref<SkSurface> aur1(surface);
     SkAutoTUnref<SkSurface> aur2(alternateSurface);
     PixelPtr pixels1 = getSurfacePixelPtr(surface, useGpu);
     PixelPtr pixels2 = getSurfacePixelPtr(alternateSurface, useGpu);
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(surface));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (surface)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface));
     SkAutoTUnref<SkImage> image1(canvas->newImageSnapshot());
     canvas->setSurface(alternateSurface);
     SkAutoTUnref<SkImage> image2(canvas->newImageSnapshot());
     REPORTER_ASSERT(reporter, image1->uniqueID() != image2->uniqueID());
     // Verify that none of the above operations triggered a surface copy on write.
     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();
     SkDevice device(store);
     NotificationCounter notificationCounter;
-    SkAutoTUnref<SkDeferredCanvas> canvas(
-#if SK_DEFERRED_CANVAS_USES_FACTORIES
-        SkDeferredCanvas::Create(&device));
-#else
-        SkNEW_ARGS(SkDeferredCanvas, (&device)));
-#endif
+    SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
     canvas->setNotificationClient(&notificationCounter);
     SkAutoTUnref<SkDevice> secondaryDevice(canvas->createCompatibleDevice(
         SkBitmap::kARGB_8888_Config, 10, 10, device.isOpaque()));
     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);
@@ skipping 16 matching lines @@
     TestDeferredCanvasSurface(reporter, NULL);
     TestDeferredCanvasSetSurface(reporter, NULL);
     if (NULL != factory) {
         TestDeferredCanvasSurface(reporter, factory);
         TestDeferredCanvasSetSurface(reporter, factory);
     }
 }
 
 #include "TestClassDef.h"
 DEFINE_GPUTESTCLASS("DeferredCanvas", TestDeferredCanvasClass, TestDeferredCanvas)