introduce Props to surface

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 "SkCanvasPriv.h"
@@ skipping 49 matching lines @@
 typedef SkTLazy<SkPaint> SkLazyPaint;
 
 void SkCanvas::predrawNotify() {
     if (fSurfaceBase) {
         fSurfaceBase->aboutToDraw(SkSurface::kRetain_ContentChangeMode);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+static bool disable_lcd(const SkSurfaceProps& props) {
+    return kUnknown_SkPixelGeometry == props.fPixelGeometry;
+}
+
+static bool disable_lcd(const SkPaint& paint) {
+    return paint.getRasterizer() || paint.getPathEffect() || paint.isFakeBoldText() ||

[robertphillips, 2014/09/16 14:15:18]

Tab these two lines over?

[reed1, 2014/09/16 18:16:01]

Done.

+    paint.getStyle() != SkPaint::kFill_Style ||
+    !SkXfermode::IsMode(paint.getXfermode(), SkXfermode::kSrcOver_Mode);
+}
+
+void apply_props_to_paint(const SkSurfaceProps& props, SkPaint* paint) {
+    uint32_t clearMask = 0;
+    
+    if (paint->isDither() && (props.fDisallowFlags & SkSurfaceProps::kDither_DisallowFlag)) {
+        clearMask |= SkPaint::kDither_Flag;
+    }
+    if (paint->isAntiAlias()) {
+        if (props.fDisallowFlags & SkSurfaceProps::kAntiAlias_DisallowFlag) {
+            clearMask |= SkPaint::kAntiAlias_Flag;
+        } else if (paint->isLCDRenderText() && (disable_lcd(props) || disable_lcd(*paint))) {
+            clearMask |= SkPaint::kLCDRenderText_Flag;
+        }
+    }
+    if (clearMask) {
+        paint->setFlags(paint->getFlags() & ~clearMask);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /*  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
     values: they reflect the top of the save stack, but translated and clipped
     by the device's XY offset and bitmap-bounds.
 */
 struct DeviceCM {
     DeviceCM*           fNext;
     SkBaseDevice*       fDevice;
@@ skipping 163 matching lines @@
     const SkPaint*  fPaint;     // May be null.
     SkBool8         fSkipEmptyClips;
 
     typedef SkDraw INHERITED;
 };
 
 /////////////////////////////////////////////////////////////////////////////
 
 class AutoDrawLooper {
 public:
-    AutoDrawLooper(SkCanvas* canvas, const SkPaint& paint,
+    AutoDrawLooper(SkCanvas* canvas, const SkSurfaceProps& props, const SkPaint& paint,
                    bool skipLayerForImageFilter = false,
-                   const SkRect* bounds = NULL) : fOrigPaint(paint) {
+                   const SkRect* bounds = NULL) : fProps(props), fOrigPaint(paint) {
         fCanvas = canvas;
         fFilter = canvas->getDrawFilter();
         fPaint = NULL;
         fSaveCount = canvas->getSaveCount();
         fDoClearImageFilter = false;
         fDone = false;
 
         if (!skipLayerForImageFilter && fOrigPaint.getImageFilter()) {
             SkPaint tmp;
             tmp.setImageFilter(fOrigPaint.getImageFilter());
@@ skipping 36 matching lines @@
             fPaint = &fOrigPaint;
             return !fPaint->nothingToDraw();
         } else {
             return this->doNext(drawType);
         }
     }
 
 private:
     SkLazyPaint     fLazyPaint;
     SkCanvas*       fCanvas;
+    const SkSurfaceProps& fProps;
     const SkPaint&  fOrigPaint;
     SkDrawFilter*   fFilter;
     const SkPaint*  fPaint;
     int             fSaveCount;
     bool            fDoClearImageFilter;
     bool            fDone;
     bool            fIsSimple;
     SkDrawLooper::Context* fLooperContext;
     SkSmallAllocator<1, 32> fLooperContextAllocator;
 
     bool doNext(SkDrawFilter::Type drawType);
 };
 
 bool AutoDrawLooper::doNext(SkDrawFilter::Type drawType) {
     fPaint = NULL;
     SkASSERT(!fIsSimple);
     SkASSERT(fLooperContext || fFilter || fDoClearImageFilter);
 
     SkPaint* paint = fLazyPaint.set(fOrigPaint);
 
     if (fDoClearImageFilter) {
         paint->setImageFilter(NULL);
     }
+    apply_props_to_paint(fProps, paint);
 
     if (fLooperContext && !fLooperContext->next(fCanvas, paint)) {
         fDone = true;
         return false;
     }
     if (fFilter) {
         if (!fFilter->filter(paint, drawType)) {
             fDone = true;
             return false;
         }
@@ skipping 16 matching lines @@
     }
     return true;
 }
 
 #include "SkColorPriv.h"
 
 ////////// macros to place around the internal draw calls //////////////////
 
 #define LOOPER_BEGIN_DRAWDEVICE(paint, type)                        \
     this->predrawNotify();                                          \
-    AutoDrawLooper  looper(this, paint, true);                      \
+    AutoDrawLooper  looper(this, fProps, paint, true);              \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_BEGIN(paint, type, bounds)                           \
     this->predrawNotify();                                          \
-    AutoDrawLooper  looper(this, paint, false, bounds);             \
+    AutoDrawLooper  looper(this, fProps, paint, false, bounds);     \
     while (looper.next(type)) {                                     \
         SkDrawIter          iter(this);
 
 #define LOOPER_END    }
 
 ////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkCanvas::init(SkBaseDevice* device, InitFlags flags) {
     fConservativeRasterClip = SkToBool(flags & kConservativeRasterClip_InitFlag);
     fCachedLocalClipBounds.setEmpty();
@@ skipping 73 matching lines @@
 }
 
 SkCanvas::SkCanvas(SkBaseDevice* device)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
 {
     inc_canvas();
     
     this->init(device, kDefault_InitFlags);
 }
 
-SkCanvas::SkCanvas(const SkBitmap& bitmap)
+SkCanvas::SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps* props)
     : fMCStack(sizeof(MCRec), fMCRecStorage, sizeof(fMCRecStorage))
+    , fProps(props ? *props : SkSurfaceProps())
 {
     inc_canvas();
 
-    this->init(SkNEW_ARGS(SkBitmapDevice, (bitmap)), kDefault_InitFlags)->unref();
+    SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (bitmap)));
+    this->init(device, kDefault_InitFlags);
 }
 
 SkCanvas::~SkCanvas() {
     // free up the contents of our deque
     this->restoreToCount(1);    // restore everything but the last
     SkASSERT(0 == fSaveLayerCount);
 
     this->internalRestore();    // restore the last, since we're going away
 
     SkDELETE(fMetaData);
@@ skipping 2004 matching lines @@
     }
 
     if (matrix) {
         canvas->concat(*matrix);
     }
 }
 
 SkAutoCanvasMatrixPaint::~SkAutoCanvasMatrixPaint() {
     fCanvas->restoreToCount(fSaveCount);
 }