rename filterTextFlags to disableLCD

src/core/SkCanvas.cpp

 /*
  * Copyright 2008 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkCanvasDrawable.h"
 #include "SkCanvasPriv.h"
@@ skipping 387 matching lines @@
 #define LOOPER_BEGIN(paint, type, bounds)                           \
     this->predrawNotify();                                          \
     AutoDrawLooper  looper(this, fProps, paint, false, bounds);     \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_END    }
 
 ////////////////////////////////////////////////////////////////////////////
 
-void SkCanvas::setupDevice(SkBaseDevice* device) {
-    device->setPixelGeometry(fProps.pixelGeometry());
-}
-
 SkBaseDevice* SkCanvas::init(SkBaseDevice* device, InitFlags flags) {
     fConservativeRasterClip = SkToBool(flags & kConservativeRasterClip_InitFlag);
     fCachedLocalClipBounds.setEmpty();
     fCachedLocalClipBoundsDirty = true;
     fAllowSoftClip = true;
     fAllowSimplifyClip = false;
     fDeviceCMDirty = true;
     fSaveLayerCount = 0;
     fCullCount = 0;
     fMetaData = NULL;
 
     fMCRec = (MCRec*)fMCStack.push_back();
     new (fMCRec) MCRec(fConservativeRasterClip);
 
     fMCRec->fLayer = SkNEW_ARGS(DeviceCM, (NULL, 0, 0, NULL, NULL, fConservativeRasterClip));
     fMCRec->fTopLayer = fMCRec->fLayer;
 
     fSurfaceBase = NULL;
 
     if (device) {
-        this->setupDevice(device);
+        device->initForRootLayer(fProps.pixelGeometry());
         if (device->forceConservativeRasterClip()) {
             fConservativeRasterClip = true;
         }
         device->onAttachToCanvas(this);
         fMCRec->fLayer->fDevice = SkRef(device);
         fMCRec->fRasterClip.setRect(SkIRect::MakeWH(device->width(), device->height()));
     }
     return device;
 }
 
@@ skipping 151 matching lines @@
     MCRec*           rec = (MCRec*)iter.next();
     SkASSERT(rec && rec->fLayer);
     SkBaseDevice*    rootDevice = rec->fLayer->fDevice;
 
     if (rootDevice == device) {
         return device;
     }
 
     if (device) {
         device->onAttachToCanvas(this);
+        device->initForRootLayer(fProps.pixelGeometry());
     }
     if (rootDevice) {
         rootDevice->onDetachFromCanvas();
     }
 
     SkRefCnt_SafeAssign(rec->fLayer->fDevice, device);
     rootDevice = device;
-    this->setupDevice(device);
 
     fDeviceCMDirty = true;
 
     /*  Now we update our initial region to have the bounds of the new device,
         and then intersect all of the clips in our stack with these bounds,
         to ensure that we can't draw outside of the device's bounds (and trash
                                                                      memory).
 
     NOTE: this is only a partial-fix, since if the new device is larger than
         the previous one, we don't know how to "enlarge" the clips in our stack,
@@ skipping 302 matching lines @@
             SkPaint* p = lazyP.set(*paint);
             p->setImageFilter(NULL);
             paint = p;
         }
     }
 
     bool isOpaque = !SkToBool(flags & kHasAlphaLayer_SaveFlag);
     SkImageInfo info = SkImageInfo::MakeN32(ir.width(), ir.height(),
                         isOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
 
-    SkBaseDevice* device;
+    SkBaseDevice* device = this->getTopDevice();
+    if (NULL == device) {
+        SkDebugf("Unable to find device for layer.");
+        return count;
+    }
+
+    SkBaseDevice::Usage usage = SkBaseDevice::kSaveLayer_Usage;
     if (paint && paint->getImageFilter()) {
-        device = this->getDevice();
-        if (device) {
-            device = device->createCompatibleDeviceForImageFilter(info);
-        }
-    } else {
-        device = this->createLayerDevice(info);
+        usage = SkBaseDevice::kImageFilter_Usage;
     }
+    device = device->onCreateCompatibleDevice(SkBaseDevice::CreateInfo(info, usage,
+                                                                       fProps.pixelGeometry()));
     if (NULL == device) {
         SkDebugf("Unable to create device for layer.");
         return count;
     }
-    this->setupDevice(device);
 
     device->setOrigin(ir.fLeft, ir.fTop);
     DeviceCM* layer = SkNEW_ARGS(DeviceCM,
                                  (device, ir.fLeft, ir.fTop, paint, this, fConservativeRasterClip));
     device->unref();
 
     layer->fNext = fMCRec->fTopLayer;
     fMCRec->fLayer = layer;
     fMCRec->fTopLayer = layer;    // this field is NOT an owner of layer
 
@@ skipping 700 matching lines @@
 
 const SkRegion& SkCanvas::internal_private_getTotalClip() const {
     return fMCRec->fRasterClip.forceGetBW();
 }
 
 GrRenderTarget* SkCanvas::internal_private_accessTopLayerRenderTarget() {
     SkBaseDevice* dev = this->getTopDevice();
     return dev ? dev->accessRenderTarget() : NULL;
 }
 
-SkBaseDevice* SkCanvas::createLayerDevice(const SkImageInfo& info) {
-    SkBaseDevice* device = this->getTopDevice();
-    return device ? device->createCompatibleDeviceForSaveLayer(info) : NULL;
-}
-
 GrContext* SkCanvas::getGrContext() {
 #if SK_SUPPORT_GPU
     SkBaseDevice* device = this->getTopDevice();
     if (device) {
         GrRenderTarget* renderTarget = device->accessRenderTarget();
         if (renderTarget) {
             return renderTarget->getContext();
         }
     }
 #endif
@@ skipping 372 matching lines @@
     TRACE_EVENT0("skia", "SkCanvas::drawBitmapNine()");
     SkDEBUGCODE(bitmap.validate();)
 
     // Need a device entry-point, so gpu can use a mesh
     this->internalDrawBitmapNine(bitmap, center, dst, paint);
 }
 
 class SkDeviceFilteredPaint {
 public:
     SkDeviceFilteredPaint(SkBaseDevice* device, const SkPaint& paint) {
-        SkBaseDevice::TextFlags flags;
-        if (device->filterTextFlags(paint, &flags)) {
+        if (device->shouldDisableLCD(paint)) {
+            uint32_t flags = paint.getFlags();
+            flags &= ~SkPaint::kLCDRenderText_Flag;
+            flags |= SkPaint::kGenA8FromLCD_Flag;
             SkPaint* newPaint = fLazy.set(paint);
-            newPaint->setFlags(flags.fFlags);
+            newPaint->setFlags(flags);
             fPaint = newPaint;
         } else {
             fPaint = &paint;
         }
     }
 
     const SkPaint& paint() const { return *fPaint; }
 
 private:
     const SkPaint*  fPaint;
@@ skipping 512 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }