Revert of remove (dumb) canvas::NewRaster, and rename surface::NewRasterPMColor to N32Premul

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 14 matching lines @@
 
 static const int gWidth = 2;
 static const int gHeight = 2;
 
 static void create(SkBitmap* bm, SkColor color) {
     bm->allocN32Pixels(gWidth, gHeight);
     bm->eraseColor(color);
 }
 
 static SkSurface* createSurface(SkColor color) {
-    SkSurface* surface = SkSurface::NewRasterN32Premul(gWidth, gHeight);
+    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);
     SkCanvas canvas(bitmap);
 
@@ skipping 398 matching lines @@
     int fFlushedDrawCommandsCount;
     int fSkippedPendingDrawCommandsCount;
 
 private:
     typedef SkDeferredCanvas::NotificationClient INHERITED;
 };
 
 // Verifies that the deferred canvas triggers a flush when its memory
 // limit is exceeded
 static void TestDeferredCanvasMemoryLimit(skiatest::Reporter* reporter) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
     canvas->setMaxRecordingStorage(160000);
 
     SkBitmap sourceImage;
     // 100 by 100 image, takes 40,000 bytes in memory
     sourceImage.allocN32Pixels(100, 100);
@@ skipping 14 matching lines @@
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
     canvas->silentFlush(); // will skip the initial clear that was recorded in createSurface
 
     REPORTER_ASSERT(reporter, 0 == notificationCounter.fFlushedDrawCommandsCount);
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fSkippedPendingDrawCommandsCount);
 }
 
 static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
     const int imageCount = 2;
     SkBitmap sourceImages[imageCount];
     for (int i = 0; i < imageCount; i++) {
         sourceImages[i].allocN32Pixels(100, 100);
         sourceImages[i].eraseColor(SK_ColorGREEN);
@@ skipping 59 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) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     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.
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
+    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.allocN32Pixels(10, 10);
@@ skipping 14 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) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
 
     SkBitmap sourceImage;
     // 100 by 100 image, takes 40,000 bytes in memory
     sourceImage.allocN32Pixels(100, 100);
     sourceImage.eraseColor(SK_ColorGREEN);
 
     // 1 under : should not store the image
     {
         SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
         canvas->setBitmapSizeThreshold(39999);
@@ skipping 170 matching lines @@
         REPORTER_ASSERT(reporter, get_surface_ptr(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, get_surface_ptr(surface, useGpu) == pixels1);
         REPORTER_ASSERT(reporter, get_surface_ptr(alternateSurface, useGpu) != pixels2);
     }
 }
 
 static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporter) {
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterN32Premul(100, 100));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(100, 100));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
 
     NotificationCounter notificationCounter;
     canvas->setNotificationClient(&notificationCounter);
 
     SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
     SkAutoTUnref<SkSurface> secondarySurface(canvas->newSurface(info));
 
     SkRect rect = SkRect::MakeWH(5, 5);
     SkPaint paint;
@@ skipping 10 matching lines @@
     SkRect rect;
     rect.setXYWH(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(gWidth), SkIntToScalar(gHeight));
     SkRect clip;
     clip.setXYWH(SkIntToScalar(0), SkIntToScalar(0), SkIntToScalar(1), SkIntToScalar(1));
 
     SkPaint paint;
     SkISize size = SkISize::Make(gWidth, gHeight);
 
     SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
     SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(surface.get()));
-    SkSurface* newSurface = SkSurface::NewRasterN32Premul(4, 4);
+    SkSurface* newSurface = SkSurface::NewRasterPMColor(4, 4);
     SkAutoTUnref<SkSurface> aur(newSurface);
 
     for (int i = 0; i < 2; ++i) {
         if (i == 1) {
             canvas->setSurface(newSurface);
             size = SkISize::Make(4, 4);
         }
 
         // verify that canvas size is correctly initialized or set
         REPORTER_ASSERT(reporter, size == canvas->getCanvasSize());
@@ skipping 43 matching lines @@
     TestDeferredCanvasSurface(reporter, NULL);
     TestDeferredCanvasSetSurface(reporter, NULL);
 }
 
 DEF_GPUTEST(DeferredCanvas_GPU, reporter, factory) {
     if (factory != NULL) {
         TestDeferredCanvasSurface(reporter, factory);
         TestDeferredCanvasSetSurface(reporter, factory);
     }
 }