rename filterTextFlags to disableLCD

src/core/SkDevice.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDevice.h"
 #include "SkDeviceProperties.h"
 #include "SkDraw.h"
 #include "SkMetaData.h"
 #include "SkPatchUtils.h"
 #include "SkShader.h"
 #include "SkTextBlob.h"
 
 SkBaseDevice::SkBaseDevice()
     : fLeakyProperties(SkNEW_ARGS(SkDeviceProperties, (SkDeviceProperties::kLegacyLCD_InitType)))
 #ifdef SK_DEBUG
     , fAttachedToCanvas(false)
 #endif
 {
     fOrigin.setZero();
     fMetaData = NULL;
 }
 
+SkBaseDevice::SkBaseDevice(const SkDeviceProperties& dp)
+    : fLeakyProperties(SkNEW_ARGS(SkDeviceProperties, (dp)))
+#ifdef SK_DEBUG
+    , fAttachedToCanvas(false)
+#endif
+{
+    fOrigin.setZero();
+    fMetaData = NULL;
+}
+
 SkBaseDevice::~SkBaseDevice() {
     SkDELETE(fLeakyProperties);
     SkDELETE(fMetaData);
 }
 
-SkBaseDevice* SkBaseDevice::createCompatibleDevice(const SkImageInfo& info) {
-    return this->onCreateCompatibleDevice(CreateInfo(info, kGeneral_Usage));
-}
-
-SkBaseDevice* SkBaseDevice::createCompatibleDeviceForSaveLayer(const SkImageInfo& info) {
-    return this->onCreateCompatibleDevice(CreateInfo(info, kSaveLayer_Usage));
-}
-
-SkBaseDevice* SkBaseDevice::createCompatibleDeviceForImageFilter(const SkImageInfo& info) {
-    return this->onCreateCompatibleDevice(CreateInfo(info, kImageFilter_Usage));
-}
-
 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) {
         fMetaData = new SkMetaData;
     }
     return *fMetaData;
 }
 
 SkImageInfo SkBaseDevice::imageInfo() const {
     return SkImageInfo::MakeUnknown();
 }
 
 const SkBitmap& SkBaseDevice::accessBitmap(bool changePixels) {
     const SkBitmap& bitmap = this->onAccessBitmap();
     if (changePixels) {
         bitmap.notifyPixelsChanged();
     }
     return bitmap;
 }
 
-void SkBaseDevice::setPixelGeometry(SkPixelGeometry geo) {
-    fLeakyProperties->setPixelGeometry(geo);
+SkPixelGeometry SkBaseDevice::CreateInfo::AdjustGeometry(const SkImageInfo& info,
+                                                         Usage usage,
+                                                         SkPixelGeometry geo) {
+    switch (usage) {
+        case kGeneral_Usage:
+            break;
+        case kSaveLayer_Usage:
+            if (info.alphaType() != kOpaque_SkAlphaType) {
+                geo = kUnknown_SkPixelGeometry;
+            }
+            break;
+        case kImageFilter_Usage:
+            geo = kUnknown_SkPixelGeometry;
+            break;
+    }
+    return geo;
+}
+
+void SkBaseDevice::initForRootLayer(SkPixelGeometry geo) {
+    // For now we don't expect to change the geometry for the root-layer, but we make the call
+    // anyway to document logically what is going on.
+    //
+    fLeakyProperties->setPixelGeometry(CreateInfo::AdjustGeometry(this->imageInfo(),
+                                                                  kGeneral_Usage,
+                                                                  geo));
 }
 
 SkSurface* SkBaseDevice::newSurface(const SkImageInfo&, const SkSurfaceProps&) { return NULL; }
 
 const void* SkBaseDevice::peekPixels(SkImageInfo*, size_t*) { return NULL; }
 
 void SkBaseDevice::drawDRRect(const SkDraw& draw, const SkRRect& outer,
                               const SkRRect& inner, const SkPaint& paint) {
     SkPath path;
     path.addRRect(outer);
@@ skipping 104 matching lines @@
 
 void* SkBaseDevice::onAccessPixels(SkImageInfo* info, size_t* rowBytes) {
     return NULL;
 }
 
 bool SkBaseDevice::EXPERIMENTAL_drawPicture(SkCanvas*, const SkPicture*, const SkMatrix*,
                                             const SkPaint*) {
     // The base class doesn't perform any accelerated picture rendering
     return false;
 }
+
+//////////////////////////////////////////////////////////////////////////////////////////
+
+bool SkBaseDevice::shouldDisableLCD(const SkPaint& paint) const {
+    if (!paint.isLCDRenderText() || !paint.isAntiAlias()) {
+        return false;
+    }
+
+    if (kUnknown_SkPixelGeometry == fLeakyProperties->pixelGeometry()) {
+        return true;
+    }
+
+    return this->onShouldDisableLCD(paint);
+}
+