optional res-scale parameter to getFillPath

src/core/SkStroke.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 "SkStrokerPriv.h"
 #include "SkGeometry.h"
 #include "SkPath.h"
@@ skipping 140 matching lines @@
         fEndSet = true;
         return true;
    }
 };
 #endif
 
 class SkPathStroker {
 public:
 #if QUAD_STROKE_APPROXIMATION
     SkPathStroker(const SkPath& src,
-                  SkScalar radius, SkScalar miterLimit, SkScalar error, SkPaint::Cap cap,
-                  SkPaint::Join join);
+                  SkScalar radius, SkScalar miterLimit, SkScalar error, SkPaint::Cap,
+                  SkPaint::Join, SkScalar resScale);
 #else
     SkPathStroker(const SkPath& src,
-                  SkScalar radius, SkScalar miterLimit, SkPaint::Cap cap,
-                  SkPaint::Join join);
+                  SkScalar radius, SkScalar miterLimit, SkPaint::Cap,
+                  SkPaint::Join, SkScalar resScale);
 #endif
 
     void moveTo(const SkPoint&);
     void lineTo(const SkPoint&);
     void quadTo(const SkPoint&, const SkPoint&);
     void cubicTo(const SkPoint&, const SkPoint&, const SkPoint&);
     void close(bool isLine) { this->finishContour(true, isLine); }
 
     void done(SkPath* dst, bool isLine) {
         this->finishContour(false, isLine);
         fOuter.addPath(fExtra);
         dst->swap(fOuter);
     }
 
+    SkScalar getResScale() const { return fResScale; }
+
 private:
 #if QUAD_STROKE_APPROXIMATION
     SkScalar    fError;
 #endif
     SkScalar    fRadius;
     SkScalar    fInvMiterLimit;
+    SkScalar    fResScale;
 
     SkVector    fFirstNormal, fPrevNormal, fFirstUnitNormal, fPrevUnitNormal;
     SkPoint     fFirstPt, fPrevPt;  // on original path
     SkPoint     fFirstOuterPt;
     int         fSegmentCount;
     bool        fPrevIsLine;
 
     SkStrokerPriv::CapProc  fCapper;
     SkStrokerPriv::JoinProc fJoiner;
 
@@ skipping 144 matching lines @@
     // reallocating its internal storage.
     fInner.rewind();
     fSegmentCount = -1;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if QUAD_STROKE_APPROXIMATION
 SkPathStroker::SkPathStroker(const SkPath& src,
                              SkScalar radius, SkScalar miterLimit, SkScalar error,
-                             SkPaint::Cap cap, SkPaint::Join join)
+                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale)
 #else
 SkPathStroker::SkPathStroker(const SkPath& src,
                              SkScalar radius, SkScalar miterLimit,
-                             SkPaint::Cap cap, SkPaint::Join join)
+                             SkPaint::Cap cap, SkPaint::Join join, SkScalar resScale)
 #endif
-        : fRadius(radius) {
+        : fRadius(radius), fResScale(resScale) {
 
     /*  This is only used when join is miter_join, but we initialize it here
         so that it is always defined, to fis valgrind warnings.
     */
     fInvMiterLimit = 0;
 
     if (join == SkPaint::kMiter_Join) {
         if (miterLimit <= SK_Scalar1) {
             join = SkPaint::kBevel_Join;
         } else {
@@ skipping 1054 matching lines @@
             // our answer should preserve the inverseness of the src
             if (src.isInverseFillType()) {
                 SkASSERT(!dst->isInverseFillType());
                 dst->toggleInverseFillType();
             }
             return;
         }
     }
 
     SkAutoConicToQuads converter;
-    const SkScalar conicTol = SK_Scalar1 / 4;
+    const SkScalar conicTol = SK_Scalar1 / 4 / fResScale;
 
 #if QUAD_STROKE_APPROXIMATION
     SkPathStroker   stroker(src, radius, fMiterLimit, fError, this->getCap(),
-                            this->getJoin());
+                            this->getJoin(), fResScale);
 #else
-    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(),
-                            this->getJoin());
+    SkPathStroker   stroker(src, radius, fMiterLimit, this->getCap(), this->getJoin(), fResScale);
 #endif
     SkPath::Iter    iter(src, false);
     SkPath::Verb    lastSegment = SkPath::kMove_Verb;
 
     for (;;) {
         SkPoint  pts[4];
         switch (iter.next(pts, false)) {
             case SkPath::kMove_Verb:
                 stroker.moveTo(pts[0]);
                 break;
@@ skipping 137 matching lines @@
         default:
             break;
     }
 
     if (fWidth < SkMinScalar(rw, rh) && !fDoFill) {
         r = rect;
         r.inset(radius, radius);
         dst->addRect(r, reverse_direction(dir));
     }
 }