Do not apply hairline optimization for paths if nv_path_rendering is used

src/gpu/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrContext.h"
@@ skipping 741 matching lines @@
     const SkMatrix* toSrc = NULL;
     SkMatrix ivm;
 
     if (viewM.hasPerspective()) {
         if (viewM.invert(&ivm)) {
             toSrc = &ivm;
         }
     }
     devBounds->set(lines.begin(), lines.count());
     for (int i = 0; i < lineCnt; ++i) {
-        add_line(&lines[2*i], toSrc, drawState->getCoverage(), &verts);
+        add_line(&lines[2*i], toSrc, drawState->getCoverageColor(), &verts);
     }
     // All the verts computed by add_line are within sqrt(1^2 + 0.5^2) of the end points.
     static const SkScalar kSqrtOfOneAndAQuarter = SkFloatToScalar(1.118f);
     // Add a little extra to account for vector normalization precision.
     static const SkScalar kOutset = kSqrtOfOneAndAQuarter + SK_Scalar1 / 20;
     devBounds->outset(kOutset, kOutset);
 
     return true;
 }
 
@@ skipping 59 matching lines @@
     for (int i = 0; i < conicCnt; ++i) {
         add_conics(&conics[3*i], cWeights[i], toDevice, toSrc, &verts, devBounds);
     }
     return true;
 }
 
 bool GrAAHairLinePathRenderer::canDrawPath(const SkPath& path,
                                            const SkStrokeRec& stroke,
                                            const GrDrawTarget* target,
                                            bool antiAlias) const {
-    if (!stroke.isHairlineStyle() || !antiAlias) {
+    if (!antiAlias) {
         return false;
     }
 
+    if (!IsStrokeHairlineOrEquivalent(stroke,
+                                      target->getDrawState().getViewMatrix(),
+                                      NULL)) {
+        return false;
+    }
+
     if (SkPath::kLine_SegmentMask == path.getSegmentMasks() ||
         target->caps()->shaderDerivativeSupport()) {
         return true;
     }
     return false;
 }
 
 template <class VertexType>
 bool check_bounds(GrDrawState* drawState, const SkRect& devBounds, void* vertices, int vCount)
 {
@@ skipping 25 matching lines @@
         }
     }
     if (!first) {
         return tolDevBounds.contains(actualBounds);
     }
 
     return true;
 }
 
 bool GrAAHairLinePathRenderer::onDrawPath(const SkPath& path,
-                                          const SkStrokeRec&,
+                                          const SkStrokeRec& stroke,
                                           GrDrawTarget* target,
                                           bool antiAlias) {
+    GrDrawState* drawState = target->drawState();
 
-    GrDrawState* drawState = target->drawState();
+    SkScalar hairlineCoverage;
+    if (IsStrokeHairlineOrEquivalent(stroke,
+                                     target->getDrawState().getViewMatrix(),
+                                     &hairlineCoverage)) {
+        uint8_t newCoverage = SkScalarRoundToInt(hairlineCoverage *
+                                                 target->getDrawState().getCoverage());
+        target->drawState()->setCoverage(newCoverage);
+    }
 
     SkIRect devClipBounds;
     target->getClip()->getConservativeBounds(drawState->getRenderTarget(), &devClipBounds);
 
     int lineCnt;
     int quadCnt;
     int conicCnt;
     PREALLOC_PTARRAY(128) lines;
     PREALLOC_PTARRAY(128) quads;
     PREALLOC_PTARRAY(128) conics;
@@ skipping 122 matching lines @@
                                     &devBounds);
                 conics += n;
             }
         }
     }
 
     target->resetIndexSource();
 
     return true;
 }