diff --git a/gm/collapsepaths.cpp b/gm/collapsepaths.cpp
index 82233c9..3899945 100644
--- a/gm/collapsepaths.cpp
+++ b/gm/collapsepaths.cpp
@@ -7,12 +7,12 @@
 
 #include "gm/gm.h"
 #include "include/core/SkCanvas.h"
-#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
 
 namespace {
 
 void test_collapse1(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     canvas->translate(0, 0);
     path.moveTo(       652.830078125,       673.9365234375);
     path.lineTo(  479.50152587890625,  213.412628173828125);
@@ -22,11 +22,11 @@
     path.lineTo(  525.02093505859375, 208.6413726806640625);
     path.lineTo(    478.403564453125, 213.5998992919921875);
     path.setFillType(SkPathFillType::kEvenOdd);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse2(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(    492.781982421875,    508.7139892578125);
     path.lineTo( 361.946746826171875, 161.0923004150390625);
     path.lineTo( 386.357513427734375, 157.8785552978515625);
@@ -34,11 +34,11 @@
     path.moveTo( 279.673004150390625, 55.619640350341796875);
     path.lineTo(  396.30657958984375, 157.4907684326171875);
     path.lineTo( 361.117950439453125, 161.2336578369140625);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse3(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(31.9730987548828125,  69.4149169921875);
     path.lineTo(36.630767822265625,   67.66190338134765625);
     path.lineTo(51.1498870849609375,  64.2765045166015625);
@@ -46,11 +46,11 @@
     path.lineTo(38.9994354248046875,  66.8980712890625);
     path.lineTo(32.229583740234375,   69.31696319580078125);
     path.lineTo(12.99810791015625,    22.4723663330078125);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse4(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(  122.66265869140625, 77.81488800048828125);
     path.lineTo(    161.983642578125,  128.557952880859375);
     path.lineTo(22.599969863891601562, 76.61859893798828125);
@@ -58,11 +58,11 @@
     path.lineTo(15.40312957763671875,  75.7647247314453125);
     path.lineTo(18.572841644287109375,  75.2251129150390625);
     path.lineTo(20.895002365112304688,  73.7937774658203125);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse5(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(52.659847259521484375,          782.0546875);
     path.lineTo(136.6915130615234375,   690.18011474609375);
     path.lineTo( 392.147796630859375,    554.6090087890625);
@@ -71,11 +71,11 @@
     path.lineTo( 430.242095947265625,   546.76605224609375);
     path.lineTo(      373.1005859375,    559.0906982421875);
     path.setFillType(SkPathFillType::kEvenOdd);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse6(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(13.314494132995605469, 197.7343902587890625);
     path.lineTo(34.56102752685546875, 174.5048675537109375);
     path.lineTo(99.15048980712890625,   140.22711181640625);
@@ -84,11 +84,11 @@
     path.lineTo(108.7822418212890625,  138.244110107421875);
     path.lineTo(94.33460235595703125,  141.360260009765625);
     path.setFillType(SkPathFillType::kEvenOdd);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse7(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(13.737141609191894531, 204.0111541748046875);
     path.lineTo(  35.658111572265625,   180.04425048828125);
     path.lineTo(102.2978668212890625,   144.67840576171875);
@@ -97,11 +97,11 @@
     path.lineTo(112.2353668212890625,    142.6324462890625);
     path.lineTo(97.32910919189453125, 145.8475189208984375);
     path.setFillType(SkPathFillType::kEvenOdd);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse8(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo( 11.75, 174.50);
     path.lineTo( 30.50, 154.00);
     path.lineTo( 87.50, 123.75);
@@ -110,11 +110,11 @@
     path.lineTo( 96.00, 122.00);
     path.lineTo( 83.25, 124.75);
     path.setFillType(SkPathFillType::kEvenOdd);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 void test_collapse9(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(SkDoubleToScalar( 13.25),   SkDoubleToScalar(197.75));
     path.lineTo(SkDoubleToScalar( 34.75),   SkDoubleToScalar(174.75));
     path.lineTo(SkDoubleToScalar( 99.0364), SkDoubleToScalar(140.364));
@@ -126,19 +126,19 @@
     path.lineTo(SkDoubleToScalar( 99.0364), SkDoubleToScalar(140.364));
     path.lineTo(SkDoubleToScalar( 94.25),   SkDoubleToScalar(141.50));
     path.setFillType(SkPathFillType::kEvenOdd);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 // This one is a thin inverted 'v', but the edges should not disappear at any point.
 void test_collapse10(SkCanvas* canvas, const SkPaint& paint) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo( 5.5,  36.0);
     path.lineTo(47.5,   5.0);
     path.lineTo(90.0,  36.0);
     path.lineTo(88.5,  36.0);
     path.lineTo(47.5,   6.0);
     path.lineTo( 7.0,  36.0);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
 
 };
diff --git a/gm/conicpaths.cpp b/gm/conicpaths.cpp
index 1375726..f3ceaea 100644
--- a/gm/conicpaths.cpp
+++ b/gm/conicpaths.cpp
@@ -9,7 +9,7 @@
 #include "include/core/SkCanvas.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkPaint.h"
-#include "include/core/SkPath.h"
+#include "include/core/SkPathBuilder.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkScalar.h"
@@ -30,66 +30,72 @@
         return SkISize::Make(920, 960);
     }
 
-    void onOnceBeforeDraw() override {
-        {
-            const SkScalar w = SkScalarSqrt(2)/2;
-            SkPath* conicCirlce = &fPaths.push_back();
-            conicCirlce->moveTo(0, 0);
-            conicCirlce->conicTo(0, 50, 50, 50, w);
-            conicCirlce->rConicTo(50, 0, 50, -50, w);
-            conicCirlce->rConicTo(0, -50, -50, -50, w);
-            conicCirlce->rConicTo(-50, 0, -50, 50, w);
+    template <typename Proc> void append_path(Proc proc) {
+        SkPathBuilder b;
+        proc(&b);
+        fPaths.push_back(b.detach());
+    }
 
-        }
-        {
-            SkPath* hyperbola = &fPaths.push_back();
+    void onOnceBeforeDraw() override {
+        this->append_path([](SkPathBuilder* conicCircle) {
+            const SkScalar w = SkScalarSqrt(2)/2;
+            conicCircle->moveTo(0, 0);
+            conicCircle->conicTo(0, 50, 50, 50, w);
+            conicCircle->rConicTo(50, 0, 50, -50, w);
+            conicCircle->rConicTo(0, -50, -50, -50, w);
+            conicCircle->rConicTo(-50, 0, -50, 50, w);
+        });
+
+        this->append_path([](SkPathBuilder* hyperbola) {
             hyperbola->moveTo(0, 0);
             hyperbola->conicTo(0, 100, 100, 100, 2);
-        }
-        {
-            SkPath* thinHyperbola = &fPaths.push_back();
+        });
+
+        this->append_path([](SkPathBuilder* thinHyperbola) {
             thinHyperbola->moveTo(0, 0);
             thinHyperbola->conicTo(100, 100, 5, 0, 2);
-        }
-        {
-            SkPath* veryThinHyperbola = &fPaths.push_back();
+        });
+
+        this->append_path([](SkPathBuilder* veryThinHyperbola) {
             veryThinHyperbola->moveTo(0, 0);
             veryThinHyperbola->conicTo(100, 100, 1, 0, 2);
-        }
-        {
-            SkPath* closedHyperbola = &fPaths.push_back();
+        });
+
+        this->append_path([](SkPathBuilder* closedHyperbola) {
             closedHyperbola->moveTo(0, 0);
             closedHyperbola->conicTo(100, 100, 0, 0, 2);
-        }
-        {
+        });
+
+        this->append_path([](SkPathBuilder* nearParabola) {
             // using 1 as weight defaults to using quadTo
-            SkPath* nearParabola = &fPaths.push_back();
             nearParabola->moveTo(0, 0);
             nearParabola->conicTo(0, 100, 100, 100, 0.999f);
-        }
-        {
-            SkPath* thinEllipse = &fPaths.push_back();
+        });
+
+        this->append_path([](SkPathBuilder* thinEllipse) {
             thinEllipse->moveTo(0, 0);
             thinEllipse->conicTo(100, 100, 5, 0, SK_ScalarHalf);
-        }
-        {
-            SkPath* veryThinEllipse = &fPaths.push_back();
+        });
+
+        this->append_path([](SkPathBuilder* veryThinEllipse) {
             veryThinEllipse->moveTo(0, 0);
             veryThinEllipse->conicTo(100, 100, 1, 0, SK_ScalarHalf);
-        }
-        {
-            SkPath* closedEllipse = &fPaths.push_back();
+        });
+
+        this->append_path([](SkPathBuilder* closedEllipse) {
             closedEllipse->moveTo(0,  0);
             closedEllipse->conicTo(100, 100, 0, 0, SK_ScalarHalf);
-        }
-        {
-            const SkScalar w = SkScalarSqrt(2)/2;
-            fGiantCircle.moveTo(2.1e+11f, -1.05e+11f);
-            fGiantCircle.conicTo(2.1e+11f, 0, 1.05e+11f, 0, w);
-            fGiantCircle.conicTo(0, 0, 0, -1.05e+11f, w);
-            fGiantCircle.conicTo(0, -2.1e+11f, 1.05e+11f, -2.1e+11f, w);
-            fGiantCircle.conicTo(2.1e+11f, -2.1e+11f, 2.1e+11f, -1.05e+11f, w);
+        });
 
+        {
+            SkPathBuilder b;
+            const SkScalar w = SkScalarSqrt(2)/2;
+            b.moveTo(2.1e+11f, -1.05e+11f);
+            b.conicTo(2.1e+11f, 0, 1.05e+11f, 0, w);
+            b.conicTo(0, 0, 0, -1.05e+11f, w);
+            b.conicTo(0, -2.1e+11f, 1.05e+11f, -2.1e+11f, w);
+            b.conicTo(2.1e+11f, -2.1e+11f, 2.1e+11f, -1.05e+11f, w);
+            fGiantCircle = b.detach();
         }
     }
 
@@ -199,7 +205,7 @@
 }
 
 DEF_SIMPLE_GM(crbug_640176, canvas, 250, 250) {
-    SkPath path;
+    SkPathBuilder path;
     path.moveTo(SkBits2Float(0x00000000), SkBits2Float(0x00000000));  // 0, 0
     path.lineTo(SkBits2Float(0x42cfd89a), SkBits2Float(0xc2700000));  // 103.923f, -60
     path.lineTo(SkBits2Float(0x42cfd899), SkBits2Float(0xc2700006));  // 103.923f, -60
@@ -210,5 +216,5 @@
     SkPaint paint;
     paint.setAntiAlias(true);
     canvas->translate(125, 125);
-    canvas->drawPath(path, paint);
+    canvas->drawPath(path.detach(), paint);
 }
diff --git a/include/core/SkPathBuilder.h b/include/core/SkPathBuilder.h
index e1932a4..adfd3ad 100644
--- a/include/core/SkPathBuilder.h
+++ b/include/core/SkPathBuilder.h
@@ -33,6 +33,11 @@
     SkPathBuilder& cubicTo(SkPoint pt1, SkPoint pt2, SkPoint pt3);
     SkPathBuilder& close();
 
+    SkPathBuilder& rConicTo(SkPoint p1, SkPoint p2, SkScalar w);
+    SkPathBuilder& rConicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2, SkScalar w) {
+        return this->rConicTo({x1, y1}, {x2, y2}, w);
+    }
+
     SkPathBuilder&  moveTo(SkScalar x, SkScalar y) { return this->moveTo(SkPoint::Make(x, y)); }
     SkPathBuilder&  lineTo(SkScalar x, SkScalar y) { return this->lineTo(SkPoint::Make(x, y)); }
     SkPathBuilder&  quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
diff --git a/src/core/SkPathBuilder.cpp b/src/core/SkPathBuilder.cpp
index c13af42..22b97cf 100644
--- a/src/core/SkPathBuilder.cpp
+++ b/src/core/SkPathBuilder.cpp
@@ -113,6 +113,16 @@
     return *this;
 }
 
+///////////////////////////////////////////////////////////////////////////////////////////
+
+SkPathBuilder& SkPathBuilder::rConicTo(SkPoint p1, SkPoint p2, SkScalar w) {
+    this->ensureMove();
+    SkPoint base = fPts[fPts.count() - 1];
+    return this->conicTo(base + p1, base + p2, w);
+}
+
+///////////////////////////////////////////////////////////////////////////////////////////
+
 SkPath SkPathBuilder::snapshot() {
     return SkPath(sk_sp<SkPathRef>(new SkPathRef(fPts, fVerbs, fConicWeights, fSegmentMask)),
                   fFillType, fIsVolatile);