Split SkDevice into SkBaseDevice and SkBitmapDevice

tests/WritePixelsTest.cpp

 
 /*
  * Copyright 2011 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 "SkCanvas.h"
@@ skipping 209 matching lines @@
            SkAbs32(aR - bR) <= 1 &&
            SkAbs32(aG - bG) <= 1 &&
            SkAbs32(aB - bB) <= 1;
 }
 
 bool checkWrite(skiatest::Reporter* reporter,
                 SkCanvas* canvas,
                 const SkBitmap& bitmap,
                 int writeX, int writeY,
                 SkCanvas::Config8888 config8888) {
-    SkDevice* dev = canvas->getDevice();
+    SkBaseDevice* dev = canvas->getDevice();
     if (!dev) {
         return false;
     }
     SkBitmap devBmp = dev->accessBitmap(false);
     if (devBmp.width() != DEV_W ||
         devBmp.height() != DEV_H ||
         devBmp.config() != SkBitmap::kARGB_8888_Config ||
         devBmp.isNull()) {
         return false;
     }
@@ skipping 57 matching lines @@
 
 static const CanvasConfig gCanvasConfigs[] = {
     {kRaster_DevType, true},
     {kRaster_DevType, false},
 #if SK_SUPPORT_GPU && defined(SK_SCALAR_IS_FLOAT)
     {kGpu_BottomLeft_DevType, true}, // row bytes has no meaning on gpu devices
     {kGpu_TopLeft_DevType, true}, // row bytes has no meaning on gpu devices
 #endif
 };
 
-SkDevice* createDevice(const CanvasConfig& c, GrContext* grCtx) {
+SkBaseDevice* createDevice(const CanvasConfig& c, GrContext* grCtx) {
     switch (c.fDevType) {
         case kRaster_DevType: {
             SkBitmap bmp;
             size_t rowBytes = c.fTightRowBytes ? 0 : 4 * DEV_W + 100;
             bmp.setConfig(SkBitmap::kARGB_8888_Config, DEV_W, DEV_H, rowBytes);
             if (!bmp.allocPixels()) {
                 sk_throw();
                 return NULL;
             }
             // if rowBytes isn't tight then set the padding to a known value
             if (rowBytes) {
                 SkAutoLockPixels alp(bmp);
                 memset(bmp.getPixels(), DEV_PAD, bmp.getSafeSize());
             }
-            return new SkDevice(bmp);
+            return new SkBitmapDevice(bmp);
         }
 #if SK_SUPPORT_GPU
         case kGpu_BottomLeft_DevType:
         case kGpu_TopLeft_DevType:
             GrTextureDesc desc;
             desc.fFlags = kRenderTarget_GrTextureFlagBit;
             desc.fWidth = DEV_W;
             desc.fHeight = DEV_H;
             desc.fConfig = kSkia8888_GrPixelConfig;
             desc.fOrigin = kGpu_TopLeft_DevType == c.fDevType ?
@@ skipping 94 matching lines @@
                 if (!GrContextFactory::IsRenderingGLContext(type)) {
                     continue;
                 }
                 context = factory->get(type);
                 if (NULL == context) {
                     continue;
                 }
             }
 #endif
 
-            SkAutoTUnref<SkDevice> device(createDevice(gCanvasConfigs[i], context));
+            SkAutoTUnref<SkBaseDevice> device(createDevice(gCanvasConfigs[i], context));
             SkCanvas canvas(device);
 
             static const SkCanvas::Config8888 gSrcConfigs[] = {
                 SkCanvas::kNative_Premul_Config8888,
                 SkCanvas::kNative_Unpremul_Config8888,
                 SkCanvas::kBGRA_Premul_Config8888,
                 SkCanvas::kBGRA_Unpremul_Config8888,
                 SkCanvas::kRGBA_Premul_Config8888,
                 SkCanvas::kRGBA_Unpremul_Config8888,
             };
@@ skipping 19 matching lines @@
                     }
                 }
             }
         }
     }
 }
 }
 
 #include "TestClassDef.h"
 DEFINE_GPUTESTCLASS("WritePixels", WritePixelsTestClass, WritePixelsTest)