Do not apply hairline optimization for paths if nv_path_rendering is used

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "effects/GrTextureDomainEffect.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "GrContext.h"
 #include "GrBitmapTextContext.h"
-
+#include "GrGpu.h"
+#include "GrDrawTargetCaps.h"
 #include "SkGrTexturePixelRef.h"
 
 #include "SkColorFilter.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkPathEffect.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
@@ skipping 822 matching lines @@
 
 SkBitmap wrap_texture(GrTexture* texture) {
     SkBitmap result;
     bool dummy;
     SkBitmap::Config config = grConfig2skConfig(texture->config(), &dummy);
     result.setConfig(config, texture->width(), texture->height());
     result.setPixelRef(SkNEW_ARGS(SkGrPixelRef, (texture)))->unref();
     return result;
 }
 
+bool treat_paint_as_hairline(const SkPaint& paint, const GrContext* context, SkScalar* hairlineCoverage) {

[bsalomon, 2013/10/24 13:28:36]

Kimmo, maybe we can do this check from GrContext::drawPath()?

[Kimmo Kinnunen, 2013/10/30 09:33:41]

Done.

+    return !context->getGpu()->caps()->pathRenderingSupport() &&
+           SkDrawTreatAsHairline(paint, context->getMatrix(), hairlineCoverage);
+}
+
 };
 
 void SkGpuDevice::drawPath(const SkDraw& draw, const SkPath& origSrcPath,
                            const SkPaint& paint, const SkMatrix* prePathMatrix,
                            bool pathIsMutable) {
     CHECK_FOR_NODRAW_ANNOTATION(paint);
     CHECK_SHOULD_DRAW(draw, false);
 
     GrPaint grPaint;
     if (!skPaint2GrPaintShader(this, paint, true, &grPaint)) {
         return;
     }
 
     // can we cheat, and treat a thin stroke as a hairline w/ coverage
     // if we can, we draw lots faster (raster device does this same test)
     SkScalar hairlineCoverage;
-    bool doHairLine = SkDrawTreatAsHairline(paint, fContext->getMatrix(), &hairlineCoverage);
+    bool doHairLine = treat_paint_as_hairline(paint, fContext, &hairlineCoverage);
     if (doHairLine) {
         grPaint.setCoverage(SkScalarRoundToInt(hairlineCoverage * grPaint.getCoverage()));
     }
 
     // If we have a prematrix, apply it to the path, optimizing for the case
     // where the original path can in fact be modified in place (even though
     // its parameter type is const).
     SkPath* pathPtr = const_cast<SkPath*>(&origSrcPath);
     SkPath  tmpPath, effectPath;
 
@@ skipping 961 matching lines @@
                          GrTexture* texture,
                          bool needClear)
     : SkBitmapDevice(make_bitmap(context, texture->asRenderTarget())) {
 
     SkASSERT(texture && texture->asRenderTarget());
     // This constructor is called from onCreateCompatibleDevice. It has locked the RT in the texture
     // cache. We pass true for the third argument so that it will get unlocked.
     this->initFromRenderTarget(context, texture->asRenderTarget(), true);
     fNeedClear = needClear;
 }