AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Split SkDevice out of SkBitmapDevice

Browse Source 
https://codereview.chromium.org/22978012/



git-svn-id: http://skia.googlecode.com/svn/trunk@10830 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
robertphillips@google.com 2013-08-20 17:49:04 +00:00
parent 4eaa6647e7
commit 3055b70018
71 changed files with 713 additions and 474 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bench/BlurImageFilterBench.cpp
View File

@ -53,7 +53,7 @@ private:
const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
fCheckerboard.allocPixels();
SkDevice device(fCheckerboard);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint darkPaint;

2
bench/DeferredCanvasBench.cpp
View File

@ -26,7 +26,7 @@ protected:
}
virtual void onDraw(SkCanvas* canvas) {
SkDevice *device = canvas->getDevice()->createCompatibleDevice(
SkBaseDevice *device = canvas->getDevice()->createCompatibleDevice(
SkBitmap::kARGB_8888_Config, CANVAS_WIDTH, CANVAS_HEIGHT, false);
SkAutoTUnref<SkDeferredCanvas> deferredCanvas(SkDeferredCanvas::Create(device));

4
bench/DisplacementBench.cpp
View File

@ -35,7 +35,7 @@ protected:
const int h = isSmall() ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;
@ -51,7 +51,7 @@ protected:
const int h = isSmall() ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
fCheckerboard.allocPixels();
SkDevice device(fCheckerboard);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint darkPaint;

2
bench/MagnifierBench.cpp
View File

@ -52,7 +52,7 @@ private:
const int h = fIsSmall ? FILTER_HEIGHT_LARGE : FILTER_HEIGHT_LARGE;
fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, w, h);
fCheckerboard.allocPixels();
SkDevice device(fCheckerboard);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint darkPaint;

4
bench/MergeBench.cpp
View File

@ -53,7 +53,7 @@ private:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;
@ -67,7 +67,7 @@ private:
void make_checkerboard() {
fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fCheckerboard.allocPixels();
SkDevice device(fCheckerboard);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint darkPaint;

10
bench/benchmain.cpp
View File

@ -193,9 +193,9 @@ enum Backend {
kPDF_Backend,
};
static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
Backend backend, int sampleCount, GrContext* context) {
SkDevice* device = NULL;
static SkBaseDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
Backend backend, int sampleCount, GrContext* context) {
SkBaseDevice* device = NULL;
SkBitmap bitmap;
bitmap.setConfig(config, size.fX, size.fY);
@ -203,7 +203,7 @@ static SkDevice* make_device(SkBitmap::Config config, const SkIPoint& size,
case kRaster_Backend:
bitmap.allocPixels();
erase(bitmap);
device = SkNEW_ARGS(SkDevice, (bitmap));
device = SkNEW_ARGS(SkBitmapDevice, (bitmap));
break;
#if SK_SUPPORT_GPU
case kGPU_Backend: {
@ -776,7 +776,7 @@ int tool_main(int argc, char** argv) {
glContext = gContextFactory.getGLContext(gConfigs[configIndex].fContextType);
}
#endif
SkDevice* device = NULL;
SkBaseDevice* device = NULL;
SkCanvas* canvas = NULL;
SkPicture pictureRecordFrom;
SkPicture pictureRecordTo;

4
debugger/QT/SkRasterWidget.cpp
View File

@ -12,7 +12,7 @@ SkRasterWidget::SkRasterWidget(SkDebugger *debugger) : QWidget() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 800, 800);
fBitmap.allocPixels();
fBitmap.eraseColor(SK_ColorTRANSPARENT);
fDevice = new SkDevice(fBitmap);
fDevice = new SkBitmapDevice(fBitmap);
fDebugger = debugger;
fCanvas = new SkCanvas(fDevice);
this->setStyleSheet("QWidget {background-color: white; border: 1px solid #cccccc;}");
@ -29,7 +29,7 @@ void SkRasterWidget::resizeEvent(QResizeEvent* event) {
fBitmap.eraseColor(SK_ColorTRANSPARENT);
SkSafeUnref(fCanvas);
SkSafeUnref(fDevice);
fDevice = new SkDevice(fBitmap);
fDevice = new SkBitmapDevice(fBitmap);
fCanvas = new SkCanvas(fDevice);
fDebugger->resize(event->size().width(), event->size().height());
this->update();

2
debugger/QT/SkRasterWidget.h
View File

@ -44,7 +44,7 @@ private:
SkBitmap fBitmap;
SkDebugger* fDebugger;
SkCanvas* fCanvas;
SkDevice* fDevice;
SkBaseDevice* fDevice;
};
#endif /* SKRASTERWIDGET_H_ */

4
experimental/PdfViewer/SkNulCanvas.h
View File

@ -8,7 +8,7 @@ public:
SK_DECLARE_INST_COUNT(SkNulCanvas);
SkNulCanvas() {}
explicit SkNulCanvas(SkDevice* device) : SkCanvas(device) {}
explicit SkNulCanvas(SkBaseDevice* device) : SkCanvas(device) {}
explicit SkNulCanvas(const SkBitmap& bitmap) : SkCanvas(bitmap) {}
virtual ~SkNulCanvas() {}
@ -83,7 +83,7 @@ public:
protected:
virtual SkCanvas* canvasForDrawIter() {return NULL;}
virtual SkDevice* setDevice(SkDevice* device) {return NULL;}
virtual SkBaseDevice* setDevice(SkBaseDevice* device) {return NULL;}
private:
typedef SkCanvas INHERITED;

4
experimental/PdfViewer/SkPdfRenderer.cpp
View File

@ -242,7 +242,7 @@ static bool readToken(SkPdfNativeTokenizer* fTokenizer, PdfToken* token) {
memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSize());
SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (bitmap)));
SkCanvas canvas(device);
// draw context stuff here
@ -2641,7 +2641,7 @@ bool SkPDFNativeRenderToBitmap(SkStream* stream,
setup_bitmap(output, (int)SkScalarToDouble(width), (int)SkScalarToDouble(height));
SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (*output)));
SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*output)));
SkCanvas canvas(device);
return renderer.renderPage(page, &canvas, rect);

14
experimental/PdfViewer/SkTrackDevice.h
View File

