remove picture-backed surfaces

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
 #include "SkRRect.h"
 #include "SkSurface.h"
 #include "SkUtils.h"
 #include "Test.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContextFactory.h"
 #else
 class GrContextFactory;
 class GrContext;
 #endif
 
 enum SurfaceType {
     kRaster_SurfaceType,
     kRasterDirect_SurfaceType,
     kGpu_SurfaceType,
     kGpuScratch_SurfaceType,
-    kPicture_SurfaceType
 };
 
 static const int gSurfaceSize = 10;
 static SkPMColor gSurfaceStorage[gSurfaceSize * gSurfaceSize];
 
 static SkSurface* createSurface(SurfaceType surfaceType, GrContext* context,
                                 SkImageInfo* requestedInfo = NULL) {
     static const SkImageInfo info = SkImageInfo::MakeN32Premul(gSurfaceSize,
                                                                gSurfaceSize);
 
@@ skipping 10 matching lines @@
         case kGpu_SurfaceType:
 #if SK_SUPPORT_GPU
             return context ? SkSurface::NewRenderTarget(context, info) : NULL;
 #endif
             break;
         case kGpuScratch_SurfaceType:
 #if SK_SUPPORT_GPU
             return context ? SkSurface::NewScratchRenderTarget(context, info) : NULL;
 #endif
             break;
-        case kPicture_SurfaceType:
-            return SkSurface::NewPicture(info.fWidth, info.fHeight);
     }
     return NULL;
 }
 
 enum ImageType {
     kRasterCopy_ImageType,
     kRasterData_ImageType,
     kGpu_ImageType,
-    kPicture_ImageType,
     kCodec_ImageType,
 };
 
 static void test_image(skiatest::Reporter* reporter) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
     size_t rowBytes = info.minRowBytes();
     size_t size = info.getSafeSize(rowBytes);
     void* addr = sk_malloc_throw(size);
     SkData* data = SkData::NewFromMalloc(addr, size);
 
@@ skipping 16 matching lines @@
     sk_memset32((SkPMColor*)addr, pmcolor, SkToInt(size >> 2));
     SkAutoTUnref<SkData> data(SkData::NewFromMalloc(addr, size));
 
     switch (imageType) {
         case kRasterCopy_ImageType:
             return SkImage::NewRasterCopy(info, addr, rowBytes);
         case kRasterData_ImageType:
             return SkImage::NewRasterData(info, data, rowBytes);
         case kGpu_ImageType:
             return NULL;        // TODO
-        case kPicture_ImageType: {
-            SkAutoTUnref<SkSurface> surf(SkSurface::NewPicture(info.fWidth,
-                                                               info.fHeight));
-            surf->getCanvas()->drawColor(SK_ColorRED);
-            return surf->newImageSnapshot();
-        }
         case kCodec_ImageType: {
             SkBitmap bitmap;
             bitmap.installPixels(info, addr, rowBytes, NULL, NULL);
             SkAutoTUnref<SkData> src(
                  SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type,
                                             100));
             return SkImage::NewEncodedData(src);
         }
     }
     SkASSERT(false);
     return NULL;
 }
 
 static void test_imagepeek(skiatest::Reporter* reporter) {
     static const struct {
         ImageType   fType;
         bool        fPeekShouldSucceed;
     } gRec[] = {
         { kRasterCopy_ImageType,    true    },
         { kRasterData_ImageType,    true    },
         { kGpu_ImageType,           false   },
-        { kPicture_ImageType,       false   },
         { kCodec_ImageType,         false   },
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         SkImageInfo info;
         size_t rowBytes;
 
@@ skipping 21 matching lines @@
     static const struct {
         SurfaceType fType;
         bool        fPeekShouldSucceed;
     } gRec[] = {
         { kRaster_SurfaceType,          true    },
         { kRasterDirect_SurfaceType,    true    },
 #if SK_SUPPORT_GPU
         { kGpu_SurfaceType,             false   },
         { kGpuScratch_SurfaceType,      false   },
 #endif
-        { kPicture_SurfaceType,         false   },
     };
 
     const SkColor color = SK_ColorRED;
     const SkPMColor pmcolor = SkPreMultiplyColor(color);
 
     GrContext* context = NULL;
 #if SK_SUPPORT_GPU
     context = factory->get(GrContextFactory::kNative_GLContextType);
 #endif
 
@@ skipping 228 matching lines @@
         SkDEBUGCODE(surface->validate();)
         REPORTER_ASSERT(reporter, image1 != image2);
     }
 
 }
 
 DEF_GPUTEST(Surface, reporter, factory) {
     test_image(reporter);
 
     TestSurfaceCopyOnWrite(reporter, kRaster_SurfaceType, NULL);
-    TestSurfaceCopyOnWrite(reporter, kPicture_SurfaceType, NULL);
     TestSurfaceWritableAfterSnapshotRelease(reporter, kRaster_SurfaceType, NULL);
-    TestSurfaceWritableAfterSnapshotRelease(reporter, kPicture_SurfaceType, NULL);
     TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kDiscard_ContentChangeMode);
     TestSurfaceNoCanvas(reporter, kRaster_SurfaceType, NULL, SkSurface::kRetain_ContentChangeMode);
 
     test_imagepeek(reporter);
     test_canvaspeek(reporter, factory);
 
 #if SK_SUPPORT_GPU
     TestGetTexture(reporter, kRaster_SurfaceType, NULL);
-    TestGetTexture(reporter, kPicture_SurfaceType, NULL);
     if (NULL != factory) {
         GrContext* context = factory->get(GrContextFactory::kNative_GLContextType);
         if (NULL != context) {
             TestSurfaceInCache(reporter, kGpu_SurfaceType, context);
             TestSurfaceInCache(reporter, kGpuScratch_SurfaceType, context);
             Test_crbug263329(reporter, kGpu_SurfaceType, context);
             Test_crbug263329(reporter, kGpuScratch_SurfaceType, context);
             TestSurfaceCopyOnWrite(reporter, kGpu_SurfaceType, context);
             TestSurfaceCopyOnWrite(reporter, kGpuScratch_SurfaceType, context);
             TestSurfaceWritableAfterSnapshotRelease(reporter, kGpu_SurfaceType, context);
             TestSurfaceWritableAfterSnapshotRelease(reporter, kGpuScratch_SurfaceType, context);
             TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode);
             TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kDiscard_ContentChangeMode);
             TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
             TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
             TestGetTexture(reporter, kGpu_SurfaceType, context);
             TestGetTexture(reporter, kGpuScratch_SurfaceType, context);
         }
     }
 #endif
 }