3 files changed, 26 insertions, 6 deletions
diff --git a/src/core/SkPicture.cpp b/src/core/SkPicture.cpp
index dccb822c82..01b315a758 100644
--- a/src/core/SkPicture.cpp
+++ b/src/core/SkPicture.cpp
@@ -135,7 +135,8 @@ struct SkPicture::PathCounter {
         : numPaintWithPathEffectUses (0)
         , numFastPathDashEffects (0)
         , numAAConcavePaths (0)
-        , numAAHairlineConcavePaths (0) {
+        , numAAHairlineConcavePaths (0)
+        , numAADFEligibleConcavePaths(0) {
     }
 
     // Recurse into nested pictures.
@@ -145,6 +146,7 @@ struct SkPicture::PathCounter {
         numFastPathDashEffects     += analysis.fNumFastPathDashEffects;
         numAAConcavePaths          += analysis.fNumAAConcavePaths;
         numAAHairlineConcavePaths  += analysis.fNumAAHairlineConcavePaths;
+        numAADFEligibleConcavePaths  += analysis.fNumAADFEligibleConcavePaths;
     }
 
     void checkPaint(const SkPaint* paint) {
@@ -171,9 +173,14 @@ struct SkPicture::PathCounter {
         if (op.paint.isAntiAlias() && !op.path.isConvex()) {
             numAAConcavePaths++;
 
-            if (SkPaint::kStroke_Style == op.paint.getStyle() &&
+            SkPaint::Style paintStyle = op.paint.getStyle();
+            const SkRect& pathBounds = op.path.getBounds();
+            if (SkPaint::kStroke_Style == paintStyle &&
                 0 == op.paint.getStrokeWidth()) {
                 numAAHairlineConcavePaths++;
+            } else if (SkPaint::kFill_Style == paintStyle && pathBounds.width() < 64.f &&
+                       pathBounds.height() < 64.f && !op.path.isVolatile()) {
+                numAADFEligibleConcavePaths++;
             }
         }
     }
@@ -190,6 +197,7 @@ struct SkPicture::PathCounter {
     int numFastPathDashEffects;
     int numAAConcavePaths;
     int numAAHairlineConcavePaths;
+    int numAADFEligibleConcavePaths;
 };
 
 SkPicture::Analysis::Analysis(const SkRecord& record) {
@@ -203,6 +211,7 @@ SkPicture::Analysis::Analysis(const SkRecord& record) {
     fNumFastPathDashEffects     = counter.numFastPathDashEffects;
     fNumAAConcavePaths          = counter.numAAConcavePaths;
     fNumAAHairlineConcavePaths  = counter.numAAHairlineConcavePaths;
+    fNumAADFEligibleConcavePaths  = counter.numAADFEligibleConcavePaths;
 
     fHasText = false;
     TextHunter text;
@@ -227,7 +236,7 @@ bool SkPicture::Analysis::suitableForGpuRasterization(const char** reason,
                                && 0 == sampleCount);
 
     bool ret = suitableForDash &&
-               (fNumAAConcavePaths - fNumAAHairlineConcavePaths)
+               (fNumAAConcavePaths - fNumAAHairlineConcavePaths - fNumAADFEligibleConcavePaths)
                    < kNumAAConcavePathsTol;
 
     if (!ret && reason) {
@@ -237,7 +246,7 @@ bool SkPicture::Analysis::suitableForGpuRasterization(const char** reason,
             } else {
                 *reason = "Too many non dashed path effects.";
             }
-        } else if ((fNumAAConcavePaths - fNumAAHairlineConcavePaths)
+        } else if ((fNumAAConcavePaths - fNumAAHairlineConcavePaths - fNumAADFEligibleConcavePaths)
                     >= kNumAAConcavePathsTol)
             *reason = "Too many anti-aliased concave paths.";
         else
diff --git a/src/core/SkPictureContentInfo.cpp b/src/core/SkPictureContentInfo.cpp
index 937173c519..9fa6a64c4e 100644
--- a/src/core/SkPictureContentInfo.cpp
+++ b/src/core/SkPictureContentInfo.cpp
@@ -25,7 +25,7 @@ bool SkPictureContentInfo::suitableForGpuRasterization(GrContext* context, const
                             && 0 == sampleCount);
 
     bool ret = suitableForDash &&
-                    (fNumAAConcavePaths - fNumAAHairlineConcavePaths)
+                    (fNumAAConcavePaths - fNumAAHairlineConcavePaths - fNumAADFEligibleConcavePaths)
                     < kNumAAConcavePaths;
     if (!ret && reason) {
         if (!suitableForDash) {
@@ -34,7 +34,7 @@ bool SkPictureContentInfo::suitableForGpuRasterization(GrContext* context, const
             } else {
                 *reason = "Too many non dashed path effects.";
             }
-        } else if ((fNumAAConcavePaths - fNumAAHairlineConcavePaths)
+        } else if ((fNumAAConcavePaths - fNumAAHairlineConcavePaths - fNumAADFEligibleConcavePaths)
                     >= kNumAAConcavePaths) {
             *reason = "Too many anti-aliased concave paths.";
         } else {
@@ -59,8 +59,13 @@ void SkPictureContentInfo::onDrawPath(const SkPath& path, const SkPaint& paint)
     if (paint.isAntiAlias() && !path.isConvex()) {
         ++fNumAAConcavePaths;
 
+        SkPaint::Style paintStyle = paint.getStyle();
+        const SkRect& pathBounds = path.getBounds();
         if (SkPaint::kStroke_Style == paint.getStyle() && 0 == paint.getStrokeWidth()) {
             ++fNumAAHairlineConcavePaths;
+        } else if (SkPaint::kFill_Style == paintStyle && pathBounds.width() < 64.f &&
+                   pathBounds.height() < 64.f && !path.isVolatile()) {
+            ++fNumAADFEligibleConcavePaths;
         }
     }
 }
@@ -134,6 +139,7 @@ void SkPictureContentInfo::set(const SkPictureContentInfo& src) {
     fNumFastPathDashEffects = src.fNumFastPathDashEffects;
     fNumAAConcavePaths = src.fNumAAConcavePaths;
     fNumAAHairlineConcavePaths = src.fNumAAHairlineConcavePaths;
+    fNumAADFEligibleConcavePaths = src.fNumAADFEligibleConcavePaths;
     fNumLayers = src.fNumLayers;
     fNumInteriorLayers = src.fNumInteriorLayers;
     fNumLeafLayers = src.fNumLeafLayers;
@@ -147,6 +153,7 @@ void SkPictureContentInfo::reset() {
     fNumFastPathDashEffects = 0;
     fNumAAConcavePaths = 0;
     fNumAAHairlineConcavePaths = 0;
+    fNumAADFEligibleConcavePaths = 0;
     fNumLayers = 0;
     fNumInteriorLayers = 0;
     fNumLeafLayers = 0;
@@ -160,6 +167,7 @@ void SkPictureContentInfo::swap(SkPictureContentInfo* other) {
     SkTSwap(fNumFastPathDashEffects, other->fNumFastPathDashEffects);
     SkTSwap(fNumAAConcavePaths, other->fNumAAConcavePaths);
     SkTSwap(fNumAAHairlineConcavePaths, other->fNumAAHairlineConcavePaths);
+    SkTSwap(fNumAADFEligibleConcavePaths, other->fNumAADFEligibleConcavePaths);
     SkTSwap(fNumLayers, other->fNumLayers);
     SkTSwap(fNumInteriorLayers, other->fNumInteriorLayers);
     SkTSwap(fNumLeafLayers, other->fNumLeafLayers);
diff --git a/src/core/SkPictureContentInfo.h b/src/core/SkPictureContentInfo.h
index d4d1d4fc5f..f255f7df65 100644
--- a/src/core/SkPictureContentInfo.h
+++ b/src/core/SkPictureContentInfo.h
@@ -60,6 +60,9 @@ private:
     // This field is incremented every time a drawPath call is
     // issued for a hairline stroked concave path.
     int fNumAAHairlineConcavePaths;
+    // This field is incremented every time a drawPath call is
+    // issued for a concave path that can be rendered with distance fields
+    int fNumAADFEligibleConcavePaths;
     // These fields track the different layer flavors. fNumLayers is just
     // a count of all saveLayers, fNumInteriorLayers is the number of layers
     // with a layer inside them, fNumLeafLayers is the number of layers with