@ -4,24 +4,24 @@
#include "SkDevice.h"
#include "SkTracker.h"
class SkTrackDevice : public SkDevice {
class SkTrackDevice : public SkBitmapDevice {
public:
SK_DECLARE_INST_COUNT(SkTrackDevice)
SkTrackDevice(const SkBitmap& bitmap) : SkDevice(bitmap)
SkTrackDevice(const SkBitmap& bitmap) : SkBitmapDevice(bitmap)
, fTracker(NULL) {}
SkTrackDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties)
: SkDevice(bitmap, deviceProperties)
: SkBitmapDevice(bitmap, deviceProperties)
, fTracker(NULL) {}
SkTrackDevice(SkBitmap::Config config, int width, int height, bool isOpaque = false)
: SkDevice(config, width, height, isOpaque)
: SkBitmapDevice(config, width, height, isOpaque)
, fTracker(NULL) {}
SkTrackDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
const SkDeviceProperties& deviceProperties)
: SkDevice(config, width, height, isOpaque, deviceProperties)
: SkBitmapDevice(config, width, height, isOpaque, deviceProperties)
, fTracker(NULL) {}
virtual ~SkTrackDevice() {}
@ -147,7 +147,7 @@ protected:
after();
}
virtual void drawDevice(const SkDraw& dummy1, SkDevice* dummy2, int x, int y,
virtual void drawDevice(const SkDraw& dummy1, SkBaseDevice* dummy2, int x, int y,
const SkPaint& dummy3) {
before();
INHERITED::drawDevice(dummy1, dummy2, x, y, dummy3);
@ -171,7 +171,7 @@ private:
private:
SkTracker* fTracker;
typedef SkDevice INHERITED;
typedef SkBitmapDevice INHERITED;
};
#endif // EXPERIMENTAL_PDFVIEWER_SKTRACKDEVICE_H_

6
experimental/PdfViewer/pdf_viewer_main.cpp
View File

@ -179,7 +179,7 @@ static bool render_page(const SkString& outputDir,
// Exercise all pdf codepaths as in normal rendering, but no actual bits are changed.
if (!FLAGS_config.isEmpty() && strcmp(FLAGS_config[0], "nul") == 0) {
SkBitmap bitmap;
SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap)));
SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (bitmap)));
SkNulCanvas canvas(device);
renderer.renderPage(page < 0 ? 0 : page, &canvas, rect);
} else {
@ -197,9 +197,9 @@ static bool render_page(const SkString& outputDir,
#else
setup_bitmap(&bitmap, (int)SkScalarToDouble(width), (int)SkScalarToDouble(height));
#endif
SkAutoTUnref<SkDevice> device;
SkAutoTUnref<SkBaseDevice> device;
if (strcmp(FLAGS_config[0], "8888") == 0) {
device.reset(SkNEW_ARGS(SkDevice, (bitmap)));
device.reset(SkNEW_ARGS(SkBitmapDevice, (bitmap)));
}
#if SK_SUPPORT_GPU
else if (strcmp(FLAGS_config[0], "gpu") == 0) {

2
experimental/SkiaExamples/SkExample.cpp
View File

@ -115,7 +115,7 @@ void SkExampleWindow::setupRenderTarget() {
SkCanvas* SkExampleWindow::createCanvas() {
if (fType == kGPU_DeviceType) {
if (NULL != fContext && NULL != fRenderTarget) {
SkAutoTUnref<SkDevice> device(new SkGpuDevice(fContext, fRenderTarget));
SkAutoTUnref<SkBaseDevice> device(new SkGpuDevice(fContext, fRenderTarget));
return new SkCanvas(device);
}
tearDownBackend();

4
experimental/iOSSampleApp/SkSampleUIView.mm
View File

@ -136,8 +136,8 @@ public:
case SampleWindow::kGPU_DeviceType:
case SampleWindow::kNullGPU_DeviceType:
if (fCurContext) {
SkAutoTUnref<SkDevice> device(new SkGpuDevice(fCurContext,
fCurRenderTarget));
SkAutoTUnref<SkBaseDevice> device(new SkGpuDevice(fCurContext,
fCurRenderTarget));
return new SkCanvas(device);
} else {
return NULL;

2
gm/bitmapcopy.cpp
View File

@ -66,7 +66,7 @@ protected:
SkScalar horizMargin(SkIntToScalar(10));
SkScalar vertMargin(SkIntToScalar(10));
SkDevice devTmp(SkBitmap::kARGB_8888_Config, 40, 40);
SkBitmapDevice devTmp(SkBitmap::kARGB_8888_Config, 40, 40, false);
SkCanvas canvasTmp(&devTmp);
draw_checks(&canvasTmp, 40, 40);

2
gm/deviceproperties.cpp
View File

@ -44,7 +44,7 @@ protected:
SkDeviceProperties::Geometry::Make(SkDeviceProperties::Geometry::kVertical_Orientation,
SkDeviceProperties::Geometry::kBGR_Layout),
SK_Scalar1);
SkDevice device(bitmap, properties);
SkBitmapDevice device(bitmap, properties);
SkCanvas canvas(&device);
canvas.drawColor(SK_ColorWHITE);

4
gm/displacement.cpp
View File

@ -25,7 +25,7 @@ protected:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;
@ -39,7 +39,7 @@ protected:
void make_checkerboard() {
fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fCheckerboard.allocPixels();
SkDevice device(fCheckerboard);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint darkPaint;

2
gm/extractbitmap.cpp
View File

@ -74,7 +74,7 @@ protected:
}
// Now do the same but with a device bitmap as source image
SkAutoTUnref<SkDevice> secondDevice(canvas->createCompatibleDevice(
SkAutoTUnref<SkBaseDevice> secondDevice(canvas->createCompatibleDevice(
SkBitmap::kARGB_8888_Config, bitmap.width(),
bitmap.height(), true));
SkCanvas secondCanvas(secondDevice.get());

4
gm/gmmain.cpp
View File

@ -517,7 +517,7 @@ public:
SkAutoTUnref<SkCanvas> canvas;
if (gRec.fBackend == kRaster_Backend) {
SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (*bitmap)));
SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*bitmap)));
if (deferred) {
canvas.reset(SkDeferredCanvas::Create(device));
} else {
@ -528,7 +528,7 @@ public:
}
#if SK_SUPPORT_GPU
else { // GPU
SkAutoTUnref<SkDevice> device(SkGpuDevice::Create(gpuTarget));
SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(gpuTarget));
if (deferred) {
canvas.reset(SkDeferredCanvas::Create(device));
} else {

2
gm/imagefiltersgraph.cpp
View File

@ -32,7 +32,7 @@ protected:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;

2
gm/lighting.cpp
View File

@ -27,7 +27,7 @@ protected:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;

2
gm/matrixconvolution.cpp
View File

@ -26,7 +26,7 @@ protected:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;

2
gm/morphology.cpp
View File

@ -28,7 +28,7 @@ protected:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 135, 135);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x0);
SkPaint paint;

4
gm/ninepatchstretch.cpp
View File

@ -14,7 +14,7 @@ class GrContext;
#endif
static void make_bitmap(SkBitmap* bitmap, GrContext* ctx, SkIRect* center) {
SkDevice* dev;
SkBaseDevice* dev;
const int kFixed = 28;
const int kStretchy = 8;
@ -29,7 +29,7 @@ static void make_bitmap(SkBitmap* bitmap, GrContext* ctx, SkIRect* center) {
{
bitmap->setConfig(SkBitmap::kARGB_8888_Config, kSize, kSize);
bitmap->allocPixels();
dev = new SkDevice(*bitmap);
dev = new SkBitmapDevice(*bitmap);
}
SkCanvas canvas(dev);

2
gm/srcmode.cpp
View File

@ -124,7 +124,7 @@ protected:
SkImage::kPremul_AlphaType
};
#if SK_SUPPORT_GPU
SkDevice* dev = canvas->getDevice();
SkBaseDevice* dev = canvas->getDevice();
if (!skipGPU && dev->accessRenderTarget()) {
SkGpuDevice* gd = (SkGpuDevice*)dev;
GrContext* ctx = gd->context();

2
gm/texdata.cpp
View File

@ -38,7 +38,7 @@ protected:
}
virtual void onDraw(SkCanvas* canvas) {
SkDevice* device = canvas->getTopDevice();
SkBaseDevice* device = canvas->getTopDevice();
GrRenderTarget* target = device->accessRenderTarget();
GrContext* ctx = GetGr();
if (ctx && target) {

4
gm/xfermodeimagefilter.cpp
View File

@ -31,7 +31,7 @@ protected:
void make_bitmap() {
fBitmap.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fBitmap.allocPixels();
SkDevice device(fBitmap);
SkBitmapDevice device(fBitmap);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint paint;
@ -45,7 +45,7 @@ protected:
void make_checkerboard() {
fCheckerboard.setConfig(SkBitmap::kARGB_8888_Config, 80, 80);
fCheckerboard.allocPixels();
SkDevice device(fCheckerboard);
SkBitmapDevice device(fCheckerboard);
SkCanvas canvas(&device);
canvas.clear(0x00000000);
SkPaint darkPaint;

2
gm/xfermodes3.cpp
View File

@ -132,7 +132,7 @@ private:
desc.fConfig = rt->config();
desc.fFlags = kRenderTarget_GrTextureFlagBit;
SkAutoTUnref<GrSurface> surface(context->createUncachedTexture(desc, NULL, 0));
SkAutoTUnref<SkDevice> device(SkGpuDevice::Create(surface.get()));
SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(surface.get()));
if (NULL != device.get()) {
tempCanvas = SkNEW_ARGS(SkCanvas, (device.get()));
}

26
include/core/SkCanvas.h
View File

@ -22,7 +22,7 @@
#include "SkXfermode.h"
class SkBounder;
class SkDevice;
class SkBaseDevice;
class SkDraw;
class SkDrawFilter;
class SkMetaData;
@ -55,7 +55,7 @@ public:
@param device Specifies a device for the canvas to draw into.
*/
explicit SkCanvas(SkDevice* device);
explicit SkCanvas(SkBaseDevice* device);
/** Deprecated - Construct a canvas with the specified bitmap to draw into.
@param bitmap Specifies a bitmap for the canvas to draw into. Its
@ -84,7 +84,7 @@ public:
the bitmap of the pixels that the canvas draws into. The reference count
of the returned device is not changed by this call.
*/
SkDevice* getDevice() const;
SkBaseDevice* getDevice() const;
/**
* saveLayer() can create another device (which is later drawn onto
@ -99,15 +99,15 @@ public:
* is drawn to, but is optional here, as there is a small perf hit
* sometimes.
*/
SkDevice* getTopDevice(bool updateMatrixClip = false) const;
SkBaseDevice* getTopDevice(bool updateMatrixClip = false) const;
/**
* Shortcut for getDevice()->createCompatibleDevice(...).
* If getDevice() == NULL, this method does nothing, and returns NULL.
*/
SkDevice* createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque);
SkBaseDevice* createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque);
///////////////////////////////////////////////////////////////////////////
@ -994,7 +994,7 @@ public:
// These reflect the current device in the iterator
SkDevice* device() const;
SkBaseDevice* device() const;
const SkMatrix& matrix() const;
const SkRegion& clip() const;
const SkPaint& paint() const;
@ -1043,7 +1043,7 @@ protected:
reference count is incremented. If the canvas was already holding a
device, its reference count is decremented. The new device is returned.
*/
virtual SkDevice* setDevice(SkDevice* device);
virtual SkBaseDevice* setDevice(SkBaseDevice* device);
private:
class MCRec;
@ -1074,10 +1074,10 @@ private:
friend class SkDrawIter; // needs setupDrawForLayerDevice()
friend class AutoDrawLooper;
SkDevice* createLayerDevice(SkBitmap::Config, int width, int height,
bool isOpaque);
SkBaseDevice* createLayerDevice(SkBitmap::Config, int width, int height,
bool isOpaque);
SkDevice* init(SkDevice*);
SkBaseDevice* init(SkBaseDevice*);
// internal methods are not virtual, so they can safely be called by other
// canvas apis, without confusing subclasses (like SkPictureRecording)
@ -1090,7 +1090,7 @@ private:
void internalDrawPaint(const SkPaint& paint);
int internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
SaveFlags, bool justForImageFilter);
void internalDrawDevice(SkDevice*, int x, int y, const SkPaint*);
void internalDrawDevice(SkBaseDevice*, int x, int y, const SkPaint*);
// shared by save() and saveLayer()
int internalSave(SaveFlags flags);

451
include/core/SkDevice.h
View File

@ -25,57 +25,21 @@ class SkRegion;
class GrRenderTarget;
class SK_API SkDevice : public SkRefCnt {
class SK_API SkBaseDevice : public SkRefCnt {
public:
SK_DECLARE_INST_COUNT(SkDevice)
SK_DECLARE_INST_COUNT(SkBaseDevice)
/**
* Construct a new device with the specified bitmap as its backend. It is
* valid for the bitmap to have no pixels associated with it. In that case,
* any drawing to this device will have no effect.
* Construct a new device.
*/
SkDevice(const SkBitmap& bitmap);
SkBaseDevice();
/**
* Construct a new device with the specified bitmap as its backend. It is
* valid for the bitmap to have no pixels associated with it. In that case,
* any drawing to this device will have no effect.
* Construct a new device.
*/
SkDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties);
SkBaseDevice(const SkDeviceProperties& deviceProperties);
/**
* Create a new raster device and have the pixels be automatically
* allocated. The rowBytes of the device will be computed automatically
* based on the config and the width.
*
* @param config The desired config for the pixels. If the request cannot
* be met, the closest matching support config will be used.
* @param width width (in pixels) of the device
* @param height height (in pixels) of the device
* @param isOpaque Set to true if it is known that all of the pixels will
* be drawn to opaquely. Used as an accelerator when drawing
* these pixels to another device.
*/
SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque = false);
/**
* Create a new raster device and have the pixels be automatically
* allocated. The rowBytes of the device will be computed automatically
* based on the config and the width.
*
* @param config The desired config for the pixels. If the request cannot
* be met, the closest matching support config will be used.
* @param width width (in pixels) of the device
* @param height height (in pixels) of the device
* @param isOpaque Set to true if it is known that all of the pixels will
* be drawn to opaquely. Used as an accelerator when drawing
* these pixels to another device.
* @param deviceProperties Properties which affect compositing.
*/
SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
const SkDeviceProperties& deviceProperties);
virtual ~SkDevice();
virtual ~SkBaseDevice();
/**
* Creates a device that is of the same type as this device (e.g. SW-raster,
@ -88,9 +52,9 @@ public:
* draw into this device such that all of the pixels will
* be opaque.
*/
SkDevice* createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque);
SkBaseDevice* createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque);
SkMetaData& getMetaData();
@ -99,14 +63,14 @@ public:
kVector_Capability = 0x2, //!< mask indicating a vector representation
kAll_Capabilities = 0x3
};
virtual uint32_t getDeviceCapabilities() { return 0; }
virtual uint32_t getDeviceCapabilities() = 0;
/** Return the width of the device (in pixels).
*/
virtual int width() const { return fBitmap.width(); }
virtual int width() const = 0;
/** Return the height of the device (in pixels).
*/
virtual int height() const { return fBitmap.height(); }
virtual int height() const = 0;
/** Return the image properties of the device. */
virtual const SkDeviceProperties& getDeviceProperties() const {
@ -119,16 +83,12 @@ public:
* canvas. The root device will have its top-left at 0,0, but other devices
* such as those associated with saveLayer may have a non-zero origin.
*/
void getGlobalBounds(SkIRect* bounds) const;
virtual void getGlobalBounds(SkIRect* bounds) const = 0;
/** Returns true if the device's bitmap's config treats every pixels as
implicitly opaque.
*/
bool isOpaque() const { return fBitmap.isOpaque(); }
/** Return the bitmap config of the device's pixels
*/
SkBitmap::Config config() const { return fBitmap.getConfig(); }
virtual bool isOpaque() const = 0;
/** Return the bitmap associated with this device. Call this each time you need
to access the bitmap, as it notifies the subclass to perform any flushing
@ -154,12 +114,12 @@ public:
* not kARGB_8888_Config then this parameter is ignored.
*/
virtual void writePixels(const SkBitmap& bitmap, int x, int y,
SkCanvas::Config8888 config8888 = SkCanvas::kNative_Premul_Config8888);
SkCanvas::Config8888 config8888 = SkCanvas::kNative_Premul_Config8888) = 0;
/**
* Return the device's associated gpu render target, or NULL.
*/
virtual GrRenderTarget* accessRenderTarget() { return NULL; }
virtual GrRenderTarget* accessRenderTarget() = 0;
/**
@ -171,7 +131,7 @@ public:
/**
* onAttachToCanvas is invoked whenever a device is installed in a canvas
* (i.e., setDevice, saveLayer (for the new device created by the save),
* and SkCanvas' SkDevice & SkBitmap -taking ctors). It allows the
* and SkCanvas' SkBaseDevice & SkBitmap -taking ctors). It allows the
* devices to prepare for drawing (e.g., locking their pixels, etc.)
*/
virtual void onAttachToCanvas(SkCanvas*) {
@ -213,9 +173,9 @@ protected:
* textflags parameter (output) and return true. If the paint is fine as
* is, then ignore the textflags parameter and return false.
*
* The baseclass SkDevice filters based on its depth and blitters.
* The baseclass SkBaseDevice filters based on its depth and blitters.
*/
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*);
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) = 0;
/**
*
@ -234,12 +194,12 @@ protected:
* passed in).
*/
virtual void setMatrixClip(const SkMatrix&, const SkRegion&,
const SkClipStack&);
const SkClipStack&) {};
/** Clears the entire device to the specified color (including alpha).
* Ignores the clip.
*/
virtual void clear(SkColor color);
virtual void clear(SkColor color) = 0;
/**
* Deprecated name for clear.
@ -251,15 +211,15 @@ protected:
and are handling any looping from the paint, and any effects from the
DrawFilter.
*/
virtual void drawPaint(const SkDraw&, const SkPaint& paint);
virtual void drawPaint(const SkDraw&, const SkPaint& paint) = 0;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
const SkPoint[], const SkPaint& paint);
const SkPoint[], const SkPaint& paint) = 0;
virtual void drawRect(const SkDraw&, const SkRect& r,
const SkPaint& paint);
const SkPaint& paint) = 0;
virtual void drawOval(const SkDraw&, const SkRect& oval,
const SkPaint& paint);
const SkPaint& paint) = 0;
virtual void drawRRect(const SkDraw&, const SkRRect& rr,
const SkPaint& paint);
const SkPaint& paint) = 0;
/**
* If pathIsMutable, then the implementation is allowed to cast path to a
@ -275,11 +235,11 @@ protected:
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint,
const SkMatrix* prePathMatrix = NULL,
bool pathIsMutable = false);
bool pathIsMutable = false) = 0;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
const SkMatrix& matrix, const SkPaint& paint);
const SkMatrix& matrix, const SkPaint& paint) = 0;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint);
int x, int y, const SkPaint& paint) = 0;
/**
* The default impl. will create a bitmap-shader from the bitmap,
@ -288,35 +248,35 @@ protected:
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
SkCanvas::DrawBitmapRectFlags flags);
SkCanvas::DrawBitmapRectFlags flags) = 0;
/**
* Does not handle text decoration.
* Decorations (underline and stike-thru) will be handled by SkCanvas.
*/
virtual void drawText(const SkDraw&, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint& paint);
SkScalar x, SkScalar y, const SkPaint& paint) = 0;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], SkScalar constY,
int scalarsPerPos, const SkPaint& paint);
int scalarsPerPos, const SkPaint& paint) = 0;
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
const SkPaint& paint);
const SkPaint& paint) = 0;
#ifdef SK_BUILD_FOR_ANDROID
virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
const SkPoint pos[], const SkPaint& paint,
const SkPath& path, const SkMatrix* matrix);
const SkPath& path, const SkMatrix* matrix) = 0;
#endif
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint);
/** The SkDevice passed will be an SkDevice which was returned by a call to
const SkPaint& paint) = 0;
/** The SkBaseDevice passed will be an SkBaseDevice which was returned by a call to
onCreateCompatibleDevice on this device with kSaveLayer_Usage.
*/
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
const SkPaint&);
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) = 0;
/**
* On success (returns true), copy the device pixels into the bitmap.
@ -352,20 +312,10 @@ protected:
///////////////////////////////////////////////////////////////////////////
/** Update as needed the pixel value in the bitmap, so that the caller can
access the pixels directly. Note: only the pixels field should be
altered. The config/width/height/rowbytes must remain unchanged.
@param bitmap The device's bitmap
@return Echo the bitmap parameter, or an alternate (shadow) bitmap
maintained by the subclass.
access the pixels directly.
@return The device contents as a bitmap
*/
virtual const SkBitmap& onAccessBitmap(SkBitmap*);
SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
// just for subclasses, to assign a custom pixelref
SkPixelRef* setPixelRef(SkPixelRef* pr, size_t offset) {
fBitmap.setPixelRef(pr, offset);
return pr;
}
virtual const SkBitmap& onAccessBitmap() = 0;
/**
* Implements readPixels API. The caller will ensure that:
@ -376,13 +326,13 @@ protected:
*/
virtual bool onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888);
SkCanvas::Config8888 config8888) = 0;
/** Called when this device is installed into a Canvas. Balanaced by a call
to unlockPixels() when the device is removed from a Canvas.
*/
virtual void lockPixels();
virtual void unlockPixels();
virtual void lockPixels() = 0;
virtual void unlockPixels() = 0;
/**
* Returns true if the device allows processing of this imagefilter. If
@ -390,7 +340,7 @@ protected:
* some subclasses that do not support pixel manipulations after drawing
* has occurred (e.g. printing). The default implementation returns true.
*/
virtual bool allowImageFilter(SkImageFilter*);
virtual bool allowImageFilter(SkImageFilter*) = 0;
/**
* Override and return true for filters that the device can handle
@ -399,7 +349,7 @@ protected:
* Returning false means the SkCanvas will have apply the filter itself,
* and just pass the resulting image to the device.
*/
virtual bool canHandleImageFilter(SkImageFilter*);
virtual bool canHandleImageFilter(SkImageFilter*) = 0;
/**
* Related (but not required) to canHandleImageFilter, this method returns
@ -409,7 +359,7 @@ protected:
* it just returns false and leaves result and offset unchanged.
*/
virtual bool filterImage(SkImageFilter*, const SkBitmap&, const SkMatrix&,
SkBitmap* result, SkIPoint* offset);
SkBitmap* result, SkIPoint* offset) = 0;
// This is equal kBGRA_Premul_Config8888 or kRGBA_Premul_Config8888 if
// either is identical to kNative_Premul_Config8888. Otherwise, -1.
@ -424,31 +374,31 @@ private:
friend class SkDeviceImageFilterProxy;
friend class SkSurface_Raster;
// used to change the backend's pixels (and possibly config/rowbytes)
// but cannot change the width/height, so there should be no change to
// any clip information.
void replaceBitmapBackendForRasterSurface(const SkBitmap&);
virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) = 0;
// just called by SkCanvas when built as a layer
void setOrigin(int x, int y) { fOrigin.set(x, y); }
// just called by SkCanvas for saveLayer
SkDevice* createCompatibleDeviceForSaveLayer(SkBitmap::Config config,
int width, int height,
bool isOpaque);
SkBaseDevice* createCompatibleDeviceForSaveLayer(SkBitmap::Config config,
int width, int height,
bool isOpaque);
/**
* Subclasses should override this to implement createCompatibleDevice.
*/
virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage);
virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) = 0;
/** Causes any deferred drawing to the device to be completed.
*/
virtual void flush() {}
virtual void flush() = 0;
SkBitmap fBitmap;
SkIPoint fOrigin;
SkMetaData* fMetaData;
/**
@ -466,4 +416,289 @@ private:
typedef SkRefCnt INHERITED;
};
///////////////////////////////////////////////////////////////////////////////
class SK_API SkBitmapDevice : public SkBaseDevice {
public:
SK_DECLARE_INST_COUNT(SkBitmapDevice)
/**
* Construct a new device with the specified bitmap as its backend. It is
* valid for the bitmap to have no pixels associated with it. In that case,
* any drawing to this device will have no effect.
*/
SkBitmapDevice(const SkBitmap& bitmap);
/**
* Construct a new device with the specified bitmap as its backend. It is
* valid for the bitmap to have no pixels associated with it. In that case,
* any drawing to this device will have no effect.
*/
SkBitmapDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties);
/**
* Create a new raster device and have the pixels be automatically
* allocated. The rowBytes of the device will be computed automatically
* based on the config and the width.
*
* @param config The desired config for the pixels. If the request cannot
* be met, the closest matching support config will be used.
* @param width width (in pixels) of the device
* @param height height (in pixels) of the device
* @param isOpaque Set to true if it is known that all of the pixels will
* be drawn to opaquely. Used as an accelerator when drawing
* these pixels to another device.
*/
SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque);
/**
* Create a new raster device and have the pixels be automatically
* allocated. The rowBytes of the device will be computed automatically
* based on the config and the width.
*
* @param config The desired config for the pixels. If the request cannot
* be met, the closest matching support config will be used.
* @param width width (in pixels) of the device
* @param height height (in pixels) of the device
* @param isOpaque Set to true if it is known that all of the pixels will
* be drawn to opaquely. Used as an accelerator when drawing
* these pixels to another device.
* @param deviceProperties Properties which affect compositing.
*/
SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
const SkDeviceProperties& deviceProperties);
virtual ~SkBitmapDevice();
virtual uint32_t getDeviceCapabilities() SK_OVERRIDE { return 0; }
/** Return the width of the device (in pixels).
*/
virtual int width() const SK_OVERRIDE { return fBitmap.width(); }
/** Return the height of the device (in pixels).
*/
virtual int height() const SK_OVERRIDE { return fBitmap.height(); }
/**
* Return the bounds of the device in the coordinate space of the root
* canvas. The root device will have its top-left at 0,0, but other devices
* such as those associated with saveLayer may have a non-zero origin.
*/
virtual void getGlobalBounds(SkIRect* bounds) const SK_OVERRIDE;
/** Returns true if the device's bitmap's config treats every pixels as
implicitly opaque.
*/
virtual bool isOpaque() const SK_OVERRIDE { return fBitmap.isOpaque(); }
/** Return the bitmap config of the device's pixels
*/
virtual SkBitmap::Config config() const { return fBitmap.getConfig(); }
/**
* DEPRECATED: This will be made protected once WebKit stops using it.
* Instead use Canvas' writePixels method.
*
* Similar to draw sprite, this method will copy the pixels in bitmap onto
* the device, with the top/left corner specified by (x, y). The pixel
* values in the device are completely replaced: there is no blending.
*
* Currently if bitmap is backed by a texture this is a no-op. This may be
* relaxed in the future.
*
* If the bitmap has config kARGB_8888_Config then the config8888 param
* will determines how the pixel valuess are intepreted. If the bitmap is
* not kARGB_8888_Config then this parameter is ignored.
*/
virtual void writePixels(const SkBitmap& bitmap, int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
/**
* Return the device's associated gpu render target, or NULL.
*/
virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE { return NULL; }
protected:
/**
* Device may filter the text flags for drawing text here. If it wants to
* make a change to the specified values, it should write them into the
* textflags parameter (output) and return true. If the paint is fine as
* is, then ignore the textflags parameter and return false.
*
* The baseclass SkDevice filters based on its depth and blitters.
*/
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE;
/** Clears the entire device to the specified color (including alpha).
* Ignores the clip.
*/
virtual void clear(SkColor color) SK_OVERRIDE;
/** These are called inside the per-device-layer loop for each draw call.
When these are called, we have already applied any saveLayer operations,
and are handling any looping from the paint, and any effects from the
DrawFilter.
*/
virtual void drawPaint(const SkDraw&, const SkPaint& paint) SK_OVERRIDE;
virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
const SkPoint[], const SkPaint& paint) SK_OVERRIDE;
virtual void drawRect(const SkDraw&, const SkRect& r,
const SkPaint& paint) SK_OVERRIDE;
virtual void drawOval(const SkDraw&, const SkRect& oval,
const SkPaint& paint) SK_OVERRIDE;
virtual void drawRRect(const SkDraw&, const SkRRect& rr,
const SkPaint& paint) SK_OVERRIDE;
/**
* If pathIsMutable, then the implementation is allowed to cast path to a
* non-const pointer and modify it in place (as an optimization). Canvas
* may do this to implement helpers such as drawOval, by placing a temp
* path on the stack to hold the representation of the oval.
*
* If prePathMatrix is not null, it should logically be applied before any
* stroking or other effects. If there are no effects on the paint that
* affect the geometry/rasterization, then the pre matrix can just be
* pre-concated with the current matrix.
*/
virtual void drawPath(const SkDraw&, const SkPath& path,
const SkPaint& paint,
const SkMatrix* prePathMatrix = NULL,
bool pathIsMutable = false) SK_OVERRIDE;
virtual void drawBitmap(const SkDraw&, const SkBitmap& bitmap,
const SkMatrix& matrix, const SkPaint& paint) SK_OVERRIDE;
virtual void drawSprite(const SkDraw&, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint) SK_OVERRIDE;
/**
* The default impl. will create a bitmap-shader from the bitmap,
* and call drawRect with it.
*/
virtual void drawBitmapRect(const SkDraw&, const SkBitmap&,
const SkRect* srcOrNull, const SkRect& dst,
const SkPaint& paint,
SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE;
/**
* Does not handle text decoration.
* Decorations (underline and stike-thru) will be handled by SkCanvas.
*/
virtual void drawText(const SkDraw&, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint& paint) SK_OVERRIDE;
virtual void drawPosText(const SkDraw&, const void* text, size_t len,
const SkScalar pos[], SkScalar constY,
int scalarsPerPos, const SkPaint& paint) SK_OVERRIDE;
virtual void drawTextOnPath(const SkDraw&, const void* text, size_t len,
const SkPath& path, const SkMatrix* matrix,
const SkPaint& paint) SK_OVERRIDE;
#ifdef SK_BUILD_FOR_ANDROID
virtual void drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
const SkPoint pos[], const SkPaint& paint,
const SkPath& path, const SkMatrix* matrix) SK_OVERRIDE;
#endif
virtual void drawVertices(const SkDraw&, SkCanvas::VertexMode, int vertexCount,
const SkPoint verts[], const SkPoint texs[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) SK_OVERRIDE;
/** The SkBaseDevice passed will be an SkBaseDevice which was returned by a call to
onCreateCompatibleDevice on this device with kSaveLayer_Usage.
*/
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) SK_OVERRIDE;
///////////////////////////////////////////////////////////////////////////
/** Update as needed the pixel value in the bitmap, so that the caller can
access the pixels directly. Note: only the pixels field should be
altered. The config/width/height/rowbytes must remain unchanged.
@return the device contents as a bitmap
*/
virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE;
SkPixelRef* getPixelRef() const { return fBitmap.pixelRef(); }
// just for subclasses, to assign a custom pixelref
SkPixelRef* setPixelRef(SkPixelRef* pr, size_t offset) {
fBitmap.setPixelRef(pr, offset);
return pr;
}
/**
* Implements readPixels API. The caller will ensure that:
* 1. bitmap has pixel config kARGB_8888_Config.
* 2. bitmap has pixels.
* 3. The rectangle (x, y, x + bitmap->width(), y + bitmap->height()) is
* contained in the device bounds.
*/
virtual bool onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
/** Called when this device is installed into a Canvas. Balanced by a call
to unlockPixels() when the device is removed from a Canvas.
*/
virtual void lockPixels() SK_OVERRIDE;
virtual void unlockPixels() SK_OVERRIDE;
/**
* Returns true if the device allows processing of this imagefilter. If
* false is returned, then the filter is ignored. This may happen for
* some subclasses that do not support pixel manipulations after drawing
* has occurred (e.g. printing). The default implementation returns true.
*/
virtual bool allowImageFilter(SkImageFilter*) SK_OVERRIDE;
/**
* Override and return true for filters that the device can handle
* intrinsically. Doing so means that SkCanvas will pass-through this
* filter to drawSprite and drawDevice (and potentially filterImage).
* Returning false means the SkCanvas will have apply the filter itself,
* and just pass the resulting image to the device.
*/
virtual bool canHandleImageFilter(SkImageFilter*) SK_OVERRIDE;
/**
* Related (but not required) to canHandleImageFilter, this method returns
* true if the device could apply the filter to the src bitmap and return
* the result (and updates offset as needed).
* If the device does not recognize or support this filter,
* it just returns false and leaves result and offset unchanged.
*/
virtual bool filterImage(SkImageFilter*, const SkBitmap&, const SkMatrix&,
SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
private:
friend class SkCanvas;
friend struct DeviceCM; //for setMatrixClip
friend class SkDraw;
friend class SkDrawIter;
friend class SkDeviceFilteredPaint;
friend class SkDeviceImageFilterProxy;
friend class SkSurface_Raster;
// used to change the backend's pixels (and possibly config/rowbytes)
// but cannot change the width/height, so there should be no change to
// any clip information.
virtual void replaceBitmapBackendForRasterSurface(const SkBitmap&) SK_OVERRIDE;
/**
* Subclasses should override this to implement createCompatibleDevice.
*/
virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
/** Causes any deferred drawing to the device to be completed.
*/
virtual void flush() SK_OVERRIDE {}
SkBitmap fBitmap;
typedef SkBaseDevice INHERITED;
};
// Temporary typedef until Chromium (and other clients) are able to move to
// SkBaseDevice or SkBitmapDevice
typedef SkBitmapDevice SkDevice;
#endif

