зеркало из https://github.com/mozilla/moz-skia.git
remove SkDeviceFactory from the collective consciousness, now that devices know
how to create compatible siblings. git-svn-id: http://skia.googlecode.com/svn/trunk@1808 2bbb7eff-a529-9590-31e7-b0007b416f81
This commit is contained in:
reed@google.com
Родитель
1e257a5db3
Коммит
cde92111d5
|
|
@ -52,15 +52,7 @@ class SkPicture;
|
|||
*/
|
||||
class SK_API SkCanvas : public SkRefCnt {
|
||||
public:
|
||||
/**
|
||||
DEPRECATED: Will be replaced by SkDevice::createCompatibleDevice
|
||||
|
||||
Construct a canvas with the given device factory.
|
||||
@param factory Specify the factory for generating additional devices.
|
||||
The factory may be null, in which case
|
||||
SkRasterDeviceFactory will be used.
|
||||
*/
|
||||
explicit SkCanvas(SkDeviceFactory* factory = NULL);
|
||||
SkCanvas();
|
||||
|
||||
/** Construct a canvas with the specified device to draw into. The device
|
||||
factory will be retrieved from the passed device.
|
||||
|
|
@ -106,24 +98,8 @@ public:
|
|||
SkDevice* setBitmapDevice(const SkBitmap& bitmap);
|
||||
|
||||
/**
|
||||
* DEPRECATED: Will be replaced by SkDevice::createCompatibleDevice
|
||||
*
|
||||
* Return the current device factory, or NULL. The reference count of
|
||||
* the returned factory is not changed.
|
||||
*/
|
||||
SkDeviceFactory* getDeviceFactory() const { return fDeviceFactory; }
|
||||
|
||||
/**
|
||||
* DEPRECATED: Will be replaced by SkDevice::createCompatibleDevice
|
||||
*
|
||||
* Replace any existing factory with the specified factory, unrefing the
|
||||
* previous (if any), and refing the new one (if any). For convenience,
|
||||
* the factory parameter is also returned.
|
||||
*/
|
||||
SkDeviceFactory* setDeviceFactory(SkDeviceFactory*);
|
||||
|
||||
/**
|
||||
* Shortcut for getDevice()->createCompatibleDevice(...)
|
||||
* Shortcut for getDevice()->createCompatibleDevice(...).
|
||||
* If getDevice() == NULL, this method does nothing, and returns NULL.
|
||||
*/
|
||||
SkDevice* createCompatibleDevice(SkBitmap::Config config,
|
||||
int width, int height,
|
||||
|
|
|
|||
|
|
@ -30,28 +30,6 @@ class SkMatrix;
|
|||
class SkMetaData;
|
||||
class SkRegion;
|
||||
|
||||
/** \class SkDeviceFactory
|
||||
|
||||
DEPRECATED: Will be replaced by SkDevice::createCompatibleDevice
|
||||
|
||||
Devices that extend SkDevice should also provide a SkDeviceFactory class
|
||||
to pass into SkCanvas. Doing so will eliminate the need to extend
|
||||
SkCanvas as well.
|
||||
*/
|
||||
class SK_API SkDeviceFactory : public SkRefCnt {
|
||||
public:
|
||||
SkDeviceFactory();
|
||||
virtual ~SkDeviceFactory();
|
||||
virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
|
||||
int height, bool isOpaque, bool isLayer) = 0;
|
||||
};
|
||||
|
||||
class SkRasterDeviceFactory : public SkDeviceFactory {
|
||||
public:
|
||||
virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
|
||||
int height, bool isOpaque, bool isLayer);
|
||||
};
|
||||
|
||||
class SK_API SkDevice : public SkRefCnt {
|
||||
public:
|
||||
// SkDevice();
|
||||
|
|
@ -80,15 +58,6 @@ public:
|
|||
|
||||
virtual ~SkDevice();
|
||||
|
||||
/**
|
||||
* DEPRECATED: Will be replaced by SkDevice::createCompatibleDevice
|
||||
*
|
||||
* Return the factory that will create this subclass of SkDevice.
|
||||
* The returned factory is cached by the device, and so its reference count
|
||||
* is not changed by this call.
|
||||
*/
|
||||
SkDeviceFactory* getDeviceFactory();
|
||||
|
||||
/**
|
||||
* Creates a device that is of the same type as this device (e.g. SW-raster,
|
||||
* GPU, or PDF). The backing store for this device is created automatically
|
||||
|
|
@ -282,17 +251,6 @@ public:
|
|||
virtual bool filterTextFlags(const SkPaint& paint, TextFlags*);
|
||||
|
||||
protected:
|
||||
/**
|
||||
* DEPRECATED: Will be replaced by SkDevice::createCompatibleDevice
|
||||
*
|
||||
* subclasses can override this to return a new (or ref'd) instance of
|
||||
* a device factory that will create this subclass of device. This value
|
||||
* is cached, so it should get called at most once for a given instance.
|
||||
*
|
||||
* If not overriden then createCompatibleDevice will be used by canvas.
|
||||
*/
|
||||
virtual SkDeviceFactory* onNewDeviceFactory();
|
||||
|
||||
/** 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.
|
||||
|
|
@ -330,8 +288,6 @@ private:
|
|||
SkBitmap fBitmap;
|
||||
SkIPoint fOrigin;
|
||||
SkMetaData* fMetaData;
|
||||
|
||||
SkDeviceFactory* fCachedDeviceFactory;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -168,10 +168,12 @@ public:
|
|||
kDevKernText_Flag = 0x02,
|
||||
kGammaForBlack_Flag = 0x04, // illegal to set both Gamma flags
|
||||
kGammaForWhite_Flag = 0x08, // illegal to set both Gamma flags
|
||||
|
||||
// together, these two flags resulting in a two bit value which matches
|
||||
// up with the SkPaint::Hinting enum.
|
||||
kHintingBit1_Flag = 0x10,
|
||||
kHintingBit2_Flag = 0x20,
|
||||
|
||||
kEmbeddedBitmapText_Flag = 0x40,
|
||||
kEmbolden_Flag = 0x80,
|
||||
kSubpixelPositioning_Flag = 0x100,
|
||||
|
|
|
|||
|
|
@ -1,58 +0,0 @@
|
|||
/*
|
||||
Copyright 2010 Google Inc.
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
*/
|
||||
|
||||
#ifndef SkGpuDeviceFactory_DEFINED
|
||||
#define SkGpuDeviceFactory_DEFINED
|
||||
|
||||
#include "SkDevice.h"
|
||||
|
||||
class GrContext;
|
||||
|
||||
class SK_API SkGpuDeviceFactory : public SkDeviceFactory {
|
||||
public:
|
||||
/**
|
||||
* The constructor will ref() the context, passing it to each device
|
||||
* that it creates. It will be unref()'d in the destructor
|
||||
* Non-layered devices created by the factory will draw to the
|
||||
* rootRenderTarget. rootRenderTarget is ref-counted by the factory.
|
||||
* SkGpuDevice::Current3DApiRenderTarget() can be passed as a special
|
||||
* value that will cause the factory to create a render target object
|
||||
* that reflects the state of the underlying 3D API at the time of
|
||||
* construction.
|
||||
*/
|
||||
SkGpuDeviceFactory(GrContext*, GrRenderTarget* rootRenderTarget);
|
||||
|
||||
/**
|
||||
* When the root layer is both a GrRenderTarget and a GrTexture it
|
||||
* is handy to have the factory hang on to a ref to the GrTexture object.
|
||||
* This is because the GrTexture has a ref to the GrRenderTarget but not
|
||||
* vice-versa.
|
||||
*/
|
||||
SkGpuDeviceFactory(GrContext*, GrTexture* rootRenderTargetTexture);
|
||||
|
||||
virtual ~SkGpuDeviceFactory();
|
||||
|
||||
virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
|
||||
int height, bool isOpaque, bool isLayer);
|
||||
|
||||
private:
|
||||
GrContext* fContext;
|
||||
GrRenderTarget* fRootRenderTarget;
|
||||
GrTexture* fRootTexture;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -39,12 +39,6 @@ class SkPDFStream;
|
|||
struct ContentEntry;
|
||||
struct GraphicStateEntry;
|
||||
|
||||
class SkPDFDeviceFactory : public SkDeviceFactory {
|
||||
public:
|
||||
virtual SkDevice* newDevice(SkCanvas*, SkBitmap::Config, int width,
|
||||
int height, bool isOpaque, bool isForLayer);
|
||||
};
|
||||
|
||||
/** \class SkPDFDevice
|
||||
|
||||
The drawing context for the PDF backend.
|
||||
|
|
@ -65,7 +59,7 @@ public:
|
|||
* a scale+translate transform to move the origin from the
|
||||
* bottom left (PDF default) to the top left. Note2: drawDevice
|
||||
* (used by layer restore) draws the device after this initial
|
||||
* transform is applied, so the PDF device factory does an
|
||||
* transform is applied, so the PDF device does an
|
||||
* inverse scale+translate to accommodate the one that SkPDFDevice
|
||||
* always does.
|
||||
*/
|
||||
|
|
@ -150,12 +144,7 @@ public:
|
|||
return fInitialTransform;
|
||||
}
|
||||
|
||||
protected:
|
||||
// override
|
||||
virtual SkDeviceFactory* onNewDeviceFactory();
|
||||
|
||||
private:
|
||||
friend class SkPDFDeviceFactory;
|
||||
// TODO(vandebo) push most of SkPDFDevice's state into a core object in
|
||||
// order to get the right access levels without using friend.
|
||||
friend class ScopedContentEntry;
|
||||
|
|
@ -175,7 +164,6 @@ private:
|
|||
SkTScopedPtr<ContentEntry> fContentEntries;
|
||||
ContentEntry* fLastContentEntry;
|
||||
|
||||
// For use by the DeviceFactory.
|
||||
SkPDFDevice(const SkISize& layerSize, const SkClipStack& existingClipStack,
|
||||
const SkRegion& existingClipRegion);
|
||||
|
||||
|
|
|
|||
|
|
@ -419,17 +419,10 @@ SkDevice* SkCanvas::init(SkDevice* device) {
|
|||
return this->setDevice(device);
|
||||
}
|
||||
|
||||
SkCanvas::SkCanvas(SkDeviceFactory* factory)
|
||||
: fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
|
||||
SkCanvas::SkCanvas()
|
||||
: fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
|
||||
inc_canvas();
|
||||
|
||||
if (factory) {
|
||||
factory->ref();
|
||||
} else {
|
||||
factory = SkNEW(SkRasterDeviceFactory);
|
||||
}
|
||||
fDeviceFactory = factory;
|
||||
|
||||
|
||||
this->init(NULL);
|
||||
}
|
||||
|
||||
|
|
@ -437,9 +430,6 @@ SkCanvas::SkCanvas(SkDevice* device)
|
|||
: fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
|
||||
inc_canvas();
|
||||
|
||||
fDeviceFactory = device->getDeviceFactory();
|
||||
SkSafeRef(fDeviceFactory);
|
||||
|
||||
this->init(device);
|
||||
}
|
||||
|
||||
|
|
@ -447,11 +437,7 @@ SkCanvas::SkCanvas(const SkBitmap& bitmap)
|
|||
: fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage)) {
|
||||
inc_canvas();
|
||||
|
||||
SkDevice* device = SkNEW_ARGS(SkDevice, (bitmap));
|
||||
fDeviceFactory = device->getDeviceFactory();
|
||||
SkSafeRef(fDeviceFactory);
|
||||
|
||||
this->init(device)->unref();
|
||||
this->init(SkNEW_ARGS(SkDevice, (bitmap)))->unref();
|
||||
}
|
||||
|
||||
SkCanvas::~SkCanvas() {
|
||||
|
|
@ -460,7 +446,6 @@ SkCanvas::~SkCanvas() {
|
|||
this->internalRestore(); // restore the last, since we're going away
|
||||
|
||||
SkSafeUnref(fBounder);
|
||||
SkSafeUnref(fDeviceFactory);
|
||||
|
||||
dec_canvas();
|
||||
}
|
||||
|
|
@ -508,10 +493,6 @@ SkDevice* SkCanvas::setDevice(SkDevice* device) {
|
|||
things like lock/unlock their pixels, etc.
|
||||
*/
|
||||
if (device) {
|
||||
// To mirror our (SkDevice*) constructor, we grab the factory from the
|
||||
// new device
|
||||
this->setDeviceFactory(device->getDeviceFactory());
|
||||
|
||||
device->lockPixels();
|
||||
}
|
||||
if (rootDevice) {
|
||||
|
|
@ -573,11 +554,6 @@ bool SkCanvas::readPixels(const SkIRect& srcRect, SkBitmap* bitmap) {
|
|||
return device->readPixels(srcRect, bitmap);
|
||||
}
|
||||
|
||||
SkDeviceFactory* SkCanvas::setDeviceFactory(SkDeviceFactory* factory) {
|
||||
SkRefCnt_SafeAssign(fDeviceFactory, factory);
|
||||
return factory;
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
bool SkCanvas::readPixels(SkBitmap* bitmap) {
|
||||
|
|
@ -1185,13 +1161,12 @@ void SkCanvas::setExternalMatrix(const SkMatrix* matrix) {
|
|||
SkDevice* SkCanvas::createLayerDevice(SkBitmap::Config config,
|
||||
int width, int height,
|
||||
bool isOpaque) {
|
||||
if (fDeviceFactory) {
|
||||
return fDeviceFactory->newDevice(this, config, width, height,
|
||||
isOpaque, true);
|
||||
SkDevice* device = this->getDevice();
|
||||
if (device) {
|
||||
return device->createCompatibleDeviceForSaveLayer(config, width, height,
|
||||
isOpaque);
|
||||
} else {
|
||||
return this->getDevice()->createCompatibleDeviceForSaveLayer(
|
||||
config, width, height,
|
||||
isOpaque);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1200,8 +1175,7 @@ SkDevice* SkCanvas::createCompatibleDevice(SkBitmap::Config config,
|
|||
bool isOpaque) {
|
||||
SkDevice* device = this->getDevice();
|
||||
if (device) {
|
||||
return device->createCompatibleDevice(config, width, height,
|
||||
isOpaque);
|
||||
return device->createCompatibleDevice(config, width, height, isOpaque);
|
||||
} else {
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,45 +3,16 @@
|
|||
#include "SkMetaData.h"
|
||||
#include "SkRect.h"
|
||||
|
||||
//#define TRACE_FACTORY_LIFETIME
|
||||
|
||||
#ifdef TRACE_FACTORY_LIFETIME
|
||||
static int gFactoryCounter;
|
||||
#endif
|
||||
|
||||
SkDeviceFactory::SkDeviceFactory() {
|
||||
#ifdef TRACE_FACTORY_LIFETIME
|
||||
SkDebugf("+++ factory index %d\n", gFactoryCounter);
|
||||
++gFactoryCounter;
|
||||
#endif
|
||||
}
|
||||
|
||||
SkDeviceFactory::~SkDeviceFactory() {
|
||||
#ifdef TRACE_FACTORY_LIFETIME
|
||||
--gFactoryCounter;
|
||||
SkDebugf("--- factory index %d\n", gFactoryCounter);
|
||||
#endif
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#if 0
|
||||
SkDevice::SkDevice() : fMetaData(NULL) {
|
||||
fOrigin.setZero();
|
||||
fCachedDeviceFactory = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
SkDevice::SkDevice(const SkBitmap& bitmap) : fBitmap(bitmap) {
|
||||
fOrigin.setZero();
|
||||
fMetaData = NULL;
|
||||
fCachedDeviceFactory = NULL;
|
||||
}
|
||||
|
||||
SkDevice::SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque) {
|
||||
fOrigin.setZero();
|
||||
fMetaData = NULL;
|
||||
fCachedDeviceFactory = NULL;
|
||||
|
||||
fBitmap.setConfig(config, width, height);
|
||||
fBitmap.allocPixels();
|
||||
|
|
@ -53,18 +24,6 @@ SkDevice::SkDevice(SkBitmap::Config config, int width, int height, bool isOpaque
|
|||
|
||||
SkDevice::~SkDevice() {
|
||||
delete fMetaData;
|
||||
SkSafeUnref(fCachedDeviceFactory);
|
||||
}
|
||||
|
||||
SkDeviceFactory* SkDevice::onNewDeviceFactory() {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
SkDeviceFactory* SkDevice::getDeviceFactory() {
|
||||
if (NULL == fCachedDeviceFactory) {
|
||||
fCachedDeviceFactory = this->onNewDeviceFactory();
|
||||
}
|
||||
return fCachedDeviceFactory;
|
||||
}
|
||||
|
||||
SkDevice* SkDevice::createCompatibleDevice(SkBitmap::Config config,
|
||||
|
|
@ -278,19 +237,3 @@ bool SkDevice::filterTextFlags(const SkPaint& paint, TextFlags* flags) {
|
|||
return false;
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkDevice* SkRasterDeviceFactory::newDevice(SkCanvas*,
|
||||
SkBitmap::Config config, int width,
|
||||
int height, bool isOpaque,
|
||||
bool isForLayer) {
|
||||
if (isForLayer) {
|
||||
return SkNEW_ARGS(SkDevice, (config, width, height, isOpaque));
|
||||
} else {
|
||||
// should we ever get here?
|
||||
SkBitmap bitmap;
|
||||
bitmap.setConfig(config, width, height);
|
||||
bitmap.setIsOpaque(isOpaque);
|
||||
return SkNEW_ARGS(SkDevice, (bitmap));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,18 +19,15 @@
|
|||
|
||||
#include "SkGpuCanvas.h"
|
||||
#include "SkGpuDevice.h"
|
||||
#include "SkGpuDeviceFactory.h"
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkGpuCanvas::SkGpuCanvas(GrContext* context, GrRenderTarget* renderTarget) {
|
||||
SkDeviceFactory* factory = SkNEW_ARGS(SkGpuDeviceFactory,
|
||||
(context, renderTarget));
|
||||
this->setDeviceFactory(factory)->unref();
|
||||
|
||||
SkASSERT(context);
|
||||
fContext = context;
|
||||
fContext->ref();
|
||||
|
||||
this->setDevice(new SkGpuDevice(context, renderTarget))->unref();
|
||||
}
|
||||
|
||||
SkGpuCanvas::~SkGpuCanvas() {
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@
|
|||
#include "GrTextContext.h"
|
||||
|
||||
#include "SkGpuDevice.h"
|
||||
#include "SkGpuDeviceFactory.h"
|
||||
#include "SkGrTexturePixelRef.h"
|
||||
|
||||
#include "SkColorFilter.h"
|
||||
|
|
@ -47,6 +46,7 @@ enum {
|
|||
kShaderTextureIdx = 0
|
||||
};
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkGpuDevice::SkAutoCachedTexture::
|
||||
|
|
@ -1494,58 +1494,3 @@ SkDevice* SkGpuDevice::onCreateCompatibleDevice(SkBitmap::Config config,
|
|||
width, height, usage));
|
||||
}
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkGpuDeviceFactory::SkGpuDeviceFactory(GrContext* context,
|
||||
GrRenderTarget* rootRenderTarget) {
|
||||
GrAssert(NULL != context);
|
||||
GrAssert(NULL != rootRenderTarget);
|
||||
|
||||
// check this now rather than passing this value to SkGpuDevice cons.
|
||||
// we want the rt that is bound *now* in the 3D API, not the one
|
||||
// at the time of newDevice.
|
||||
if (SkGpuDevice::Current3DApiRenderTarget() == rootRenderTarget) {
|
||||
fRootRenderTarget = context->createRenderTargetFrom3DApiState();
|
||||
} else {
|
||||
fRootRenderTarget = rootRenderTarget;
|
||||
rootRenderTarget->ref();
|
||||
}
|
||||
|
||||
fContext = context;
|
||||
context->ref();
|
||||
|
||||
fRootTexture = NULL;
|
||||
}
|
||||
|
||||
SkGpuDeviceFactory::SkGpuDeviceFactory(GrContext* context, GrTexture* rootRenderTargetTexture) {
|
||||
GrAssert(NULL != context);
|
||||
GrAssert(NULL != rootRenderTargetTexture);
|
||||
GrAssert(NULL != rootRenderTargetTexture->asRenderTarget());
|
||||
|
||||
fRootTexture = rootRenderTargetTexture;
|
||||
rootRenderTargetTexture->ref();
|
||||
|
||||
fRootRenderTarget = rootRenderTargetTexture->asRenderTarget();
|
||||
fRootRenderTarget->ref();
|
||||
|
||||
fContext = context;
|
||||
context->ref();
|
||||
}
|
||||
|
||||
SkGpuDeviceFactory::~SkGpuDeviceFactory() {
|
||||
fContext->unref();
|
||||
fRootRenderTarget->unref();
|
||||
GrSafeUnref(fRootTexture);
|
||||
}
|
||||
|
||||
SkDevice* SkGpuDeviceFactory::newDevice(SkCanvas*, SkBitmap::Config config,
|
||||
int width, int height,
|
||||
bool isOpaque, bool isLayer) {
|
||||
if (isLayer) {
|
||||
return SkNEW_ARGS(SkGpuDevice, (fContext, config, width, height));
|
||||
} else {
|
||||
return SkNEW_ARGS(SkGpuDevice, (fContext, fRootRenderTarget));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -487,20 +487,6 @@ private:
|
|||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
SkDevice* SkPDFDeviceFactory::newDevice(SkCanvas* c, SkBitmap::Config config,
|
||||
int width, int height, bool isOpaque,
|
||||
bool isForLayer) {
|
||||
SkMatrix initialTransform;
|
||||
initialTransform.reset();
|
||||
SkISize size = SkISize::Make(width, height);
|
||||
if (isForLayer) {
|
||||
return SkNEW_ARGS(SkPDFDevice, (size, c->getTotalClipStack(),
|
||||
c->getTotalClip()));
|
||||
} else {
|
||||
return SkNEW_ARGS(SkPDFDevice, (size, size, initialTransform));
|
||||
}
|
||||
}
|
||||
|
||||
static inline SkBitmap makeContentBitmap(const SkISize& contentSize,
|
||||
const SkMatrix* initialTransform) {
|
||||
SkBitmap bitmap;
|
||||
|
|
@ -565,10 +551,6 @@ void SkPDFDevice::init() {
|
|||
fLastContentEntry = NULL;
|
||||
}
|
||||
|
||||
SkDeviceFactory* SkPDFDevice::onNewDeviceFactory() {
|
||||
return SkNEW(SkPDFDeviceFactory);
|
||||
}
|
||||
|
||||
void SkPDFDevice::cleanUp() {
|
||||
fGraphicStateResources.unrefAll();
|
||||
fXObjectResources.unrefAll();
|
||||
|
|
|
|||
Загрузка…
Ссылка в новой задаче