Enable distance field path rendering in Chrome.

src/core/SkPicture.cpp

 
 /*
  * Copyright 2007 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 "SkPictureFlat.h"
@@ skipping 117 matching lines @@
 /** SkRecords visitor to determine heuristically whether or not a SkPicture
     will be performant when rasterized on the GPU.
  */
 struct SkPicture::PathCounter {
     SK_CREATE_MEMBER_DETECTOR(paint);
 
     PathCounter()
         : numPaintWithPathEffectUses (0)
         , numFastPathDashEffects (0)
         , numAAConcavePaths (0)
-        , numAAHairlineConcavePaths (0) {
+        , numAAHairlineConcavePaths (0)
+        , numAADFEligibleConcavePaths(0) {
     }
 
     // Recurse into nested pictures.
     void operator()(const SkRecords::DrawPicture& op) {
         const SkPicture::Analysis& analysis = op.picture->fAnalysis;
         numPaintWithPathEffectUses += analysis.fNumPaintWithPathEffectUses;
         numFastPathDashEffects     += analysis.fNumFastPathDashEffects;
         numAAConcavePaths          += analysis.fNumAAConcavePaths;
         numAAHairlineConcavePaths  += analysis.fNumAAHairlineConcavePaths;
+        numAADFEligibleConcavePaths  += analysis.fNumAADFEligibleConcavePaths;
     }
 
     void checkPaint(const SkPaint* paint) {
         if (paint && paint->getPathEffect()) {
             numPaintWithPathEffectUses++;
         }
     }
 
     void operator()(const SkRecords::DrawPoints& op) {
         this->checkPaint(&op.paint);
         const SkPathEffect* effect = op.paint.getPathEffect();
         if (effect) {
             SkPathEffect::DashInfo info;
             SkPathEffect::DashType dashType = effect->asADash(&info);
             if (2 == op.count && SkPaint::kRound_Cap != op.paint.getStrokeCap() &&
                 SkPathEffect::kDash_DashType == dashType && 2 == info.fCount) {
                 numFastPathDashEffects++;
             }
         }
     }
 
     void operator()(const SkRecords::DrawPath& op) {
         this->checkPaint(&op.paint);
         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++;
             }
         }
     }
 
     template <typename T>
     SK_WHEN(HasMember_paint<T>, void) operator()(const T& op) {
         this->checkPaint(AsPtr(op.paint));
     }
 
     template <typename T>
     SK_WHEN(!HasMember_paint<T>, void) operator()(const T& op) { /* do nothing */ }
 
     int numPaintWithPathEffectUses;
     int numFastPathDashEffects;
     int numAAConcavePaths;
     int numAAHairlineConcavePaths;
+    int numAADFEligibleConcavePaths;
 };
 
 SkPicture::Analysis::Analysis(const SkRecord& record) {
     fWillPlaybackBitmaps = WillPlaybackBitmaps(record);
 
     PathCounter counter;
     for (unsigned i = 0; i < record.count(); i++) {
         record.visit<void>(i, counter);
     }
     fNumPaintWithPathEffectUses = counter.numPaintWithPathEffectUses;
     fNumFastPathDashEffects     = counter.numFastPathDashEffects;
     fNumAAConcavePaths          = counter.numAAConcavePaths;
     fNumAAHairlineConcavePaths  = counter.numAAHairlineConcavePaths;
+    fNumAADFEligibleConcavePaths  = counter.numAADFEligibleConcavePaths;
 
     fHasText = false;
     TextHunter text;
     for (unsigned i = 0; i < record.count(); i++) {
         if (record.visit<bool>(i, text)) {
             fHasText = true;
             break;
         }
     }
 }
 
 bool SkPicture::Analysis::suitableForGpuRasterization(const char** reason,
                                                       int sampleCount) const {
     // TODO: the heuristic used here needs to be refined
     static const int kNumPaintWithPathEffectsUsesTol = 1;
     static const int kNumAAConcavePathsTol = 5;
 
     int numNonDashedPathEffects = fNumPaintWithPathEffectUses -
                                   fNumFastPathDashEffects;
     bool suitableForDash = (0 == fNumPaintWithPathEffectUses) ||
                            (numNonDashedPathEffects < kNumPaintWithPathEffectsUsesTol
                                && 0 == sampleCount);
 
     bool ret = suitableForDash &&
-               (fNumAAConcavePaths - fNumAAHairlineConcavePaths)
+               (fNumAAConcavePaths - fNumAAHairlineConcavePaths - fNumAADFEligibleConcavePaths)
                    < kNumAAConcavePathsTol;
 
     if (!ret && reason) {
         if (!suitableForDash) {
             if (0 != sampleCount) {
                 *reason = "Can't use multisample on dash effect.";
             } 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
             *reason = "Unknown reason for GPU unsuitability.";
     }
     return ret;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 407 matching lines @@
 int SkPicture::approximateOpCount() const {
     SkASSERT(fRecord.get() || fData.get());
     if (fRecord.get()) {
         return fRecord->count();
     }
     if (fData.get()) {
         return fData->opCount();
     }
     return 0;
 }