4
include/core/SkDraw.h
View File

@ -17,7 +17,7 @@
class SkBitmap;
class SkBounder;
class SkClipStack;
class SkDevice;
class SkBaseDevice;
class SkMatrix;
class SkPath;
class SkRegion;
@ -127,7 +127,7 @@ public:
const SkRasterClip* fRC; // required
const SkClipStack* fClipStack; // optional
SkDevice* fDevice; // optional
SkBaseDevice* fDevice; // optional
SkBounder* fBounder; // optional
SkDrawProcs* fProcs; // optional

4
include/core/SkImageFilter.h
View File

@ -13,7 +13,7 @@
class SkBitmap;
class SkColorFilter;
class SkDevice;
class SkBaseDevice;
class SkMatrix;
struct SkIPoint;
class SkShader;
@ -35,7 +35,7 @@ public:
public:
virtual ~Proxy() {};
virtual SkDevice* createDevice(int width, int height) = 0;
virtual SkBaseDevice* createDevice(int width, int height) = 0;
// returns true if the proxy can handle this filter natively
virtual bool canHandleImageFilter(SkImageFilter*) = 0;
// returns true if the proxy handled the filter itself. if this returns

2
include/core/SkRRect.h
View File

@ -25,7 +25,7 @@ class SkPath;
// use growToInclude to fit skp round rects & generate stats (RRs vs. real paths)
// check on # of rectorus's the RRs could handle
// rendering work
// add entry points (clipRRect, drawRRect) - plumb down to SkDevice
// add entry points (clipRRect, drawRRect) - plumb down to SkBaseDevice
// update SkPath.addRRect() to take an SkRRect - only use quads
// -- alternatively add addRRectToPath here
// add GM and bench

17
include/device/xps/SkXPSDevice.h
View File

@ -30,7 +30,7 @@
The drawing context for the XPS backend.
*/
class SkXPSDevice : public SkDevice {
class SkXPSDevice : public SkBitmapDevice {
public:
SK_API SkXPSDevice();
SK_API virtual ~SkXPSDevice();
@ -134,7 +134,7 @@ protected:
virtual void drawDevice(
const SkDraw&,
SkDevice* device,
SkBaseDevice* device,
int x, int y,
const SkPaint& paint) SK_OVERRIDE;
@ -307,18 +307,17 @@ private:
const SkVector& ppuScale,
IXpsOMPath* shadedPath);
// override from SkDevice
virtual SkDevice* onCreateCompatibleDevice(
SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
// override from SkBaseDevice
virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
// Disable the default copy and assign implementation.
SkXPSDevice(const SkXPSDevice&);
void operator=(const SkXPSDevice&);
typedef SkDevice INHERITED;
typedef SkBitmapDevice INHERITED;
};
#endif

24
include/gpu/SkGpuDevice.h
View File

@ -22,10 +22,10 @@ struct GrSkDrawProcs;
class GrTextContext;
/**
* Subclass of SkDevice, which directs all drawing to the GrGpu owned by the
* Subclass of SkBitmapDevice, which directs all drawing to the GrGpu owned by the
* canvas.
*/
class SK_API SkGpuDevice : public SkDevice {
class SK_API SkGpuDevice : public SkBitmapDevice {
public:
/**
@ -62,7 +62,7 @@ public:
virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
// overrides from SkDevice
// overrides from SkBaseDevice
virtual void clear(SkColor color) SK_OVERRIDE;
virtual void writePixels(const SkBitmap& bitmap, int x, int y,
@ -101,11 +101,11 @@ public:
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint&) SK_OVERRIDE;
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) SK_OVERRIDE;
virtual bool filterTextFlags(const SkPaint&, TextFlags*) SK_OVERRIDE;
virtual void flush();
virtual void flush() SK_OVERRIDE;
virtual void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
virtual void onDetachFromCanvas() SK_OVERRIDE;
@ -123,7 +123,7 @@ public:
class SkAutoCachedTexture; // used internally
protected:
// overrides from SkDevice
// overrides from SkBaseDevice
virtual bool onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
@ -145,11 +145,11 @@ private:
// used by createCompatibleDevice
SkGpuDevice(GrContext*, GrTexture* texture, bool needClear);
// override from SkDevice
virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
// override from SkBaseDevice
virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
SkDrawProcs* initDrawForText(GrTextContext*);
@ -192,7 +192,7 @@ private:
*/
GrTextContext* getTextContext();
typedef SkDevice INHERITED;
typedef SkBitmapDevice INHERITED;
};
#endif

16
include/pdf/SkPDFDevice.h
View File

@ -44,7 +44,7 @@ typedef bool (*EncodeToDCTStream)(SkWStream* stream, const SkBitmap& bitmap, con
The drawing context for the PDF backend.
*/
class SkPDFDevice : public SkDevice {
class SkPDFDevice : public SkBitmapDevice {
public:
/** Create a PDF drawing context with the given width and height.
* 72 points/in means letter paper is 612x792.
@ -107,7 +107,7 @@ public:
const SkPoint texs[], const SkColor colors[],
SkXfermode* xmode, const uint16_t indices[],
int indexCount, const SkPaint& paint) SK_OVERRIDE;
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) SK_OVERRIDE;
virtual void onAttachToCanvas(SkCanvas* canvas) SK_OVERRIDE;
@ -237,11 +237,11 @@ private:
SkPDFDevice(const SkISize& layerSize, const SkClipStack& existingClipStack,
const SkRegion& existingClipRegion);
// override from SkDevice
virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
// override from SkBaseDevice
virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
void init();
void cleanUp(bool clearFontUsage);
@ -310,7 +310,7 @@ private:
void defineNamedDestination(SkData* nameData, const SkPoint& point,
const SkMatrix& matrix);
typedef SkDevice INHERITED;
typedef SkBitmapDevice INHERITED;
};
#endif

2
include/utils/SkDeferredCanvas.h
View File

@ -33,7 +33,7 @@ public:
*/
static SkDeferredCanvas* Create(SkSurface* surface);
static SkDeferredCanvas* Create(SkDevice* device);
static SkDeferredCanvas* Create(SkBaseDevice* device);
virtual ~SkDeferredCanvas();

4
samplecode/SampleApp.cpp
View File

@ -269,7 +269,7 @@ public:
SampleWindow* win) {
#if SK_SUPPORT_GPU
if (IsGpuDeviceType(dType) && NULL != fCurContext) {
SkAutoTUnref<SkDevice> device(new SkGpuDevice(fCurContext, fCurRenderTarget));
SkAutoTUnref<SkBaseDevice> device(new SkGpuDevice(fCurContext, fCurRenderTarget));
return new SkCanvas(device);
} else
#endif
@ -1429,7 +1429,7 @@ void SampleWindow::afterChildren(SkCanvas* orig) {
if (fRequestGrabImage) {
fRequestGrabImage = false;
SkDevice* device = orig->getDevice();
SkBaseDevice* device = orig->getDevice();
SkBitmap bmp;
if (device->accessBitmap(false).copyTo(&bmp, SkBitmap::kARGB_8888_Config)) {
static int gSampleGrabCounter;

2
samplecode/SampleApp.h
View File

@ -61,7 +61,7 @@ public:
/**
* SampleApp ports can subclass this manager class if they want to:
* * filter the types of devices supported
* * customize plugging of SkDevice objects into an SkCanvas
* * customize plugging of SkBaseDevice objects into an SkCanvas
* * customize publishing the results of draw to the OS window
* * manage GrContext / GrRenderTarget lifetimes
*/

2
samplecode/SampleCircle.cpp
View File

@ -74,7 +74,7 @@ protected:
}
static void blowup(SkCanvas* canvas, const SkIRect& src, const SkRect& dst) {
SkDevice* device = canvas->getDevice();
SkBaseDevice* device = canvas->getDevice();
const SkBitmap& bm = device->accessBitmap(false);
canvas->drawBitmapRect(bm, &src, dst, NULL);
}

2
samplecode/SampleTextureDomain.cpp
View File

@ -61,7 +61,7 @@ protected:
// the constrainted texture domain.
// Note: GPU-backed bitmaps follow a different rendering path
// when copying from one GPU device to another.
SkAutoTUnref<SkDevice> secondDevice(canvas->createCompatibleDevice(
SkAutoTUnref<SkBaseDevice> secondDevice(canvas->createCompatibleDevice(
SkBitmap::kARGB_8888_Config, 5, 5, true));
SkCanvas secondCanvas(secondDevice.get());

2
src/core/SkBBoxHierarchyRecord.cpp
View File

@ -11,7 +11,7 @@
SkBBoxHierarchyRecord::SkBBoxHierarchyRecord(uint32_t recordFlags,
SkBBoxHierarchy* h,
SkDevice* device)
SkBaseDevice* device)
: INHERITED(recordFlags, device) {
fStateTree = SkNEW(SkPictureStateTree);
fBoundingHierarchy = h;

2
src/core/SkBBoxHierarchyRecord.h
View File

@ -20,7 +20,7 @@ class SkBBoxHierarchyRecord : public SkBBoxRecord, public SkBBoxHierarchyClient
public:
/** This will take a ref of h */
SkBBoxHierarchyRecord(uint32_t recordFlags, SkBBoxHierarchy* h,
SkDevice*);
SkBaseDevice*);
virtual void handleBBox(const SkRect& bounds) SK_OVERRIDE;

2
src/core/SkBBoxRecord.h
View File

@ -19,7 +19,7 @@
class SkBBoxRecord : public SkPictureRecord {
public:
SkBBoxRecord(uint32_t recordFlags, SkDevice* device)
SkBBoxRecord(uint32_t recordFlags, SkBaseDevice* device)
: INHERITED(recordFlags, device) { }
virtual ~SkBBoxRecord() { }

58
src/core/SkCanvas.cpp
View File

@ -129,7 +129,7 @@ void SkCanvas::predrawNotify() {
///////////////////////////////////////////////////////////////////////////////
/* This is the record we keep for each SkDevice that the user installs.
/* This is the record we keep for each SkBaseDevice that the user installs.
The clip/matrix/proc are fields that reflect the top of the save/restore
stack. Whenever the canvas changes, it marks a dirty flag, and then before
these are used (assuming we're not on a layer) we rebuild these cache
@ -138,12 +138,12 @@ void SkCanvas::predrawNotify() {
*/
struct DeviceCM {
DeviceCM* fNext;
SkDevice* fDevice;
SkBaseDevice* fDevice;
SkRasterClip fClip;
const SkMatrix* fMatrix;
SkPaint* fPaint; // may be null (in the future)
DeviceCM(SkDevice* device, int x, int y, const SkPaint* paint, SkCanvas* canvas)
DeviceCM(SkBaseDevice* device, int x, int y, const SkPaint* paint, SkCanvas* canvas)
: fNext(NULL) {
if (NULL != device) {
device->ref();
@ -315,7 +315,7 @@ public:
return false;
}
SkDevice* getDevice() const { return fDevice; }
SkBaseDevice* getDevice() const { return fDevice; }
int getX() const { return fDevice->getOrigin().x(); }
int getY() const { return fDevice->getOrigin().y(); }
const SkMatrix& getMatrix() const { return *fMatrix; }
@ -482,7 +482,7 @@ private:
////////////////////////////////////////////////////////////////////////////
SkDevice* SkCanvas::init(SkDevice* device) {
SkBaseDevice* SkCanvas::init(SkBaseDevice* device) {
fBounder = NULL;
fLocalBoundsCompareType.setEmpty();
fLocalBoundsCompareTypeDirty = true;
@ -511,7 +511,7 @@ SkCanvas::SkCanvas()
this->init(NULL);
}
SkCanvas::SkCanvas(SkDevice* device)
SkCanvas::SkCanvas(SkBaseDevice* device)
: fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
inc_canvas();
@ -522,7 +522,7 @@ SkCanvas::SkCanvas(const SkBitmap& bitmap)
: fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
inc_canvas();
this->init(SkNEW_ARGS(SkDevice, (bitmap)))->unref();
this->init(SkNEW_ARGS(SkBitmapDevice, (bitmap)))->unref();
}
SkCanvas::~SkCanvas() {
@ -564,37 +564,37 @@ SkMetaData& SkCanvas::getMetaData() {
///////////////////////////////////////////////////////////////////////////////
void SkCanvas::flush() {
SkDevice* device = this->getDevice();
SkBaseDevice* device = this->getDevice();
if (device) {
device->flush();
}
}
SkISize SkCanvas::getDeviceSize() const {
SkDevice* d = this->getDevice();
SkBaseDevice* d = this->getDevice();
return d ? SkISize::Make(d->width(), d->height()) : SkISize::Make(0, 0);
}
SkDevice* SkCanvas::getDevice() const {
SkBaseDevice* SkCanvas::getDevice() const {
// return root device
MCRec* rec = (MCRec*) fMCStack.front();
SkASSERT(rec && rec->fLayer);
return rec->fLayer->fDevice;
}
SkDevice* SkCanvas::getTopDevice(bool updateMatrixClip) const {
SkBaseDevice* SkCanvas::getTopDevice(bool updateMatrixClip) const {
if (updateMatrixClip) {
const_cast<SkCanvas*>(this)->updateDeviceCMCache();
}
return fMCRec->fTopLayer->fDevice;
}
SkDevice* SkCanvas::setDevice(SkDevice* device) {
SkBaseDevice* SkCanvas::setDevice(SkBaseDevice* device) {
// return root device
SkDeque::F2BIter iter(fMCStack);
MCRec* rec = (MCRec*)iter.next();
SkASSERT(rec && rec->fLayer);
SkDevice* rootDevice = rec->fLayer->fDevice;
SkBaseDevice* rootDevice = rec->fLayer->fDevice;
if (rootDevice == device) {
return device;
@ -644,7 +644,7 @@ SkDevice* SkCanvas::setDevice(SkDevice* device) {
bool SkCanvas::readPixels(SkBitmap* bitmap,
int x, int y,
Config8888 config8888) {
SkDevice* device = this->getDevice();
SkBaseDevice* device = this->getDevice();
if (!device) {
return false;
}
@ -652,7 +652,7 @@ bool SkCanvas::readPixels(SkBitmap* bitmap,
}
bool SkCanvas::readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
SkDevice* device = this->getDevice();
SkBaseDevice* device = this->getDevice();
if (!device) {
return false;
}
@ -676,7 +676,7 @@ bool SkCanvas::readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
void SkCanvas::writePixels(const SkBitmap& bitmap, int x, int y,
Config8888 config8888) {
SkDevice* device = this->getDevice();
SkBaseDevice* device = this->getDevice();
if (device) {
if (SkIRect::Intersects(SkIRect::MakeSize(this->getDeviceSize()),
SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height()))) {
@ -748,7 +748,7 @@ static SkBitmap::Config resolve_config(SkCanvas* canvas,
uint32_t configMask = 0;
for (int i = canvas->countLayerDevices() - 1; i >= 0; --i)
{
SkDevice* device = canvas->getLayerDevice(i);
SkBaseDevice* device = canvas->getLayerDevice(i);
if (device->intersects(bounds))
configMask |= 1 << device->config();
}
@ -849,7 +849,7 @@ int SkCanvas::internalSaveLayer(const SkRect* bounds, const SkPaint* paint,
bool isOpaque;
SkBitmap::Config config = resolve_config(this, ir, flags, &isOpaque);
SkDevice* device;
SkBaseDevice* device;
if (paint && paint->getImageFilter()) {
device = this->createCompatibleDevice(config, ir.width(), ir.height(),
isOpaque);
@ -981,7 +981,7 @@ void SkCanvas::internalDrawBitmap(const SkBitmap& bitmap,
LOOPER_END
}
void SkCanvas::internalDrawDevice(SkDevice* srcDev, int x, int y,
void SkCanvas::internalDrawDevice(SkBaseDevice* srcDev, int x, int y,
const SkPaint* paint) {
SkPaint tmp;
if (NULL == paint) {
@ -991,7 +991,7 @@ void SkCanvas::internalDrawDevice(SkDevice* srcDev, int x, int y,
LOOPER_BEGIN_DRAWDEVICE(*paint, SkDrawFilter::kBitmap_Type)
while (iter.next()) {
SkDevice* dstDev = iter.fDevice;
SkBaseDevice* dstDev = iter.fDevice;
paint = &looper.paint();
SkImageFilter* filter = paint->getImageFilter();
SkIPoint pos = { x - iter.getX(), y - iter.getY() };
@ -1164,7 +1164,7 @@ static bool clipPathHelper(const SkCanvas* canvas, SkRasterClip* currClip,
return currClip->op(clip, op);
}
} else {
const SkDevice* device = canvas->getDevice();
const SkBaseDevice* device = canvas->getDevice();
if (!device) {
return currClip->setEmpty();
}
@ -1358,7 +1358,7 @@ bool SkCanvas::clipRegion(const SkRegion& rgn, SkRegion::Op op) {
#ifdef SK_DEBUG
void SkCanvas::validateClip() const {
// construct clipRgn from the clipstack
const SkDevice* device = this->getDevice();
const SkBaseDevice* device = this->getDevice();
if (!device) {
SkASSERT(this->getTotalClip().isEmpty());
return;
@ -1543,10 +1543,10 @@ const SkRegion& SkCanvas::getTotalClip() const {
return fMCRec->fRasterClip->forceGetBW();
}
SkDevice* SkCanvas::createLayerDevice(SkBitmap::Config config,
SkBaseDevice* SkCanvas::createLayerDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque) {
SkDevice* device = this->getTopDevice();
SkBaseDevice* device = this->getTopDevice();
if (device) {
return device->createCompatibleDeviceForSaveLayer(config, width, height,
isOpaque);
@ -1555,10 +1555,10 @@ SkDevice* SkCanvas::createLayerDevice(SkBitmap::Config config,
}
}
SkDevice* SkCanvas::createCompatibleDevice(SkBitmap::Config config,
SkBaseDevice* SkCanvas::createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque) {
SkDevice* device = this->getDevice();
SkBaseDevice* device = this->getDevice();
if (device) {
return device->createCompatibleDevice(config, width, height, isOpaque);
} else {
@ -1874,8 +1874,8 @@ void SkCanvas::drawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
class SkDeviceFilteredPaint {
public:
SkDeviceFilteredPaint(SkDevice* device, const SkPaint& paint) {
SkDevice::TextFlags flags;
SkDeviceFilteredPaint(SkBaseDevice* device, const SkPaint& paint) {
SkBaseDevice::TextFlags flags;
if (device->filterTextFlags(paint, &flags)) {
SkPaint* newPaint = fLazy.set(paint);
newPaint->setFlags(flags.fFlags);
@ -2203,7 +2203,7 @@ void SkCanvas::LayerIter::next() {
fDone = !fImpl->next();
}
SkDevice* SkCanvas::LayerIter::device() const {
SkBaseDevice* SkCanvas::LayerIter::device() const {
return fImpl->getDevice();
}

214
src/core/SkDevice.cpp
View File

@ -15,7 +15,8 @@
#include "SkRRect.h"
#include "SkShader.h"
SK_DEFINE_INST_COUNT(SkDevice)
SK_DEFINE_INST_COUNT(SkBaseDevice)
SK_DEFINE_INST_COUNT(SkBitmapDevice)
///////////////////////////////////////////////////////////////////////////////
@ -24,20 +25,13 @@ SK_DEFINE_INST_COUNT(SkDevice)
///////////////////////////////////////////////////////////////////////////////
SkDevice::SkDevice(const SkBitmap& bitmap)
: fBitmap(bitmap), fLeakyProperties(SkDeviceProperties::MakeDefault())
#ifdef SK_DEBUG
, fAttachedToCanvas(false)
#endif
{
fOrigin.setZero();
fMetaData = NULL;
SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap)
: fBitmap(bitmap) {
SkASSERT(SkBitmap::kARGB_4444_Config != bitmap.config());
}
SkDevice::SkDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties)
: fBitmap(bitmap), fLeakyProperties(deviceProperties)
SkBaseDevice::SkBaseDevice()
: fLeakyProperties(SkDeviceProperties::MakeDefault())
#ifdef SK_DEBUG
, fAttachedToCanvas(false)
#endif
@ -46,25 +40,12 @@ SkDevice::SkDevice(const SkBitmap& bitmap, const SkDeviceProperties& devicePrope
fMetaData = NULL;
}
SkDevice::SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque)
: fLeakyProperties(SkDeviceProperties::MakeDefault())
#ifdef SK_DEBUG
, fAttachedToCanvas(false)
#endif
{
fOrigin.setZero();
fMetaData = NULL;
fBitmap.setConfig(config, width, height);
fBitmap.allocPixels();
fBitmap.setIsOpaque(isOpaque);
if (!isOpaque) {
fBitmap.eraseColor(SK_ColorTRANSPARENT);
}
SkBitmapDevice::SkBitmapDevice(const SkBitmap& bitmap, const SkDeviceProperties& deviceProperties)
: SkBaseDevice(deviceProperties)
, fBitmap(bitmap) {
}
SkDevice::SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
const SkDeviceProperties& deviceProperties)
SkBaseDevice::SkBaseDevice(const SkDeviceProperties& deviceProperties)
: fLeakyProperties(deviceProperties)
#ifdef SK_DEBUG
, fAttachedToCanvas(false)
@ -72,6 +53,20 @@ SkDevice::SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque
{
fOrigin.setZero();
fMetaData = NULL;
}
SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque) {
fBitmap.setConfig(config, width, height);
fBitmap.allocPixels();
fBitmap.setIsOpaque(isOpaque);
if (!isOpaque) {
fBitmap.eraseColor(SK_ColorTRANSPARENT);
}
}
SkBitmapDevice::SkBitmapDevice(SkBitmap::Config config, int width, int height, bool isOpaque,
const SkDeviceProperties& deviceProperties)
: SkBaseDevice(deviceProperties) {
fBitmap.setConfig(config, width, height);
fBitmap.allocPixels();
@ -81,39 +76,43 @@ SkDevice::SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque
}
}
SkDevice::~SkDevice() {
SkBaseDevice::~SkBaseDevice() {
delete fMetaData;
}
void SkDevice::replaceBitmapBackendForRasterSurface(const SkBitmap& bm) {
SkBitmapDevice::~SkBitmapDevice() {
}
void SkBitmapDevice::replaceBitmapBackendForRasterSurface(const SkBitmap& bm) {
SkASSERT(bm.width() == fBitmap.width());
SkASSERT(bm.height() == fBitmap.height());
fBitmap = bm; // intent is to use bm's pixelRef (and rowbytes/config)
fBitmap.lockPixels();
}
SkDevice* SkDevice::createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque) {
SkBaseDevice* SkBaseDevice::createCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque) {
return this->onCreateCompatibleDevice(config, width, height,
isOpaque, kGeneral_Usage);
}
SkDevice* SkDevice::createCompatibleDeviceForSaveLayer(SkBitmap::Config config,
int width, int height,
bool isOpaque) {
SkBaseDevice* SkBaseDevice::createCompatibleDeviceForSaveLayer(SkBitmap::Config config,
int width, int height,
bool isOpaque) {
return this->onCreateCompatibleDevice(config, width, height,
isOpaque, kSaveLayer_Usage);
}
SkDevice* SkDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
return SkNEW_ARGS(SkDevice,(config, width, height, isOpaque, fLeakyProperties));
SkBaseDevice* SkBitmapDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
return SkNEW_ARGS(SkBitmapDevice,(config, width, height, isOpaque,
this->getDeviceProperties()));
}
SkMetaData& SkDevice::getMetaData() {
SkMetaData& SkBaseDevice::getMetaData() {
// metadata users are rare, so we lazily allocate it. If that changes we
// can decide to just make it a field in the device (rather than a ptr)
if (NULL == fMetaData) {
@ -122,61 +121,60 @@ SkMetaData& SkDevice::getMetaData() {
return *fMetaData;
}
void SkDevice::lockPixels() {
void SkBitmapDevice::lockPixels() {
if (fBitmap.lockPixelsAreWritable()) {
fBitmap.lockPixels();
}
}
void SkDevice::unlockPixels() {
void SkBitmapDevice::unlockPixels() {
if (fBitmap.lockPixelsAreWritable()) {
fBitmap.unlockPixels();
}
}
const SkBitmap& SkDevice::accessBitmap(bool changePixels) {
const SkBitmap& bitmap = this->onAccessBitmap(&fBitmap);
const SkBitmap& SkBaseDevice::accessBitmap(bool changePixels) {
const SkBitmap& bitmap = this->onAccessBitmap();
if (changePixels) {
bitmap.notifyPixelsChanged();
}
return bitmap;
}
void SkDevice::getGlobalBounds(SkIRect* bounds) const {
void SkBitmapDevice::getGlobalBounds(SkIRect* bounds) const {
if (bounds) {
bounds->setXYWH(fOrigin.x(), fOrigin.y(),
const SkIPoint& origin = this->getOrigin();
bounds->setXYWH(origin.x(), origin.y(),
fBitmap.width(), fBitmap.height());
}
}
void SkDevice::clear(SkColor color) {
void SkBitmapDevice::clear(SkColor color) {
fBitmap.eraseColor(color);
}
const SkBitmap& SkDevice::onAccessBitmap(SkBitmap* bitmap) {return *bitmap;}
void SkDevice::setMatrixClip(const SkMatrix& matrix, const SkRegion& region,
const SkClipStack& clipStack) {
const SkBitmap& SkBitmapDevice::onAccessBitmap() {
return fBitmap;
}
bool SkDevice::canHandleImageFilter(SkImageFilter*) {
bool SkBitmapDevice::canHandleImageFilter(SkImageFilter*) {
return false;
}
bool SkDevice::filterImage(SkImageFilter* filter, const SkBitmap& src,
const SkMatrix& ctm, SkBitmap* result,
SkIPoint* offset) {
bool SkBitmapDevice::filterImage(SkImageFilter* filter, const SkBitmap& src,
const SkMatrix& ctm, SkBitmap* result,
SkIPoint* offset) {
return false;
}
bool SkDevice::allowImageFilter(SkImageFilter*) {
bool SkBitmapDevice::allowImageFilter(SkImageFilter*) {
return true;
}
///////////////////////////////////////////////////////////////////////////////
bool SkDevice::readPixels(SkBitmap* bitmap, int x, int y,
SkCanvas::Config8888 config8888) {
bool SkBaseDevice::readPixels(SkBitmap* bitmap, int x, int y,
SkCanvas::Config8888 config8888) {
if (SkBitmap::kARGB_8888_Config != bitmap->config() ||
NULL != bitmap->getTexture()) {
return false;
@ -220,21 +218,21 @@ bool SkDevice::readPixels(SkBitmap* bitmap, int x, int y,
}
#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
const SkCanvas::Config8888 SkDevice::kPMColorAlias =
const SkCanvas::Config8888 SkBaseDevice::kPMColorAlias =
SkCanvas::kBGRA_Premul_Config8888;
#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
const SkCanvas::Config8888 SkDevice::kPMColorAlias =
const SkCanvas::Config8888 SkBaseDevice::kPMColorAlias =
SkCanvas::kRGBA_Premul_Config8888;
#else
const SkCanvas::Config8888 SkDevice::kPMColorAlias =
const SkCanvas::Config8888 SkBaseDevice::kPMColorAlias =
(SkCanvas::Config8888) -1;
#endif
#include <SkConfig8888.h>
bool SkDevice::onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) {
bool SkBitmapDevice::onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) {
SkASSERT(SkBitmap::kARGB_8888_Config == bitmap.config());
SkASSERT(!bitmap.isNull());
SkASSERT(SkIRect::MakeWH(this->width(), this->height()).contains(SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height())));
@ -257,9 +255,9 @@ bool SkDevice::onReadPixels(const SkBitmap& bitmap,
return true;
}
void SkDevice::writePixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) {
void SkBitmapDevice::writePixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) {
if (bitmap.isNull() || bitmap.getTexture()) {
return;
}
@ -328,22 +326,22 @@ void SkDevice::writePixels(const SkBitmap& bitmap,
///////////////////////////////////////////////////////////////////////////////
void SkDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
void SkBitmapDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
draw.drawPaint(paint);
}
void SkDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint) {
void SkBitmapDevice::drawPoints(const SkDraw& draw, SkCanvas::PointMode mode, size_t count,
const SkPoint pts[], const SkPaint& paint) {
CHECK_FOR_NODRAW_ANNOTATION(paint);
draw.drawPoints(mode, count, pts, paint);
}
void SkDevice::drawRect(const SkDraw& draw, const SkRect& r, const SkPaint& paint) {
void SkBitmapDevice::drawRect(const SkDraw& draw, const SkRect& r, const SkPaint& paint) {
CHECK_FOR_NODRAW_ANNOTATION(paint);
draw.drawRect(r, paint);
}
void SkDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
void SkBitmapDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& paint) {
CHECK_FOR_NODRAW_ANNOTATION(paint);
SkPath path;
@ -353,7 +351,7 @@ void SkDevice::drawOval(const SkDraw& draw, const SkRect& oval, const SkPaint& p
this->drawPath(draw, path, paint, NULL, true);
}
void SkDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint& paint) {
void SkBitmapDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint& paint) {
CHECK_FOR_NODRAW_ANNOTATION(paint);
SkPath path;
@ -363,22 +361,22 @@ void SkDevice::drawRRect(const SkDraw& draw, const SkRRect& rrect, const SkPaint
this->drawPath(draw, path, paint, NULL, true);
}
void SkDevice::drawPath(const SkDraw& draw, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable) {
void SkBitmapDevice::drawPath(const SkDraw& draw, const SkPath& path,
const SkPaint& paint, const SkMatrix* prePathMatrix,
bool pathIsMutable) {
CHECK_FOR_NODRAW_ANNOTATION(paint);
draw.drawPath(path, paint, prePathMatrix, pathIsMutable);
}
void SkDevice::drawBitmap(const SkDraw& draw, const SkBitmap& bitmap,
const SkMatrix& matrix, const SkPaint& paint) {
void SkBitmapDevice::drawBitmap(const SkDraw& draw, const SkBitmap& bitmap,
const SkMatrix& matrix, const SkPaint& paint) {
draw.drawBitmap(bitmap, matrix, paint);
}
void SkDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
const SkRect* src, const SkRect& dst,
const SkPaint& paint,
SkCanvas::DrawBitmapRectFlags flags) {
void SkBitmapDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
const SkRect* src, const SkRect& dst,
const SkPaint& paint,
SkCanvas::DrawBitmapRectFlags flags) {
SkMatrix matrix;
SkRect bitmapBounds, tmpSrc, tmpDst;
SkBitmap tmpBitmap;
@ -462,56 +460,56 @@ void SkDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
this->drawRect(draw, *dstPtr, paintWithShader);
}
void SkDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint) {
void SkBitmapDevice::drawSprite(const SkDraw& draw, const SkBitmap& bitmap,
int x, int y, const SkPaint& paint) {
draw.drawSprite(bitmap, x, y, paint);
}
void SkDevice::drawText(const SkDraw& draw, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint& paint) {
void SkBitmapDevice::drawText(const SkDraw& draw, const void* text, size_t len,
SkScalar x, SkScalar y, const SkPaint& paint) {
draw.drawText((const char*)text, len, x, y, paint);
}
void SkDevice::drawPosText(const SkDraw& draw, const void* text, size_t len,
const SkScalar xpos[], SkScalar y,
int scalarsPerPos, const SkPaint& paint) {
void SkBitmapDevice::drawPosText(const SkDraw& draw, const void* text, size_t len,
const SkScalar xpos[], SkScalar y,
int scalarsPerPos, const SkPaint& paint) {
draw.drawPosText((const char*)text, len, xpos, y, scalarsPerPos, paint);
}
void SkDevice::drawTextOnPath(const SkDraw& draw, const void* text,
size_t len, const SkPath& path,
const SkMatrix* matrix,
const SkPaint& paint) {
void SkBitmapDevice::drawTextOnPath(const SkDraw& draw, const void* text,
size_t len, const SkPath& path,
const SkMatrix* matrix,
const SkPaint& paint) {
draw.drawTextOnPath((const char*)text, len, path, matrix, paint);
}
#ifdef SK_BUILD_FOR_ANDROID
void SkDevice::drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
const SkPoint pos[], const SkPaint& paint,
const SkPath& path, const SkMatrix* matrix) {
void SkBitmapDevice::drawPosTextOnPath(const SkDraw& draw, const void* text, size_t len,
const SkPoint pos[], const SkPaint& paint,
const SkPath& path, const SkMatrix* matrix) {
draw.drawPosTextOnPath((const char*)text, len, pos, paint, path, matrix);
}
#endif
void SkDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
int vertexCount,
const SkPoint verts[], const SkPoint textures[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
void SkBitmapDevice::drawVertices(const SkDraw& draw, SkCanvas::VertexMode vmode,
int vertexCount,
const SkPoint verts[], const SkPoint textures[],
const SkColor colors[], SkXfermode* xmode,
const uint16_t indices[], int indexCount,
const SkPaint& paint) {
draw.drawVertices(vmode, vertexCount, verts, textures, colors, xmode,
indices, indexCount, paint);
}
void SkDevice::drawDevice(const SkDraw& draw, SkDevice* device,
int x, int y, const SkPaint& paint) {
void SkBitmapDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
int x, int y, const SkPaint& paint) {
const SkBitmap& src = device->accessBitmap(false);
draw.drawSprite(src, x, y, paint);
}
///////////////////////////////////////////////////////////////////////////////
bool SkDevice::filterTextFlags(const SkPaint& paint, TextFlags* flags) {
bool SkBitmapDevice::filterTextFlags(const SkPaint& paint, TextFlags* flags) {
if (!paint.isLCDRenderText() || !paint.isAntiAlias()) {
// we're cool with the paint as is
return false;

6
src/core/SkDeviceImageFilterProxy.h
View File

@ -12,9 +12,9 @@
class SkDeviceImageFilterProxy : public SkImageFilter::Proxy {
public:
SkDeviceImageFilterProxy(SkDevice* device) : fDevice(device) {}
SkDeviceImageFilterProxy(SkBaseDevice* device) : fDevice(device) {}
virtual SkDevice* createDevice(int w, int h) SK_OVERRIDE {
virtual SkBaseDevice* createDevice(int w, int h) SK_OVERRIDE {
return fDevice->createCompatibleDevice(SkBitmap::kARGB_8888_Config,
w, h, false);
}
@ -28,7 +28,7 @@ public:
}
private:
SkDevice* fDevice;
SkBaseDevice* fDevice;
};
#endif

2
src/core/SkPicture.cpp
View File

@ -205,7 +205,7 @@ SkCanvas* SkPicture::beginRecording(int width, int height,
SkBitmap bm;
bm.setConfig(SkBitmap::kNo_Config, width, height);
SkAutoTUnref<SkDevice> dev(SkNEW_ARGS(SkDevice, (bm)));
SkAutoTUnref<SkBaseDevice> dev(SkNEW_ARGS(SkBitmapDevice, (bm)));
// Must be set before calling createBBoxHierarchy
fWidth = width;

4
src/core/SkPictureRecord.cpp
View File

@ -28,7 +28,7 @@ static const uint32_t kSaveSize = 2 * kUInt32Size;
static const uint32_t kSaveLayerNoBoundsSize = 4 * kUInt32Size;
static const uint32_t kSaveLayerWithBoundsSize = 4 * kUInt32Size + sizeof(SkRect);
SkPictureRecord::SkPictureRecord(uint32_t flags, SkDevice* device) :
SkPictureRecord::SkPictureRecord(uint32_t flags, SkBaseDevice* device) :
INHERITED(device),
fBoundingHierarchy(NULL),
fStateTree(NULL),
@ -138,7 +138,7 @@ static inline uint32_t getPaintOffset(DrawType op, uint32_t opSize) {
return gPaintOffsets[op] * sizeof(uint32_t) + overflow;
}
SkDevice* SkPictureRecord::setDevice(SkDevice* device) {
SkBaseDevice* SkPictureRecord::setDevice(SkBaseDevice* device) {
SkASSERT(!"eeek, don't try to change the device on a recording canvas");
return this->INHERITED::setDevice(device);
}

4
src/core/SkPictureRecord.h
View File

@ -30,10 +30,10 @@ class SkBBoxHierarchy;
class SkPictureRecord : public SkCanvas {
public:
SkPictureRecord(uint32_t recordFlags, SkDevice*);
SkPictureRecord(uint32_t recordFlags, SkBaseDevice*);
virtual ~SkPictureRecord();
virtual SkDevice* setDevice(SkDevice* device) SK_OVERRIDE;
virtual SkBaseDevice* setDevice(SkBaseDevice* device) SK_OVERRIDE;
virtual int save(SaveFlags) SK_OVERRIDE;
virtual int saveLayer(const SkRect* bounds, const SkPaint*, SaveFlags) SK_OVERRIDE;

16
src/device/xps/SkXPSDevice.cpp
View File

@ -111,7 +111,7 @@ static SkBitmap make_fake_bitmap(int width, int height) {
}
SkXPSDevice::SkXPSDevice()
: SkDevice(make_fake_bitmap(10000, 10000))
: SkBitmapDevice(make_fake_bitmap(10000, 10000))
, fCurrentPage(0) {
}
@ -2375,7 +2375,7 @@ void SkXPSDevice::drawTextOnPath(const SkDraw& d, const void* text, size_t len,
d.drawTextOnPath((const char*)text, len, path, matrix, paint);
}
void SkXPSDevice::drawDevice(const SkDraw& d, SkDevice* dev,
void SkXPSDevice::drawDevice(const SkDraw& d, SkBaseDevice* dev,
int x, int y,
const SkPaint&) {
SkXPSDevice* that = static_cast<SkXPSDevice*>(dev);
@ -2407,11 +2407,11 @@ bool SkXPSDevice::onReadPixels(const SkBitmap& bitmap, int x, int y,
return false;
}
SkDevice* SkXPSDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
if (SkDevice::kGeneral_Usage == usage) {
SkBaseDevice* SkXPSDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
if (SkBaseDevice::kGeneral_Usage == usage) {
return NULL;
SK_CRASH();
//To what stream do we write?
@ -2425,7 +2425,7 @@ SkDevice* SkXPSDevice::onCreateCompatibleDevice(SkBitmap::Config config,
}
SkXPSDevice::SkXPSDevice(IXpsOMObjectFactory* xpsFactory)
: SkDevice(make_fake_bitmap(10000, 10000))
: SkBitmapDevice(make_fake_bitmap(10000, 10000))
, fCurrentPage(0) {
HRVM(CoCreateInstance(

2
src/effects/SkColorFilterImageFilter.cpp
View File

@ -111,7 +111,7 @@ bool SkColorFilterImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& sourc
return false;
}
SkAutoTUnref<SkDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(bounds.width(), bounds.height()));
SkCanvas canvas(device.get());
SkPaint paint;

2
src/effects/SkDropShadowImageFilter.cpp
View File

@ -46,7 +46,7 @@ bool SkDropShadowImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& source
if (getInput(0) && !getInput(0)->filterImage(proxy, source, matrix, &src, loc))
return false;
SkAutoTUnref<SkDevice> device(proxy->createDevice(src.width(), src.height()));
SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(src.width(), src.height()));
SkCanvas canvas(device.get());
SkAutoTUnref<SkImageFilter> blurFilter(new SkBlurImageFilter(fSigma, fSigma));

2
src/effects/SkMergeImageFilter.cpp
View File

@ -109,7 +109,7 @@ bool SkMergeImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& src,
const int x0 = bounds.left();
const int y0 = bounds.top();
SkAutoTUnref<SkDevice> dst(proxy->createDevice(bounds.width(), bounds.height()));
SkAutoTUnref<SkBaseDevice> dst(proxy->createDevice(bounds.width(), bounds.height()));
if (NULL == dst) {
return false;
}

4
src/effects/SkRectShaderImageFilter.cpp
View File

@ -56,8 +56,8 @@ bool SkRectShaderImageFilter::onFilterImage(Proxy* proxy,
return false;
}
SkAutoTUnref<SkDevice> device(proxy->createDevice(SkScalarCeilToInt(rect.width()),
SkScalarCeilToInt(rect.height())));
SkAutoTUnref<SkBaseDevice> device(proxy->createDevice(SkScalarCeilToInt(rect.width()),
SkScalarCeilToInt(rect.height())));
SkCanvas canvas(device.get());
SkPaint paint;
paint.setShader(fShader);

8
src/effects/SkTestImageFilters.cpp
View File

@ -9,11 +9,11 @@
// with the following:
//
// SkCanvas canvas(device);
// SkAutoTUnref<SkDevice> aur(device);
// SkAutoTUnref<SkBaseDevice> aur(device);
//
class OwnDeviceCanvas : public SkCanvas {
public:
OwnDeviceCanvas(SkDevice* device) : SkCanvas(device) {
OwnDeviceCanvas(SkBaseDevice* device) : SkCanvas(device) {
SkSafeUnref(device);
}
};
@ -41,7 +41,7 @@ bool SkDownSampleImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& src,
// downsample
{
SkDevice* dev = proxy->createDevice(dstW, dstH);
SkBaseDevice* dev = proxy->createDevice(dstW, dstH);
if (NULL == dev) {
return false;
}
@ -56,7 +56,7 @@ bool SkDownSampleImageFilter::onFilterImage(Proxy* proxy, const SkBitmap& src,
// upscale
{
SkDevice* dev = proxy->createDevice(src.width(), src.height());
SkBaseDevice* dev = proxy->createDevice(src.width(), src.height());
if (NULL == dev) {
return false;
}

20
src/gpu/SkGpuDevice.cpp
View File

@ -161,12 +161,12 @@ SkGpuDevice* SkGpuDevice::Create(GrSurface* surface) {
}
SkGpuDevice::SkGpuDevice(GrContext* context, GrTexture* texture)
: SkDevice(make_bitmap(context, texture->asRenderTarget())) {
: SkBitmapDevice(make_bitmap(context, texture->asRenderTarget())) {
this->initFromRenderTarget(context, texture->asRenderTarget(), false);
}
SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget)
: SkDevice(make_bitmap(context, renderTarget)) {
: SkBitmapDevice(make_bitmap(context, renderTarget)) {
this->initFromRenderTarget(context, renderTarget, false);
}
@ -203,7 +203,7 @@ SkGpuDevice::SkGpuDevice(GrContext* context,
int width,
int height,
int sampleCount)
: SkDevice(config, width, height, false /*isOpaque*/) {
: SkBitmapDevice(config, width, height, false /*isOpaque*/) {
fDrawProcs = NULL;
@ -1436,7 +1436,7 @@ void SkGpuDevice::internalDrawBitmap(const SkBitmap& bitmap,
fContext->drawRectToRect(grPaint, dstRect, paintRect, &m);
}
static bool filter_texture(SkDevice* device, GrContext* context,
static bool filter_texture(SkBaseDevice* device, GrContext* context,
GrTexture* texture, SkImageFilter* filter,
int w, int h, const SkMatrix& ctm, SkBitmap* result,
SkIPoint* offset) {
@ -1535,7 +1535,7 @@ void SkGpuDevice::drawBitmapRect(const SkDraw& draw, const SkBitmap& bitmap,
this->drawBitmapCommon(draw, bitmap, &tmpSrc, matrix, paint, flags);
}
void SkGpuDevice::drawDevice(const SkDraw& draw, SkDevice* device,
void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
int x, int y, const SkPaint& paint) {
// clear of the source device must occur before CHECK_SHOULD_DRAW
SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
@ -1818,10 +1818,10 @@ void SkGpuDevice::flush() {
///////////////////////////////////////////////////////////////////////////////
SkDevice* SkGpuDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
SkBaseDevice* SkGpuDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
GrTextureDesc desc;
desc.fConfig = fRenderTarget->config();
desc.fFlags = kRenderTarget_GrTextureFlagBit;
@ -1854,7 +1854,7 @@ SkDevice* SkGpuDevice::onCreateCompatibleDevice(SkBitmap::Config config,
SkGpuDevice::SkGpuDevice(GrContext* context,
GrTexture* texture,
bool needClear)
: SkDevice(make_bitmap(context, texture->asRenderTarget())) {
: SkBitmapDevice(make_bitmap(context, texture->asRenderTarget())) {
SkASSERT(texture && texture->asRenderTarget());
// This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture

16
src/pdf/SkPDFDevice.cpp
View File

@ -566,10 +566,10 @@ void GraphicStackState::updateDrawingState(const GraphicStateEntry& state) {
}
}
SkDevice* SkPDFDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
SkBaseDevice* SkPDFDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
SkMatrix initialTransform;
initialTransform.reset();
SkISize size = SkISize::Make(width, height);
@ -672,7 +672,7 @@ static inline SkBitmap makeContentBitmap(const SkISize& contentSize,
// TODO(vandebo) change pageSize to SkSize.
SkPDFDevice::SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
const SkMatrix& initialTransform)
: SkDevice(makeContentBitmap(contentSize, &initialTransform)),
: SkBitmapDevice(makeContentBitmap(contentSize, &initialTransform)),
fPageSize(pageSize),
fContentSize(contentSize),
fLastContentEntry(NULL),
@ -696,7 +696,7 @@ SkPDFDevice::SkPDFDevice(const SkISize& pageSize, const SkISize& contentSize,
SkPDFDevice::SkPDFDevice(const SkISize& layerSize,
const SkClipStack& existingClipStack,
const SkRegion& existingClipRegion)
: SkDevice(makeContentBitmap(layerSize, NULL)),
: SkBitmapDevice(makeContentBitmap(layerSize, NULL)),
fPageSize(layerSize),
fContentSize(layerSize),
fExistingClipStack(existingClipStack),
@ -1153,11 +1153,11 @@ void SkPDFDevice::drawVertices(const SkDraw& d, SkCanvas::VertexMode,
NOT_IMPLEMENTED("drawVerticies", true);
}
void SkPDFDevice::drawDevice(const SkDraw& d, SkDevice* device, int x, int y,
void SkPDFDevice::drawDevice(const SkDraw& d, SkBaseDevice* device, int x, int y,
const SkPaint& paint) {
if ((device->getDeviceCapabilities() & kVector_Capability) == 0) {
// If we somehow get a raster device, do what our parent would do.
SkDevice::drawDevice(d, device, x, y, paint);
INHERITED::drawDevice(d, device, x, y, paint);
return;
}

2
src/pipe/SkGPipeWrite.cpp
View File

@ -432,7 +432,7 @@ SkGPipeCanvas::SkGPipeCanvas(SkGPipeController* controller,
// We don't allocate pixels for the bitmap
SkBitmap bitmap;
bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height);
SkDevice* device = SkNEW_ARGS(SkDevice, (bitmap));
SkBaseDevice* device = SkNEW_ARGS(SkBitmapDevice, (bitmap));
this->setDevice(device)->unref();
// Tell the reader the appropriate flags to use.

2
src/pipe/utils/SamplePipeControllers.cpp
View File

@ -55,7 +55,7 @@ TiledPipeController::TiledPipeController(const SkBitmap& bitmap,
SkDEBUGCODE(bool extracted = )bitmap.extractSubset(&fBitmaps[i], rect);
SkASSERT(extracted);
SkDevice* device = new SkDevice(fBitmaps[i]);
SkBaseDevice* device = new SkBitmapDevice(fBitmaps[i]);
SkCanvas* canvas = new SkCanvas(device);
device->unref();
if (initial != NULL) {

50
src/utils/SkDeferredCanvas.cpp
View File

@ -137,16 +137,16 @@ void DeferredPipeController::playback(bool silent) {
//-----------------------------------------------------------------------------
// DeferredDevice
//-----------------------------------------------------------------------------
class DeferredDevice : public SkDevice {
class DeferredDevice : public SkBitmapDevice {
public:
explicit DeferredDevice(SkDevice* immediateDevice);
explicit DeferredDevice(SkBaseDevice* immediateDevice);
explicit DeferredDevice(SkSurface* surface);
~DeferredDevice();
void setNotificationClient(SkDeferredCanvas::NotificationClient* notificationClient);
SkCanvas* recordingCanvas();
SkCanvas* immediateCanvas() const {return fImmediateCanvas;}
SkDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();}
SkBaseDevice* immediateDevice() const {return fImmediateCanvas->getTopDevice();}
SkImage* newImageSnapshot();
void setSurface(SkSurface* surface);
bool isFreshFrame();
@ -165,24 +165,24 @@ public:
virtual int height() const SK_OVERRIDE;
virtual GrRenderTarget* accessRenderTarget() SK_OVERRIDE;
virtual SkDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
virtual SkBaseDevice* onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) SK_OVERRIDE;
virtual void writePixels(const SkBitmap& bitmap, int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
protected:
virtual const SkBitmap& onAccessBitmap(SkBitmap*) SK_OVERRIDE;
virtual const SkBitmap& onAccessBitmap() SK_OVERRIDE;
virtual bool onReadPixels(const SkBitmap& bitmap,
int x, int y,
SkCanvas::Config8888 config8888) SK_OVERRIDE;
// The following methods are no-ops on a deferred device
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*)
SK_OVERRIDE
{return false;}
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*) SK_OVERRIDE {
return false;
}
// None of the following drawing methods should ever get called on the
// deferred device
@ -234,7 +234,7 @@ protected:
SkXfermode* xmode, const uint16_t indices[],
int indexCount, const SkPaint& paint) SK_OVERRIDE
{SkASSERT(0);}
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) SK_OVERRIDE
{SkASSERT(0);}
private:
@ -258,11 +258,11 @@ private:
size_t fBitmapSizeThreshold;
};
DeferredDevice::DeferredDevice(SkDevice* immediateDevice)
: SkDevice(SkBitmap::kNo_Config,
immediateDevice->width(), immediateDevice->height(),
immediateDevice->isOpaque(),
immediateDevice->getDeviceProperties()) {
DeferredDevice::DeferredDevice(SkBaseDevice* immediateDevice)
: SkBitmapDevice(SkBitmap::kNo_Config,
immediateDevice->width(), immediateDevice->height(),
immediateDevice->isOpaque(),
immediateDevice->getDeviceProperties()) {
fSurface = NULL;
fImmediateCanvas = SkNEW_ARGS(SkCanvas, (immediateDevice));
fPipeController.setPlaybackCanvas(fImmediateCanvas);
@ -270,11 +270,11 @@ DeferredDevice::DeferredDevice(SkDevice* immediateDevice)
}
DeferredDevice::DeferredDevice(SkSurface* surface)
: SkDevice(SkBitmap::kNo_Config,
surface->getCanvas()->getDevice()->width(),
surface->getCanvas()->getDevice()->height(),
surface->getCanvas()->getDevice()->isOpaque(),
surface->getCanvas()->getDevice()->getDeviceProperties()) {
: SkBitmapDevice(SkBitmap::kNo_Config,
surface->getCanvas()->getDevice()->width(),
surface->getCanvas()->getDevice()->height(),
surface->getCanvas()->getDevice()->isOpaque(),
surface->getCanvas()->getDevice()->getDeviceProperties()) {
fMaxRecordingStorageBytes = kDefaultMaxRecordingStorageBytes;
fNotificationClient = NULL;
fImmediateCanvas = NULL;
@ -492,12 +492,12 @@ void DeferredDevice::writePixels(const SkBitmap& bitmap,
}
}
const SkBitmap& DeferredDevice::onAccessBitmap(SkBitmap*) {
const SkBitmap& DeferredDevice::onAccessBitmap() {
this->flushPendingCommands(kNormal_PlaybackMode);
return immediateDevice()->accessBitmap(false);
}
SkDevice* DeferredDevice::onCreateCompatibleDevice(
SkBaseDevice* DeferredDevice::onCreateCompatibleDevice(
SkBitmap::Config config, int width, int height, bool isOpaque,
Usage usage) {
@ -555,7 +555,7 @@ SkDeferredCanvas* SkDeferredCanvas::Create(SkSurface* surface) {
return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
}
SkDeferredCanvas* SkDeferredCanvas::Create(SkDevice* device) {
SkDeferredCanvas* SkDeferredCanvas::Create(SkBaseDevice* device) {
SkAutoTUnref<DeferredDevice> deferredDevice(SkNEW_ARGS(DeferredDevice, (device)));
return SkNEW_ARGS(SkDeferredCanvas, (deferredDevice));
}

11
src/utils/SkPictureUtils.cpp
View File

@ -47,7 +47,7 @@ static void nothing_to_do() {}
* It should never actually draw anything, so there need not be any pixels
* behind its device-bitmap.
*/
class GatherPixelRefDevice : public SkDevice {
class GatherPixelRefDevice : public SkBitmapDevice {
private:
PixelRefSet* fPRSet;
@ -70,7 +70,7 @@ private:
}
public:
GatherPixelRefDevice(const SkBitmap& bm, PixelRefSet* prset) : SkDevice(bm) {
GatherPixelRefDevice(const SkBitmap& bm, PixelRefSet* prset) : SkBitmapDevice(bm) {
fPRSet = prset;
}
@ -138,7 +138,7 @@ public:
const SkPaint& paint) SK_OVERRIDE {
this->addBitmapFromPaint(paint);
}
virtual void drawDevice(const SkDraw&, SkDevice*, int x, int y,
virtual void drawDevice(const SkDraw&, SkBaseDevice*, int x, int y,
const SkPaint&) SK_OVERRIDE {
nothing_to_do();
}
@ -150,11 +150,14 @@ protected:
not_supported();
return false;
}
private:
typedef SkBitmapDevice INHERITED;
};
class NoSaveLayerCanvas : public SkCanvas {
public:
NoSaveLayerCanvas(SkDevice* device) : INHERITED(device) {}
NoSaveLayerCanvas(SkBaseDevice* device) : INHERITED(device) {}
// turn saveLayer() into save() for speed, should not affect correctness.
virtual int saveLayer(const SkRect* bounds, const SkPaint* paint,

10
tests/CanvasTest.cpp
View File

@ -779,7 +779,7 @@ public:
SkBitmap deferredStore;
createBitmap(&deferredStore, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice deferredDevice(deferredStore);
SkBitmapDevice deferredDevice(deferredStore);
SkAutoTUnref<SkDeferredCanvas> deferredCanvas(SkDeferredCanvas::Create(&deferredDevice));
testStep->setAssertMessageFormat(kDeferredDrawAssertMessageFormat);
testStep->draw(deferredCanvas, reporter);
@ -821,7 +821,7 @@ static void TestProxyCanvasStateConsistency(
SkBitmap indirectStore;
createBitmap(&indirectStore, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice indirectDevice(indirectStore);
SkBitmapDevice indirectDevice(indirectStore);
SkCanvas indirectCanvas(&indirectDevice);
SkProxyCanvas proxyCanvas(&indirectCanvas);
testStep->setAssertMessageFormat(kProxyDrawAssertMessageFormat);
@ -844,12 +844,12 @@ static void TestNWayCanvasStateConsistency(
SkBitmap indirectStore1;
createBitmap(&indirectStore1, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice indirectDevice1(indirectStore1);
SkBitmapDevice indirectDevice1(indirectStore1);
SkCanvas indirectCanvas1(&indirectDevice1);
SkBitmap indirectStore2;
createBitmap(&indirectStore2, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice indirectDevice2(indirectStore2);
SkBitmapDevice indirectDevice2(indirectStore2);
SkCanvas indirectCanvas2(&indirectDevice2);
SkISize canvasSize = referenceCanvas.getDeviceSize();
@ -882,7 +882,7 @@ static void TestOverrideStateConsistency(skiatest::Reporter* reporter,
CanvasTestStep* testStep) {
SkBitmap referenceStore;
createBitmap(&referenceStore, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice referenceDevice(referenceStore);
SkBitmapDevice referenceDevice(referenceStore);
SkCanvas referenceCanvas(&referenceDevice);
testStep->setAssertMessageFormat(kCanvasDrawAssertMessageFormat);
testStep->draw(&referenceCanvas, reporter);

26
tests/DeferredCanvasTest.cpp
View File

@ -33,7 +33,7 @@ static void TestDeferredCanvasBitmapAccess(skiatest::Reporter* reporter) {
SkBitmap store;
create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->clear(0x00000000);
@ -259,7 +259,7 @@ static void TestDeferredCanvasFlush(skiatest::Reporter* reporter) {
SkBitmap store;
create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->clear(0x00000000);
@ -279,7 +279,7 @@ static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
partialRect.setXYWH(SkIntToScalar(0), SkIntToScalar(0),
SkIntToScalar(1), SkIntToScalar(1));
create(&store, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
// verify that frame is intially fresh
@ -433,9 +433,9 @@ static void TestDeferredCanvasFreshFrame(skiatest::Reporter* reporter) {
}
}
class MockDevice : public SkDevice {
class MockDevice : public SkBitmapDevice {
public:
MockDevice(const SkBitmap& bm) : SkDevice(bm) {
MockDevice(const SkBitmap& bm) : SkBitmapDevice(bm) {
fDrawBitmapCallCount = 0;
}
virtual void drawBitmap(const SkDraw&, const SkBitmap&,
@ -502,7 +502,7 @@ static void TestDeferredCanvasBitmapCaching(skiatest::Reporter* reporter) {
SkBitmap store;
store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
store.allocPixels();
SkDevice device(store);
SkBitmapDevice device(store);
NotificationCounter notificationCounter;
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->setNotificationClient(&notificationCounter);
@ -585,7 +585,7 @@ static void TestDeferredCanvasSkip(skiatest::Reporter* reporter) {
SkBitmap store;
store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
store.allocPixels();
SkDevice device(store);
SkBitmapDevice device(store);
NotificationCounter notificationCounter;
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->setNotificationClient(&notificationCounter);
@ -606,7 +606,7 @@ static void TestDeferredCanvasBitmapShaderNoLeak(skiatest::Reporter* reporter) {
SkBitmap store;
store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
store.allocPixels();
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
// test will fail if nbIterations is not in sync with
// BITMAPS_TO_KEEP in SkGPipeWrite.cpp
@ -652,7 +652,7 @@ static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter)
// 1 under : should not store the image
{
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->setBitmapSizeThreshold(39999);
canvas->drawBitmap(sourceImage, 0, 0, NULL);
@ -662,7 +662,7 @@ static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter)
// exact value : should store the image
{
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->setBitmapSizeThreshold(40000);
canvas->drawBitmap(sourceImage, 0, 0, NULL);
@ -672,7 +672,7 @@ static void TestDeferredCanvasBitmapSizeThreshold(skiatest::Reporter* reporter)
// 1 over : should still store the image
{
SkDevice device(store);
SkBitmapDevice device(store);
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->setBitmapSizeThreshold(40001);
canvas->drawBitmap(sourceImage, 0, 0, NULL);
@ -807,11 +807,11 @@ static void TestDeferredCanvasCreateCompatibleDevice(skiatest::Reporter* reporte
SkBitmap store;
store.setConfig(SkBitmap::kARGB_8888_Config, 100, 100);
store.allocPixels();
SkDevice device(store);
SkBitmapDevice device(store);
NotificationCounter notificationCounter;
SkAutoTUnref<SkDeferredCanvas> canvas(SkDeferredCanvas::Create(&device));
canvas->setNotificationClient(&notificationCounter);
SkAutoTUnref<SkDevice> secondaryDevice(canvas->createCompatibleDevice(
SkAutoTUnref<SkBaseDevice> secondaryDevice(canvas->createCompatibleDevice(
SkBitmap::kARGB_8888_Config, 10, 10, device.isOpaque()));
SkCanvas secondaryCanvas(secondaryDevice.get());
SkRect rect = SkRect::MakeWH(5, 5);

2
tests/GradientTest.cpp
View File

@ -146,7 +146,7 @@ static void TestConstantGradient(skiatest::Reporter*) {
outBitmap.allocPixels();
SkPaint paint;
paint.setShader(s.get());
SkDevice device(outBitmap);
SkBitmapDevice device(outBitmap);
SkCanvas canvas(&device);
canvas.drawPaint(paint);
SkAutoLockPixels alp(outBitmap);

9
tests/LayerDrawLooperTest.cpp
View File

@ -19,17 +19,20 @@
namespace {
class FakeDevice : public SkDevice {
class FakeDevice : public SkBitmapDevice {
public:
FakeDevice() : SkDevice(SkBitmap::kARGB_8888_Config, 100, 100) { }
FakeDevice() : SkBitmapDevice(SkBitmap::kARGB_8888_Config, 100, 100, false) { }
virtual void drawRect(const SkDraw& draw, const SkRect& r,
const SkPaint& paint) SK_OVERRIDE {
fLastMatrix = *draw.fMatrix;
SkDevice::drawRect(draw, r, paint);
INHERITED::drawRect(draw, r, paint);
}
SkMatrix fLastMatrix;
private:
typedef SkBitmapDevice INHERITED;
};
} // namespace

10
tests/PremulAlphaRoundTripTest.cpp
View File

@ -41,7 +41,7 @@ static const SkCanvas::Config8888 gUnpremulConfigs[] = {
};
void PremulAlphaRoundTripTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
SkAutoTUnref<SkDevice> device;
SkAutoTUnref<SkBaseDevice> device;
for (int dtype = 0; dtype < 2; ++dtype) {
int glCtxTypeCnt = 1;
@ -52,10 +52,10 @@ void PremulAlphaRoundTripTest(skiatest::Reporter* reporter, GrContextFactory* fa
#endif
for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
if (0 == dtype) {
device.reset(new SkDevice(SkBitmap::kARGB_8888_Config,
256,
256,
false));
device.reset(new SkBitmapDevice(SkBitmap::kARGB_8888_Config,
256,
256,
false));
} else {
#if SK_SUPPORT_GPU
GrContextFactory::GLContextType type =

5
tests/ReadPixelsTest.cpp
View File

@ -311,9 +311,10 @@ void ReadPixelsTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
}
#endif
for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
SkAutoTUnref<SkDevice> device;
SkAutoTUnref<SkBaseDevice> device;
if (0 == dtype) {
device.reset(new SkDevice(SkBitmap::kARGB_8888_Config, DEV_W, DEV_H, false));
device.reset(new SkBitmapDevice(SkBitmap::kARGB_8888_Config,
DEV_W, DEV_H, false));
} else {
#if SK_SUPPORT_GPU
GrContextFactory::GLContextType type =

2
tests/ReadWriteAlphaTest.cpp
View File

@ -82,7 +82,7 @@ static void ReadWriteAlphaTest(skiatest::Reporter* reporter, GrContextFactory* f
REPORTER_ASSERT(reporter, match);
// Now try writing on the single channel texture
SkAutoTUnref<SkDevice> device(new SkGpuDevice(context, texture->asRenderTarget()));
SkAutoTUnref<SkBaseDevice> device(new SkGpuDevice(context, texture->asRenderTarget()));
SkCanvas canvas(device);
SkPaint paint;

30
tests/TileGridTest.cpp
View File

@ -24,7 +24,7 @@ enum Tile {
namespace {
class MockCanvas : public SkCanvas {
public:
MockCanvas(SkDevice* device) : SkCanvas(device)
MockCanvas(SkBaseDevice* device) : SkCanvas(device)
{}
virtual void drawRect(const SkRect& rect, const SkPaint&)
@ -80,14 +80,14 @@ public:
// Test parts of top-left tile
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
picture.draw(&mockCanvas);
REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
}
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-7.99f), SkFloatToScalar(-7.99f));
picture.draw(&mockCanvas);
@ -96,7 +96,7 @@ public:
}
// Corner overlap
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-9.5f), SkFloatToScalar(-9.5f));
picture.draw(&mockCanvas);
@ -106,7 +106,7 @@ public:
}
// Intersect bottom right tile, but does not overlap rect 2
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-16.0f), SkFloatToScalar(-16.0f));
picture.draw(&mockCanvas);
@ -115,7 +115,7 @@ public:
}
// Out of bounds queries, snap to border tiles
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(2.0f), SkFloatToScalar(0.0f));
picture.draw(&mockCanvas);
@ -123,7 +123,7 @@ public:
REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
}
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(0.0f), SkFloatToScalar(2.0f));
picture.draw(&mockCanvas);
@ -131,7 +131,7 @@ public:
REPORTER_ASSERT(reporter, rect1 == mockCanvas.fRects[0]);
}
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-22.0f), SkFloatToScalar(-16.0f));
picture.draw(&mockCanvas);
@ -139,7 +139,7 @@ public:
REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
}
{
SkDevice device(store);
SkBitmapDevice device(store);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-16.0f), SkFloatToScalar(-22.0f));
picture.draw(&mockCanvas);
@ -185,7 +185,7 @@ public:
{
// The offset should cancel the top and left borders of the top left tile
// So a look-up at interval 0-10 should be grid aligned,
SkDevice device(tileBitmap);
SkBitmapDevice device(tileBitmap);
MockCanvas mockCanvas(&device);
picture.draw(&mockCanvas);
REPORTER_ASSERT(reporter, 1 == mockCanvas.fRects.count());
@ -193,7 +193,7 @@ public:
}
{
// Encroaching border by one pixel
SkDevice device(moreThanATileBitmap);
SkBitmapDevice device(moreThanATileBitmap);
MockCanvas mockCanvas(&device);
picture.draw(&mockCanvas);
REPORTER_ASSERT(reporter, 2 == mockCanvas.fRects.count());
@ -204,7 +204,7 @@ public:
// Tile stride is 8 (tileWidth - 2 * border pixels
// so translating by 8, should make query grid-aligned
// with middle tile.
SkDevice device(tileBitmap);
SkBitmapDevice device(tileBitmap);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkIntToScalar(-8), SkIntToScalar(-8));
picture.draw(&mockCanvas);
@ -212,7 +212,7 @@ public:
REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[0]);
}
{
SkDevice device(tileBitmap);
SkBitmapDevice device(tileBitmap);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-7.9f), SkFloatToScalar(-7.9f));
picture.draw(&mockCanvas);
@ -221,7 +221,7 @@ public:
REPORTER_ASSERT(reporter, rect2 == mockCanvas.fRects[1]);
}
{
SkDevice device(tileBitmap);
SkBitmapDevice device(tileBitmap);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-8.1f), SkFloatToScalar(-8.1f));
picture.draw(&mockCanvas);
@ -233,7 +233,7 @@ public:
// Regression test for crbug.com/234688
// Once the 2x2 device region is inset by margin, it yields an empty
// adjusted region, sitting right on top of the tile boundary.
SkDevice device(tinyBitmap);
SkBitmapDevice device(tinyBitmap);
MockCanvas mockCanvas(&device);
mockCanvas.translate(SkFloatToScalar(-8.0f), SkFloatToScalar(-8.0f));
picture.draw(&mockCanvas);

8
tests/WritePixelsTest.cpp
View File

@ -227,7 +227,7 @@ bool checkWrite(skiatest::Reporter* reporter,
const SkBitmap& bitmap,
int writeX, int writeY,
SkCanvas::Config8888 config8888) {
SkDevice* dev = canvas->getDevice();
SkBaseDevice* dev = canvas->getDevice();
if (!dev) {
return false;
}
@ -305,7 +305,7 @@ static const CanvasConfig gCanvasConfigs[] = {
#endif
};
SkDevice* createDevice(const CanvasConfig& c, GrContext* grCtx) {
SkBaseDevice* createDevice(const CanvasConfig& c, GrContext* grCtx) {
switch (c.fDevType) {
case kRaster_DevType: {
SkBitmap bmp;
@ -320,7 +320,7 @@ SkDevice* createDevice(const CanvasConfig& c, GrContext* grCtx) {
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:
@ -435,7 +435,7 @@ void WritePixelsTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
}
#endif
SkAutoTUnref<SkDevice> device(createDevice(gCanvasConfigs[i], context));
SkAutoTUnref<SkBaseDevice> device(createDevice(gCanvasConfigs[i], context));
SkCanvas canvas(device);
static const SkCanvas::Config8888 gSrcConfigs[] = {