increase coverage of SkPath.cpp, remove unused code

tests/PathTest.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 "Test.h"
 #include "SkCanvas.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkParse.h"
 #include "SkParsePath.h"
 #include "SkPathEffect.h"
 #include "SkRandom.h"
 #include "SkReader32.h"
 #include "SkRRect.h"
 #include "SkSize.h"
 #include "SkSurface.h"
 #include "SkTypes.h"
 #include "SkWriter32.h"
 
 static void make_path0(SkPath* path) {
     // from  *  https://code.google.com/p/skia/issues/detail?id=1706
 
-    path->moveTo(146.939f, 1012.84f);
-    path->lineTo(181.747f, 1009.18f);
-    path->lineTo(182.165f, 1013.16f);
-    path->lineTo(147.357f, 1016.82f);
-    path->lineTo(146.939f, 1012.84f);
+    path->moveTo(SkFloatToScalar(146.939f), SkFloatToScalar(1012.84f));

[reed1, 2013/11/13 18:37:52]

are these macros required?

[caryclark, 2013/11/13 18:52:37]

Only if one day, we wanted to allow optionally SkScalar == double.

SkFloatToScalar is used irregularly throughout. 

What is your desired use case for SkFloatToScalar?

[reed1, 2013/11/13 18:58:58]

Good question. It began life when scalars could be fixed, in which case a macro
was definitely needed.

I wonder if we need any cast/macro when scalar is double. would we ever get a
warning if we said

double x;
x = 15.3f;

I think my macro comment is that much of the change in this file is from adding
that macro, which I'm not sure makes an impact, but is a lot more to read.

+    path->lineTo(SkFloatToScalar(181.747f), SkFloatToScalar(1009.18f));
+    path->lineTo(SkFloatToScalar(182.165f), SkFloatToScalar(1013.16f));
+    path->lineTo(SkFloatToScalar(147.357f), SkFloatToScalar(1016.82f));
+    path->lineTo(SkFloatToScalar(146.939f), SkFloatToScalar(1012.84f));
     path->close();
 }
 
 static void make_path1(SkPath* path) {
     path->addRect(SkRect::MakeXYWH(10, 10, 10, 1));
 }
 
 typedef void (*PathProc)(SkPath*);
 
 /*
@@ skipping 95 matching lines @@
     SkPath copy(original);
     REPORTER_ASSERT(reporter, copy.getGenerationID() == original.getGenerationID());
     REPORTER_ASSERT(reporter, copy.getSourcePath() == original.getSourcePath());
 
     // Test assigment operator.  Change generation ID, copy source path.
     SkPath assign;
     assignID = assign.getGenerationID();
     assign = original;
     REPORTER_ASSERT(reporter, assign.getGenerationID() != assignID);
     REPORTER_ASSERT(reporter, assign.getSourcePath() == original.getSourcePath());
-
+    assignID = assign.getGenerationID();
+    assign = assign;

[reed1, 2013/11/13 18:37:52]

this looks odd enough, perhaps we could add a comment for these 3 lines of
code... something like (I'm just guessing, as I don't really know why)

// test that self-assignment doesn't change our id

We don't, in general, test for self-assignment. Was this motivated by a bug
somewhere? I ask, because it seems possible that a future reviewer may delete
this code w/o knowing why its here.

[caryclark, 2013/11/13 18:52:37]

I'll add a comment.

I wouldn't be surprised if I was misreading the code, but I thought that

SkPath& SkPath::operator=(const SkPath& that) {
    SkDEBUGCODE(that.validate();)

    if (this != &that) {

was a test for self-assignment.

[reed1, 2013/11/13 18:58:58]

It definitely is. I'm just noting that we don't *test* for that anywhere else,
but perhaps we should (e.g. SkRegion, etc. all of our other complex class that
have assignment).

+    REPORTER_ASSERT(reporter, assign.getGenerationID() == assignID);
+    
     // Test rewind.  Change generation ID, don't touch source path.
     copyID = copy.getGenerationID();
     copy.rewind();
     REPORTER_ASSERT(reporter, copy.getGenerationID() != copyID);
     REPORTER_ASSERT(reporter, copy.getSourcePath() == original.getSourcePath());
 
     // Test reset.  Change generation ID, don't touch source path.
     assignID = assign.getGenerationID();
     assign.reset();
     REPORTER_ASSERT(reporter, assign.getGenerationID() != assignID);
@@ skipping 58 matching lines @@
     const uint32_t v = c.getGenerationID();
     REPORTER_ASSERT(reporter, (v == w) == kExpectGenIDToIgnoreFill);
 
     c.rewind();
     REPORTER_ASSERT(reporter, v != c.getGenerationID());
 }
 
 // This used to assert in the debug build, as the edges did not all line-up.
 static void test_bad_cubic_crbug234190() {
     SkPath path;
-    path.moveTo(13.8509f, 3.16858f);
-    path.cubicTo(-2.35893e+08f, -4.21044e+08f,
-                 -2.38991e+08f, -4.26573e+08f,
-                 -2.41016e+08f, -4.30188e+08f);
+    path.moveTo(SkFloatToScalar(13.8509f), SkFloatToScalar(3.16858f));
+    path.cubicTo(SkFloatToScalar(-2.35893e+08f), SkFloatToScalar(-4.21044e+08f),
+                 SkFloatToScalar(-2.38991e+08f), SkFloatToScalar(-4.26573e+08f),
+                 SkFloatToScalar(-2.41016e+08f), SkFloatToScalar(-4.30188e+08f));
 
     SkPaint paint;
     paint.setAntiAlias(true);
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(84, 88));
     surface->getCanvas()->drawPath(path, paint);
 }
 
 static void test_bad_cubic_crbug229478() {
     const SkPoint pts[] = {
-        { 4595.91064f,    -11596.9873f },
-        { 4597.2168f,    -11595.9414f },
-        { 4598.52344f,    -11594.8955f },
-        { 4599.83008f,    -11593.8496f },
+        { SkFloatToScalar(4595.91064f),    SkFloatToScalar(-11596.9873f) },
+        { SkFloatToScalar(4597.2168f),    SkFloatToScalar(-11595.9414f) },
+        { SkFloatToScalar(4598.52344f),    SkFloatToScalar(-11594.8955f) },
+        { SkFloatToScalar(4599.83008f),    SkFloatToScalar(-11593.8496f) },
     };
 
     SkPath path;
     path.moveTo(pts[0]);
     path.cubicTo(pts[1], pts[2], pts[3]);
 
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(20);
 
     SkPath dst;
     // Before the fix, this would infinite-recurse, and run out of stack
     // because we would keep trying to subdivide a degenerate cubic segment.
     paint.getFillPath(path, &dst, NULL);
 }
 
 static void build_path_170666(SkPath& path) {
-    path.moveTo(17.9459f, 21.6344f);
-    path.lineTo(139.545f, -47.8105f);
-    path.lineTo(139.545f, -47.8105f);
-    path.lineTo(131.07f, -47.3888f);
-    path.lineTo(131.07f, -47.3888f);
-    path.lineTo(122.586f, -46.9532f);
-    path.lineTo(122.586f, -46.9532f);
-    path.lineTo(18076.6f, 31390.9f);
-    path.lineTo(18076.6f, 31390.9f);
-    path.lineTo(18085.1f, 31390.5f);
-    path.lineTo(18085.1f, 31390.5f);
-    path.lineTo(18076.6f, 31390.9f);
-    path.lineTo(18076.6f, 31390.9f);
-    path.lineTo(17955, 31460.3f);
-    path.lineTo(17955, 31460.3f);
-    path.lineTo(17963.5f, 31459.9f);
-    path.lineTo(17963.5f, 31459.9f);
-    path.lineTo(17971.9f, 31459.5f);
-    path.lineTo(17971.9f, 31459.5f);
-    path.lineTo(17.9551f, 21.6205f);
-    path.lineTo(17.9551f, 21.6205f);
-    path.lineTo(9.47091f, 22.0561f);
-    path.lineTo(9.47091f, 22.0561f);
-    path.lineTo(17.9459f, 21.6344f);
-    path.lineTo(17.9459f, 21.6344f);
-    path.close();path.moveTo(0.995934f, 22.4779f);
-    path.lineTo(0.986725f, 22.4918f);
-    path.lineTo(0.986725f, 22.4918f);
-    path.lineTo(17955, 31460.4f);
-    path.lineTo(17955, 31460.4f);
-    path.lineTo(17971.9f, 31459.5f);
-    path.lineTo(17971.9f, 31459.5f);
-    path.lineTo(18093.6f, 31390.1f);
-    path.lineTo(18093.6f, 31390.1f);
-    path.lineTo(18093.6f, 31390);
-    path.lineTo(18093.6f, 31390);
-    path.lineTo(139.555f, -47.8244f);
-    path.lineTo(139.555f, -47.8244f);
-    path.lineTo(122.595f, -46.9671f);
-    path.lineTo(122.595f, -46.9671f);
-    path.lineTo(0.995934f, 22.4779f);
-    path.lineTo(0.995934f, 22.4779f);
+    path.moveTo(SkFloatToScalar(17.9459f), SkFloatToScalar(21.6344f));
+    path.lineTo(SkFloatToScalar(139.545f), SkFloatToScalar(-47.8105f));
+    path.lineTo(SkFloatToScalar(139.545f), SkFloatToScalar(-47.8105f));
+    path.lineTo(SkFloatToScalar(131.07f), SkFloatToScalar(-47.3888f));
+    path.lineTo(SkFloatToScalar(131.07f), SkFloatToScalar(-47.3888f));
+    path.lineTo(SkFloatToScalar(122.586f), SkFloatToScalar(-46.9532f));
+    path.lineTo(SkFloatToScalar(122.586f), SkFloatToScalar(-46.9532f));
+    path.lineTo(SkFloatToScalar(18076.6f), SkFloatToScalar(31390.9f));
+    path.lineTo(SkFloatToScalar(18076.6f), SkFloatToScalar(31390.9f));
+    path.lineTo(SkFloatToScalar(18085.1f), SkFloatToScalar(31390.5f));
+    path.lineTo(SkFloatToScalar(18085.1f), SkFloatToScalar(31390.5f));
+    path.lineTo(SkFloatToScalar(18076.6f), SkFloatToScalar(31390.9f));
+    path.lineTo(SkFloatToScalar(18076.6f), SkFloatToScalar(31390.9f));
+    path.lineTo(17955, SkFloatToScalar(31460.3f));
+    path.lineTo(17955, SkFloatToScalar(31460.3f));
+    path.lineTo(SkFloatToScalar(17963.5f), SkFloatToScalar(31459.9f));
+    path.lineTo(SkFloatToScalar(17963.5f), SkFloatToScalar(31459.9f));
+    path.lineTo(SkFloatToScalar(17971.9f), SkFloatToScalar(31459.5f));
+    path.lineTo(SkFloatToScalar(17971.9f), SkFloatToScalar(31459.5f));
+    path.lineTo(SkFloatToScalar(17.9551f), SkFloatToScalar(21.6205f));
+    path.lineTo(SkFloatToScalar(17.9551f), SkFloatToScalar(21.6205f));
+    path.lineTo(SkFloatToScalar(9.47091f), SkFloatToScalar(22.0561f));
+    path.lineTo(SkFloatToScalar(9.47091f), SkFloatToScalar(22.0561f));
+    path.lineTo(SkFloatToScalar(17.9459f), SkFloatToScalar(21.6344f));
+    path.lineTo(SkFloatToScalar(17.9459f), SkFloatToScalar(21.6344f));
+    path.close();path.moveTo(SkFloatToScalar(0.995934f), SkFloatToScalar(22.4779f));
+    path.lineTo(SkFloatToScalar(0.986725f), SkFloatToScalar(22.4918f));
+    path.lineTo(SkFloatToScalar(0.986725f), SkFloatToScalar(22.4918f));
+    path.lineTo(17955, SkFloatToScalar(31460.4f));
+    path.lineTo(17955, SkFloatToScalar(31460.4f));
+    path.lineTo(SkFloatToScalar(17971.9f), SkFloatToScalar(31459.5f));
+    path.lineTo(SkFloatToScalar(17971.9f), SkFloatToScalar(31459.5f));
+    path.lineTo(SkFloatToScalar(18093.6f), SkFloatToScalar(31390.1f));
+    path.lineTo(SkFloatToScalar(18093.6f), SkFloatToScalar(31390.1f));
+    path.lineTo(SkFloatToScalar(18093.6f), 31390);
+    path.lineTo(SkFloatToScalar(18093.6f), 31390);
+    path.lineTo(SkFloatToScalar(139.555f), SkFloatToScalar(-47.8244f));
+    path.lineTo(SkFloatToScalar(139.555f), SkFloatToScalar(-47.8244f));
+    path.lineTo(SkFloatToScalar(122.595f), SkFloatToScalar(-46.9671f));
+    path.lineTo(SkFloatToScalar(122.595f), SkFloatToScalar(-46.9671f));
+    path.lineTo(SkFloatToScalar(0.995934f), SkFloatToScalar(22.4779f));
+    path.lineTo(SkFloatToScalar(0.995934f), SkFloatToScalar(22.4779f));
     path.close();
-    path.moveTo(5.43941f, 25.5223f);
-    path.lineTo(798267, -28871.1f);
-    path.lineTo(798267, -28871.1f);
-    path.lineTo(3.12512e+06f, -113102);
-    path.lineTo(3.12512e+06f, -113102);
-    path.cubicTo(5.16324e+06f, -186882, 8.15247e+06f, -295092, 1.1957e+07f, -432813);
-    path.cubicTo(1.95659e+07f, -708257, 3.04359e+07f, -1.10175e+06f, 4.34798e+07f, -1.57394e+06f);
-    path.cubicTo(6.95677e+07f, -2.51831e+06f, 1.04352e+08f, -3.77748e+06f, 1.39135e+08f, -5.03666e+06f);
-    path.cubicTo(1.73919e+08f, -6.29583e+06f, 2.08703e+08f, -7.555e+06f, 2.34791e+08f, -8.49938e+06f);
-    path.cubicTo(2.47835e+08f, -8.97157e+06f, 2.58705e+08f, -9.36506e+06f, 2.66314e+08f, -9.6405e+06f);
-    path.cubicTo(2.70118e+08f, -9.77823e+06f, 2.73108e+08f, -9.88644e+06f, 2.75146e+08f, -9.96022e+06f);
-    path.cubicTo(2.76165e+08f, -9.99711e+06f, 2.76946e+08f, -1.00254e+07f, 2.77473e+08f, -1.00444e+07f);
-    path.lineTo(2.78271e+08f, -1.00733e+07f);
-    path.lineTo(2.78271e+08f, -1.00733e+07f);
-    path.cubicTo(2.78271e+08f, -1.00733e+07f, 2.08703e+08f, -7.555e+06f, 135.238f, 23.3517f);
-    path.cubicTo(131.191f, 23.4981f, 125.995f, 23.7976f, 123.631f, 24.0206f);
-    path.cubicTo(121.267f, 24.2436f, 122.631f, 24.3056f, 126.677f, 24.1591f);
-    path.cubicTo(2.08703e+08f, -7.555e+06f, 2.78271e+08f, -1.00733e+07f, 2.78271e+08f, -1.00733e+07f);
-    path.lineTo(2.77473e+08f, -1.00444e+07f);
-    path.lineTo(2.77473e+08f, -1.00444e+07f);
-    path.cubicTo(2.76946e+08f, -1.00254e+07f, 2.76165e+08f, -9.99711e+06f, 2.75146e+08f, -9.96022e+06f);
-    path.cubicTo(2.73108e+08f, -9.88644e+06f, 2.70118e+08f, -9.77823e+06f, 2.66314e+08f, -9.6405e+06f);
-    path.cubicTo(2.58705e+08f, -9.36506e+06f, 2.47835e+08f, -8.97157e+06f, 2.34791e+08f, -8.49938e+06f);
-    path.cubicTo(2.08703e+08f, -7.555e+06f, 1.73919e+08f, -6.29583e+06f, 1.39135e+08f, -5.03666e+06f);
-    path.cubicTo(1.04352e+08f, -3.77749e+06f, 6.95677e+07f, -2.51831e+06f, 4.34798e+07f, -1.57394e+06f);
-    path.cubicTo(3.04359e+07f, -1.10175e+06f, 1.95659e+07f, -708258, 1.1957e+07f, -432814);
-    path.cubicTo(8.15248e+06f, -295092, 5.16324e+06f, -186883, 3.12513e+06f, -113103);
+    path.moveTo(SkFloatToScalar(5.43941f), SkFloatToScalar(25.5223f));
+    path.lineTo(798267, SkFloatToScalar(-28871.1f));
+    path.lineTo(798267, SkFloatToScalar(-28871.1f));
+    path.lineTo(SkFloatToScalar(3.12512e+06f), -113102);
+    path.lineTo(SkFloatToScalar(3.12512e+06f), -113102);
+    path.cubicTo(SkFloatToScalar(5.16324e+06f), -186882, SkFloatToScalar(8.15247e+06f), -295092, SkFloatToScalar(1.1957e+07f), -432813);
+    path.cubicTo(SkFloatToScalar(1.95659e+07f), -708257, SkFloatToScalar(3.04359e+07f), SkFloatToScalar(-1.10175e+06f), SkFloatToScalar(4.34798e+07f), SkFloatToScalar(-1.57394e+06f));
+    path.cubicTo(SkFloatToScalar(6.95677e+07f), SkFloatToScalar(-2.51831e+06f), SkFloatToScalar(1.04352e+08f), SkFloatToScalar(-3.77748e+06f), SkFloatToScalar(1.39135e+08f), SkFloatToScalar(-5.03666e+06f));
+    path.cubicTo(SkFloatToScalar(1.73919e+08f), SkFloatToScalar(-6.29583e+06f), SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(2.34791e+08f), SkFloatToScalar(-8.49938e+06f));
+    path.cubicTo(SkFloatToScalar(2.47835e+08f), SkFloatToScalar(-8.97157e+06f), SkFloatToScalar(2.58705e+08f), SkFloatToScalar(-9.36506e+06f), SkFloatToScalar(2.66314e+08f), SkFloatToScalar(-9.6405e+06f));
+    path.cubicTo(SkFloatToScalar(2.70118e+08f), SkFloatToScalar(-9.77823e+06f), SkFloatToScalar(2.73108e+08f), SkFloatToScalar(-9.88644e+06f), SkFloatToScalar(2.75146e+08f), SkFloatToScalar(-9.96022e+06f));
+    path.cubicTo(SkFloatToScalar(2.76165e+08f), SkFloatToScalar(-9.99711e+06f), SkFloatToScalar(2.76946e+08f), SkFloatToScalar(-1.00254e+07f), SkFloatToScalar(2.77473e+08f), SkFloatToScalar(-1.00444e+07f));
+    path.lineTo(SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f));
+    path.lineTo(SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f));
+    path.cubicTo(SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f), SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(135.238f), SkFloatToScalar(23.3517f));
+    path.cubicTo(SkFloatToScalar(131.191f), SkFloatToScalar(23.4981f), SkFloatToScalar(125.995f), SkFloatToScalar(23.7976f), SkFloatToScalar(123.631f), SkFloatToScalar(24.0206f));
+    path.cubicTo(SkFloatToScalar(121.267f), SkFloatToScalar(24.2436f), SkFloatToScalar(122.631f), SkFloatToScalar(24.3056f), SkFloatToScalar(126.677f), SkFloatToScalar(24.1591f));
+    path.cubicTo(SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f), SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f));
+    path.lineTo(SkFloatToScalar(2.77473e+08f), SkFloatToScalar(-1.00444e+07f));
+    path.lineTo(SkFloatToScalar(2.77473e+08f), SkFloatToScalar(-1.00444e+07f));
+    path.cubicTo(SkFloatToScalar(2.76946e+08f), SkFloatToScalar(-1.00254e+07f), SkFloatToScalar(2.76165e+08f), SkFloatToScalar(-9.99711e+06f), SkFloatToScalar(2.75146e+08f), SkFloatToScalar(-9.96022e+06f));
+    path.cubicTo(SkFloatToScalar(2.73108e+08f), SkFloatToScalar(-9.88644e+06f), SkFloatToScalar(2.70118e+08f), SkFloatToScalar(-9.77823e+06f), SkFloatToScalar(2.66314e+08f), SkFloatToScalar(-9.6405e+06f));
+    path.cubicTo(SkFloatToScalar(2.58705e+08f), SkFloatToScalar(-9.36506e+06f), SkFloatToScalar(2.47835e+08f), SkFloatToScalar(-8.97157e+06f), SkFloatToScalar(2.34791e+08f), SkFloatToScalar(-8.49938e+06f));
+    path.cubicTo(SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(1.73919e+08f), SkFloatToScalar(-6.29583e+06f), SkFloatToScalar(1.39135e+08f), SkFloatToScalar(-5.03666e+06f));
+    path.cubicTo(SkFloatToScalar(1.04352e+08f), SkFloatToScalar(-3.77749e+06f), SkFloatToScalar(6.95677e+07f), SkFloatToScalar(-2.51831e+06f), SkFloatToScalar(4.34798e+07f), SkFloatToScalar(-1.57394e+06f));
+    path.cubicTo(SkFloatToScalar(3.04359e+07f), SkFloatToScalar(-1.10175e+06f), SkFloatToScalar(1.95659e+07f), -708258, SkFloatToScalar(1.1957e+07f), -432814);
+    path.cubicTo(SkFloatToScalar(8.15248e+06f), -295092, SkFloatToScalar(5.16324e+06f), -186883, SkFloatToScalar(3.12513e+06f), -113103);
     path.lineTo(798284, -28872);
     path.lineTo(798284, -28872);
-    path.lineTo(22.4044f, 24.6677f);
-    path.lineTo(22.4044f, 24.6677f);
-    path.cubicTo(22.5186f, 24.5432f, 18.8134f, 24.6337f, 14.1287f, 24.8697f);
-    path.cubicTo(9.4439f, 25.1057f, 5.55359f, 25.3978f, 5.43941f, 25.5223f);
+    path.lineTo(SkFloatToScalar(22.4044f), SkFloatToScalar(24.6677f));
+    path.lineTo(SkFloatToScalar(22.4044f), SkFloatToScalar(24.6677f));
+    path.cubicTo(SkFloatToScalar(22.5186f), SkFloatToScalar(24.5432f), SkFloatToScalar(18.8134f), SkFloatToScalar(24.6337f), SkFloatToScalar(14.1287f), SkFloatToScalar(24.8697f));
+    path.cubicTo(SkFloatToScalar(9.4439f), SkFloatToScalar(25.1057f), SkFloatToScalar(5.55359f), SkFloatToScalar(25.3978f), SkFloatToScalar(5.43941f), SkFloatToScalar(25.5223f));
     path.close();
 }
 
 static void build_path_simple_170666(SkPath& path) {
-    path.moveTo(126.677f, 24.1591f);
-    path.cubicTo(2.08703e+08f, -7.555e+06f, 2.78271e+08f, -1.00733e+07f, 2.78271e+08f, -1.00733e+07f);
+    path.moveTo(SkFloatToScalar(126.677f), SkFloatToScalar(24.1591f));
+    path.cubicTo(SkFloatToScalar(2.08703e+08f), SkFloatToScalar(-7.555e+06f), SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f), SkFloatToScalar(2.78271e+08f), SkFloatToScalar(-1.00733e+07f));
 }
 
 // This used to assert in the SK_DEBUG build, as the clip step would fail with
 // too-few interations in our cubic-line intersection code. That code now runs
 // 24 interations (instead of 16).
 static void test_crbug_170666() {
     SkPath path;
     SkPaint paint;
     paint.setAntiAlias(true);
 
@@ skipping 22 matching lines @@
 
     path.reset();
     REPORTER_ASSERT(reporter, path.isFinite());
 
     path.addRect(SkRect::MakeWH(50, 100));
     REPORTER_ASSERT(reporter, path.isFinite());
 }
 
 static void build_big_path(SkPath* path, bool reducedCase) {
     if (reducedCase) {
-        path->moveTo(577330, 1971.72f);
-        path->cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
+        path->moveTo(577330, SkFloatToScalar(1971.72f));
+        path->cubicTo(SkFloatToScalar(10.7082f), SkFloatToScalar(-116.596f), SkFloatToScalar(262.057f), SkFloatToScalar(45.6468f), SkFloatToScalar(294.694f), SkFloatToScalar(1.96237f));
     } else {
-        path->moveTo(60.1631f, 7.70567f);
-        path->quadTo(60.1631f, 7.70567f, 0.99474f, 0.901199f);
-        path->lineTo(577379, 1977.77f);
-        path->quadTo(577364, 1979.57f, 577325, 1980.26f);
-        path->quadTo(577286, 1980.95f, 577245, 1980.13f);
-        path->quadTo(577205, 1979.3f, 577187, 1977.45f);
-        path->quadTo(577168, 1975.6f, 577183, 1973.8f);
-        path->quadTo(577198, 1972, 577238, 1971.31f);
-        path->quadTo(577277, 1970.62f, 577317, 1971.45f);
-        path->quadTo(577330, 1971.72f, 577341, 1972.11f);
-        path->cubicTo(10.7082f, -116.596f, 262.057f, 45.6468f, 294.694f, 1.96237f);
-        path->moveTo(306.718f, -32.912f);
-        path->cubicTo(30.531f, 10.0005f, 1502.47f, 13.2804f, 84.3088f, 9.99601f);
+        path->moveTo(SkFloatToScalar(60.1631f), SkFloatToScalar(7.70567f));
+        path->quadTo(SkFloatToScalar(60.1631f), SkFloatToScalar(7.70567f), SkFloatToScalar(0.99474f), SkFloatToScalar(0.901199f));
+        path->lineTo(577379, SkFloatToScalar(1977.77f));
+        path->quadTo(577364, SkFloatToScalar(1979.57f), 577325, SkFloatToScalar(1980.26f));
+        path->quadTo(577286, SkFloatToScalar(1980.95f), 577245, SkFloatToScalar(1980.13f));
+        path->quadTo(577205, SkFloatToScalar(1979.3f), 577187, SkFloatToScalar(1977.45f));
+        path->quadTo(577168, SkFloatToScalar(1975.6f), 577183, SkFloatToScalar(1973.8f));
+        path->quadTo(577198, 1972, 577238, SkFloatToScalar(1971.31f));
+        path->quadTo(577277, SkFloatToScalar(1970.62f), 577317, SkFloatToScalar(1971.45f));
+        path->quadTo(577330, SkFloatToScalar(1971.72f), 577341, SkFloatToScalar(1972.11f));
+        path->cubicTo(SkFloatToScalar(10.7082f), SkFloatToScalar(-116.596f), SkFloatToScalar(262.057f), SkFloatToScalar(45.6468f), SkFloatToScalar(294.694f), SkFloatToScalar(1.96237f));
+        path->moveTo(SkFloatToScalar(306.718f), SkFloatToScalar(-32.912f));
+        path->cubicTo(SkFloatToScalar(30.531f), SkFloatToScalar(10.0005f), SkFloatToScalar(1502.47f), SkFloatToScalar(13.2804f), SkFloatToScalar(84.3088f), SkFloatToScalar(9.99601f));
     }
 }
 
 static void test_clipped_cubic() {
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRasterPMColor(640, 480));
 
     // This path used to assert, because our cubic-chopping code incorrectly
     // moved control points after the chop. This test should be run in SK_DEBUG
     // mode to ensure that we no long assert.
     SkPath path;
@@ skipping 30 matching lines @@
     SkSurface* surface = SkSurface::NewRasterPMColor(19, 130);
     surface->getCanvas()->drawPath(path, paint);
     surface->unref();
 }
 
 // Inspired by http://code.google.com/p/chromium/issues/detail?id=141651
 //
 static void test_isfinite_after_transform(skiatest::Reporter* reporter) {
     SkPath path;
     path.quadTo(157, 366, 286, 208);
-    path.arcTo(37, 442, 315, 163, 957494590897113.0f);
+    path.arcTo(37, 442, 315, 163, SkFloatToScalar(957494590897113.0f));
 
     SkMatrix matrix;
     matrix.setScale(1000*1000, 1000*1000);
 
     // Be sure that path::transform correctly updates isFinite and the bounds
     // if the transformation overflows. The previous bug was that isFinite was
     // set to true in this case, but the bounds were not set to empty (which
     // they should be).
     while (path.isFinite()) {
         REPORTER_ASSERT(reporter, path.getBounds().isFinite());
@@ skipping 344 matching lines @@
 
 #ifdef SK_SCALAR_IS_FLOAT
     // triangle with one point really far from the origin.
     path.reset();
     // the first point is roughly 1.05e10, 1.05e10
     path.moveTo(SkFloatToScalar(SkBits2Float(0x501c7652)), SkFloatToScalar(SkBits2Float(0x501c7652)));
     path.lineTo(110 * SK_Scalar1, -10 * SK_Scalar1);
     path.lineTo(-10 * SK_Scalar1, 60 * SK_Scalar1);
     check_direction(reporter, path, SkPath::kCCW_Direction);
 #endif
+
+    path.reset();
+    path.conicTo(20, 0, 20, 20, SkFloatToScalar(0.5f));
+    path.close();
+    check_direction(reporter, path, SkPath::kCW_Direction);
+
+    path.reset();
+    path.lineTo(1, SkFloatToScalar(1e7f));
+    path.lineTo(SkFloatToScalar(1e7f), SkFloatToScalar(2e7f));
+    path.close();
+    REPORTER_ASSERT(reporter, SkPath::kConvex_Convexity == path.getConvexity());
+    check_direction(reporter, path, SkPath::kCCW_Direction);
 }
 
 static void add_rect(SkPath* path, const SkRect& r) {
     path->moveTo(r.fLeft, r.fTop);
     path->lineTo(r.fRight, r.fTop);
     path->lineTo(r.fRight, r.fBottom);
     path->lineTo(r.fLeft, r.fBottom);
     path->close();
 }
 
@@ skipping 25 matching lines @@
 
     SkPath fill;
     paint.getFillPath(path, &fill);
 }
 
 // just ensure this can run w/o any SkASSERTS firing in the debug build
 // we used to assert due to differences in how we determine a degenerate vector
 // but that was fixed with the introduction of SkPoint::CanNormalize
 static void stroke_tiny_cubic() {
     SkPoint p0[] = {
-        { 372.0f,   92.0f },
-        { 372.0f,   92.0f },
-        { 372.0f,   92.0f },
-        { 372.0f,   92.0f },
+        { SkFloatToScalar(372.0f),   SkFloatToScalar(92.0f) },
+        { SkFloatToScalar(372.0f),   SkFloatToScalar(92.0f) },
+        { SkFloatToScalar(372.0f),   SkFloatToScalar(92.0f) },
+        { SkFloatToScalar(372.0f),   SkFloatToScalar(92.0f) },
     };
 
     stroke_cubic(p0);
 
     SkPoint p1[] = {
-        { 372.0f,       92.0f },
-        { 372.0007f,    92.000755f },
-        { 371.99927f,   92.003922f },
-        { 371.99826f,   92.003899f },
+        { SkFloatToScalar(372.0f),       SkFloatToScalar(92.0f) },
+        { SkFloatToScalar(372.0007f),    SkFloatToScalar(92.000755f) },
+        { SkFloatToScalar(371.99927f),   SkFloatToScalar(92.003922f) },
+        { SkFloatToScalar(371.99826f),   SkFloatToScalar(92.003899f) },
     };
 
     stroke_cubic(p1);
 }
 
 static void check_close(skiatest::Reporter* reporter, const SkPath& path) {
     for (int i = 0; i < 2; ++i) {
         SkPath::Iter iter(path, SkToBool(i));
         SkPoint mv;
         SkPoint pts[4];
@@ skipping 257 matching lines @@
         { "0 0 10 10 10 0", SkPath::kConvex_Convexity, SkPath::kCCW_Direction },
         { "0 0 10 10 10 0 0 10", SkPath::kConcave_Convexity, kDontCheckDir },
         { "0 0 10 0 0 10 -10 -10", SkPath::kConcave_Convexity, SkPath::kCW_Direction },
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gRec); ++i) {
         SkPath path;
         setFromString(&path, gRec[i].fPathStr);
         check_convexity(reporter, path, gRec[i].fExpectedConvexity);
         check_direction(reporter, path, gRec[i].fExpectedDirection);
+        // check after setting the initial convex and direction
+        if (kDontCheckDir != gRec[i].fExpectedDirection) {
+            SkPath copy(path);
+            SkPath::Direction dir;
+            bool foundDir = copy.cheapComputeDirection(&dir);
+            REPORTER_ASSERT(reporter, (gRec[i].fExpectedDirection == SkPath::kUnknown_Direction)
+                    ^ foundDir);
+            REPORTER_ASSERT(reporter, !foundDir || gRec[i].fExpectedDirection == dir);
+            check_convexity(reporter, copy, gRec[i].fExpectedConvexity);
+        }
+        REPORTER_ASSERT(reporter, gRec[i].fExpectedConvexity == path.getConvexity());
+        check_direction(reporter, path, gRec[i].fExpectedDirection);
     }
 }
 
 static void test_isLine(skiatest::Reporter* reporter) {
     SkPath path;
     SkPoint pts[2];
     const SkScalar value = SkIntToScalar(5);
 
     REPORTER_ASSERT(reporter, !path.isLine(NULL));
 
     // set some non-zero values
     pts[0].set(value, value);
     pts[1].set(value, value);
     REPORTER_ASSERT(reporter, !path.isLine(pts));
     // check that pts was untouched
     REPORTER_ASSERT(reporter, pts[0].equals(value, value));
     REPORTER_ASSERT(reporter, pts[1].equals(value, value));
 
     const SkScalar moveX = SkIntToScalar(1);
     const SkScalar moveY = SkIntToScalar(2);
-    SkASSERT(value != moveX && value != moveY);
+    REPORTER_ASSERT(reporter, value != moveX && value != moveY);
 
     path.moveTo(moveX, moveY);
     REPORTER_ASSERT(reporter, !path.isLine(NULL));
     REPORTER_ASSERT(reporter, !path.isLine(pts));
     // check that pts was untouched
     REPORTER_ASSERT(reporter, pts[0].equals(value, value));
     REPORTER_ASSERT(reporter, pts[1].equals(value, value));
 
     const SkScalar lineX = SkIntToScalar(2);
     const SkScalar lineY = SkIntToScalar(2);
-    SkASSERT(value != lineX && value != lineY);
+    REPORTER_ASSERT(reporter, value != lineX && value != lineY);
 
     path.lineTo(lineX, lineY);
     REPORTER_ASSERT(reporter, path.isLine(NULL));
 
     REPORTER_ASSERT(reporter, !pts[0].equals(moveX, moveY));
     REPORTER_ASSERT(reporter, !pts[1].equals(lineX, lineY));
     REPORTER_ASSERT(reporter, path.isLine(pts));
     REPORTER_ASSERT(reporter, pts[0].equals(moveX, moveY));
     REPORTER_ASSERT(reporter, pts[1].equals(lineX, lineY));
 
@@ skipping 16 matching lines @@
     static const SkPoint kCircleC = {kBaseRect.centerX(), kBaseRect.centerY()};
 
     // round-rect radii
     static const SkScalar kRRRadii[] = {SkIntToScalar(5), SkIntToScalar(3)};
 
     static const struct SUPPRESS_VISIBILITY_WARNING {
         SkRect fQueryRect;
         bool   fInRect;
         bool   fInCircle;
         bool   fInRR;
+        bool   fInCubicRR;
     } kQueries[] = {
-        {kBaseRect, true, true, false},
+        {kBaseRect, true, true, false, false},
 
         // rect well inside of kBaseRect
         {SkRect::MakeLTRB(kBaseRect.fLeft + SkFloatToScalar(0.25f)*kBaseRect.width(),
                           kBaseRect.fTop + SkFloatToScalar(0.25f)*kBaseRect.height(),
                           kBaseRect.fRight - SkFloatToScalar(0.25f)*kBaseRect.width(),
                           kBaseRect.fBottom - SkFloatToScalar(0.25f)*kBaseRect.height()),
-                          true, true, true},
+                          true, true, true, true},
 
         // rects with edges off by one from kBaseRect's edges
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,
                           kBaseRect.width(), kBaseRect.height() + 1),
-         false, true, false},
+         false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,
                           kBaseRect.width() + 1, kBaseRect.height()),
-         false, true, false},
+         false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop,
                           kBaseRect.width() + 1, kBaseRect.height() + 1),
-         false, true, false},
+         false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft - 1, kBaseRect.fTop,
                           kBaseRect.width(), kBaseRect.height()),
-         false, true, false},
+         false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop - 1,
                           kBaseRect.width(), kBaseRect.height()),
-         false, true, false},
+         false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft - 1, kBaseRect.fTop,
                           kBaseRect.width() + 2, kBaseRect.height()),
-         false, true, false},
+         false, true, false, false},
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop - 1,
                           kBaseRect.width() + 2, kBaseRect.height()),
-         false, true, false},
+         false, true, false, false},
 
         // zero-w/h rects at each corner of kBaseRect
-        {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop, 0, 0), true, true, false},
-        {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fTop, 0, 0), true, true, false},
-        {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fBottom, 0, 0), true, true, false},
-        {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fBottom, 0, 0), true, true, false},
+        {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fTop, 0, 0), true, true, false, false},
+        {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fTop, 0, 0), true, true, false, true},
+        {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.fBottom, 0, 0), true, true, false, true},
+        {SkRect::MakeXYWH(kBaseRect.fRight, kBaseRect.fBottom, 0, 0), true, true, false, true},
 
         // far away rect
         {SkRect::MakeXYWH(10 * kBaseRect.fRight, 10 * kBaseRect.fBottom,
                           SkIntToScalar(10), SkIntToScalar(10)),
-         false, false, false},
+         false, false, false, false},
 
         // very large rect containing kBaseRect
         {SkRect::MakeXYWH(kBaseRect.fLeft - 5 * kBaseRect.width(),
                           kBaseRect.fTop - 5 * kBaseRect.height(),
                           11 * kBaseRect.width(), 11 * kBaseRect.height()),
-         false, false, false},
+         false, false, false, false},
 
         // skinny rect that spans same y-range as kBaseRect
         {SkRect::MakeXYWH(kBaseRect.centerX(), kBaseRect.fTop,
                           SkIntToScalar(1), kBaseRect.height()),
-         true, true, true},
+         true, true, true, true},
 
         // short rect that spans same x-range as kBaseRect
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.centerY(), kBaseRect.width(), SkScalar(1)),
-         true, true, true},
+         true, true, true, true},
 
         // skinny rect that spans slightly larger y-range than kBaseRect
         {SkRect::MakeXYWH(kBaseRect.centerX(), kBaseRect.fTop,
                           SkIntToScalar(1), kBaseRect.height() + 1),
-         false, true, false},
+         false, true, false, false},
 
         // short rect that spans slightly larger x-range than kBaseRect
         {SkRect::MakeXYWH(kBaseRect.fLeft, kBaseRect.centerY(),
                           kBaseRect.width() + 1, SkScalar(1)),
-         false, true, false},
+         false, true, false, false},
     };
 
     for (int inv = 0; inv < 4; ++inv) {
         for (size_t q = 0; q < SK_ARRAY_COUNT(kQueries); ++q) {
             SkRect qRect = kQueries[q].fQueryRect;
             if (inv & 0x1) {
                 SkTSwap(qRect.fLeft, qRect.fRight);
             }
             if (inv & 0x2) {
                 SkTSwap(qRect.fTop, qRect.fBottom);
             }
             for (int d = 0; d < 2; ++d) {
                 SkPath::Direction dir = d ? SkPath::kCCW_Direction : SkPath::kCW_Direction;
                 path.reset();
                 path.addRect(kBaseRect, dir);
                 REPORTER_ASSERT(reporter, kQueries[q].fInRect ==
                                           path.conservativelyContainsRect(qRect));
 
                 path.reset();
                 path.addCircle(kCircleC.fX, kCircleC.fY, circleR, dir);
                 REPORTER_ASSERT(reporter, kQueries[q].fInCircle ==
                                           path.conservativelyContainsRect(qRect));
 
                 path.reset();
                 path.addRoundRect(kBaseRect, kRRRadii[0], kRRRadii[1], dir);
                 REPORTER_ASSERT(reporter, kQueries[q].fInRR ==
                                           path.conservativelyContainsRect(qRect));
+
+                path.reset();
+                path.moveTo(kBaseRect.fLeft + kRRRadii[0], kBaseRect.fTop);
+                path.cubicTo(kBaseRect.fLeft + kRRRadii[0] / 2, kBaseRect.fTop,
+                             kBaseRect.fLeft, kBaseRect.fTop + kRRRadii[1] / 2,
+                             kBaseRect.fLeft, kBaseRect.fTop + kRRRadii[1]);
+                path.lineTo(kBaseRect.fLeft, kBaseRect.fBottom);
+                path.lineTo(kBaseRect.fRight, kBaseRect.fBottom);
+                path.lineTo(kBaseRect.fRight, kBaseRect.fTop);
+                path.close();
+                REPORTER_ASSERT(reporter, kQueries[q].fInCubicRR ==
+                                          path.conservativelyContainsRect(qRect));
+                
             }
             // Slightly non-convex shape, shouldn't contain any rects.
             path.reset();
             path.moveTo(0, 0);
             path.lineTo(SkIntToScalar(50), SkFloatToScalar(0.05f));
             path.lineTo(SkIntToScalar(100), 0);
             path.lineTo(SkIntToScalar(100), SkIntToScalar(100));
             path.lineTo(0, SkIntToScalar(100));
             path.close();
             REPORTER_ASSERT(reporter, !path.conservativelyContainsRect(qRect));
@@ skipping 69 matching lines @@
     // passing tests (all moveTo / lineTo...
     SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}};
     SkPoint r2[] = {{1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint r3[] = {{1, 1}, {0, 1}, {0, 0}, {1, 0}};
     SkPoint r4[] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
     SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};
     SkPoint r6[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};
     SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};
     SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
-    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, {1, 0}, {.5f, 0}};
-    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, {0, 1}, {0, .5f}};
+    SkPoint ra[] = {{0, 0}, {0, SkFloatToScalar(.5f)}, {0, 1}, {SkFloatToScalar(.5f), 1}, {1, 1}, {1, SkFloatToScalar(.5f)}, {1, 0}, {SkFloatToScalar(.5f), 0}};
+    SkPoint rb[] = {{0, 0}, {SkFloatToScalar(.5f), 0}, {1, 0}, {1, SkFloatToScalar(.5f)}, {1, 1}, {SkFloatToScalar(.5f), 1}, {0, 1}, {0, SkFloatToScalar(.5f)}};
     SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}};
     SkPoint rf[] = {{1, 0}, {8, 0}, {8, 8}, {0, 8}, {0, 0}};
 
     // failing tests
     SkPoint f1[] = {{0, 0}, {1, 0}, {1, 1}}; // too few points
     SkPoint f2[] = {{0, 0}, {1, 1}, {0, 1}, {1, 0}}; // diagonal
     SkPoint f3[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}, {1, 0}}; // wraps
     SkPoint f4[] = {{0, 0}, {1, 0}, {0, 0}, {1, 0}, {1, 1}, {0, 1}}; // backs up
@@ skipping 96 matching lines @@
     }
     path1.close();
     path1.lineTo(1, 0);
     REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, move in the middle
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         if (index == 2) {
-            path1.moveTo(1, .5f);
+            path1.moveTo(1, SkFloatToScalar(.5f));
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, move on the edge
     path1.reset();
     for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         path1.moveTo(r1[index - 1].fX, r1[index - 1].fY);
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, quad
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         if (index == 2) {
-            path1.quadTo(1, .5f, 1, .5f);
+            path1.quadTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 
     // fail, cubic
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
     for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
         if (index == 2) {
-            path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
+            path1.cubicTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));
         }
         path1.lineTo(r1[index].fX, r1[index].fY);
     }
     path1.close();
     REPORTER_ASSERT(reporter, !path1.isRect(NULL));
 }
 
 static void test_isNestedRects(skiatest::Reporter* reporter) {
     // passing tests (all moveTo / lineTo...
     SkPoint r1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
     SkPoint r2[] = {{1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint r3[] = {{1, 1}, {0, 1}, {0, 0}, {1, 0}};
     SkPoint r4[] = {{0, 1}, {0, 0}, {1, 0}, {1, 1}};
     SkPoint r5[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}}; // CCW
     SkPoint r6[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint r7[] = {{1, 1}, {1, 0}, {0, 0}, {0, 1}};
     SkPoint r8[] = {{1, 0}, {0, 0}, {0, 1}, {1, 1}};
     SkPoint r9[] = {{0, 1}, {1, 1}, {1, 0}, {0, 0}};
-    SkPoint ra[] = {{0, 0}, {0, .5f}, {0, 1}, {.5f, 1}, {1, 1}, {1, .5f}, {1, 0}, {.5f, 0}}; // CCW
-    SkPoint rb[] = {{0, 0}, {.5f, 0}, {1, 0}, {1, .5f}, {1, 1}, {.5f, 1}, {0, 1}, {0, .5f}}; // CW
+    SkPoint ra[] = {{0, 0}, {0, SkFloatToScalar(.5f)}, {0, 1}, {SkFloatToScalar(.5f), 1}, {1, 1}, {1, SkFloatToScalar(.5f)}, {1, 0}, {SkFloatToScalar(.5f), 0}}; // CCW
+    SkPoint rb[] = {{0, 0}, {SkFloatToScalar(.5f), 0}, {1, 0}, {1, SkFloatToScalar(.5f)}, {1, 1}, {SkFloatToScalar(.5f), 1}, {0, 1}, {0, SkFloatToScalar(.5f)}}; // CW
     SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}}; // CW
     SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}}; // CCW
     SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}}; // CW
 
     // failing tests
     SkPoint f1[] = {{0, 0}, {1, 0}, {1, 1}}; // too few points
     SkPoint f2[] = {{0, 0}, {1, 1}, {0, 1}, {1, 0}}; // diagonal
     SkPoint f3[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}, {1, 0}}; // wraps
     SkPoint f4[] = {{0, 0}, {1, 0}, {0, 0}, {1, 0}, {1, 1}, {0, 1}}; // backs up
     SkPoint f5[] = {{0, 0}, {1, 0}, {1, 1}, {2, 0}}; // end overshoots
@@ skipping 97 matching lines @@
         REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, move in the middle
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             if (index == 2) {
-                path1.moveTo(1, .5f);
+                path1.moveTo(1, SkFloatToScalar(.5f));
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
         REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, move on the edge
@@ skipping 12 matching lines @@
         REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, quad
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             if (index == 2) {
-                path1.quadTo(1, .5f, 1, .5f);
+                path1.quadTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
         REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail, cubic
         path1.reset();
         if (rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCW_Direction);
         }
         path1.moveTo(r1[0].fX, r1[0].fY);
         for (index = 1; index < SK_ARRAY_COUNT(r1); ++index) {
             if (index == 2) {
-                path1.cubicTo(1, .5f, 1, .5f, 1, .5f);
+                path1.cubicTo(1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f), 1, SkFloatToScalar(.5f));
             }
             path1.lineTo(r1[index].fX, r1[index].fY);
         }
         path1.close();
         if (!rectFirst) {
             path1.addRect(-1, -1, 2, 2, SkPath::kCCW_Direction);
         }
         REPORTER_ASSERT(reporter, !path1.isNestedRects(NULL));
 
         // fail,  not nested
@@ skipping 77 matching lines @@
         SkRect rect = SkRect::MakeWH(10, 10);
         oval.addOval(rect);
 
         write_and_read_back(reporter, oval);
     }
 }
 
 static void test_transform(skiatest::Reporter* reporter) {
     SkPath p, p1;
 
+#define CONIC_PERSPECTIVE_BUG_FIXED 0
     static const SkPoint pts[] = {
-        { 0, 0 },
-        { SkIntToScalar(10), SkIntToScalar(10) },
-        { SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 },
-        { 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) }
+        { 0, 0 },  // move
+        { SkIntToScalar(10), SkIntToScalar(10) },  // line
+        { SkIntToScalar(20), SkIntToScalar(10) }, { SkIntToScalar(20), 0 },  // quad
+        { 0, 0 }, { 0, SkIntToScalar(10) }, { SkIntToScalar(1), SkIntToScalar(10) },  // cubic
+#if CONIC_PERSPECTIVE_BUG_FIXED
+        { 0, 0 }, { SkIntToScalar(20), SkIntToScalar(10) },  // conic
+#endif
     };
+    const int kPtCount = SK_ARRAY_COUNT(pts);
     p.moveTo(pts[0]);
     p.lineTo(pts[1]);
     p.quadTo(pts[2], pts[3]);
     p.cubicTo(pts[4], pts[5], pts[6]);
-
+#if CONIC_PERSPECTIVE_BUG_FIXED
+    p.conicTo(pts[4], pts[5], SkFloatToScalar(0.5f));
+#endif
+    p.close();
     SkMatrix matrix;
     matrix.reset();
     p.transform(matrix, &p1);
     REPORTER_ASSERT(reporter, p == p1);
 
     matrix.setScale(SK_Scalar1 * 2, SK_Scalar1 * 3);
     p.transform(matrix, &p1);
-    SkPoint pts1[7];
-    int count = p1.getPoints(pts1, 7);
-    REPORTER_ASSERT(reporter, 7 == count);
+    SkPoint pts1[kPtCount];
+    int count = p1.getPoints(pts1, kPtCount);
+    REPORTER_ASSERT(reporter, kPtCount == count);
     for (int i = 0; i < count; ++i) {
         SkPoint newPt = SkPoint::Make(pts[i].fX * 2, pts[i].fY * 3);
         REPORTER_ASSERT(reporter, newPt == pts1[i]);
     }
+    matrix.reset();
+    matrix.setPerspX(SkScalarToPersp(4));
+    p.transform(matrix, &p1);
+    REPORTER_ASSERT(reporter, matrix.invert(&matrix));
+    p1.transform(matrix, NULL);
+    SkRect pBounds = p.getBounds();
+    SkRect p1Bounds = p1.getBounds();
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fLeft, p1Bounds.fLeft));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fTop, p1Bounds.fTop));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fRight, p1Bounds.fRight));
+    REPORTER_ASSERT(reporter, SkScalarNearlyEqual(pBounds.fBottom, p1Bounds.fBottom));
+
+    matrix.reset();
+    p.reset();
+    p.addCircle(0, 0, 1, SkPath::kCW_Direction);
+    p.transform(matrix, &p1);
+    REPORTER_ASSERT(reporter, p1.cheapIsDirection(SkPath::kCW_Direction));
+    matrix.setScaleX(-1);
+    p.transform(matrix, &p1);
+    REPORTER_ASSERT(reporter, p1.cheapIsDirection(SkPath::kCCW_Direction));
+    matrix.setAll(1, 1, 0, 1, 1, 0, 0, 0, 1);
+    p.transform(matrix, &p1);
+    REPORTER_ASSERT(reporter, p1.cheapIsDirection(SkPath::kUnknown_Direction));
 }
 
 static void test_zero_length_paths(skiatest::Reporter* reporter) {
     SkPath  p;
     uint8_t verbs[32];
 
     struct SUPPRESS_VISIBILITY_WARNING zeroPathTestData {
         const char* testPath;
         const size_t numResultPts;
         const SkRect resultBound;
@@ skipping 183 matching lines @@
         int j = 0, l = 0;
         do {
             REPORTER_ASSERT(reporter, iter.next(pts, gIterTests[i].consumeDegenerates) == gIterTests[i].resultVerbs[j]);
             for (int k = 0; k < (int)gIterTests[i].numResultPtsPerVerb[j]; ++k) {
                 REPORTER_ASSERT(reporter, pts[k] == gIterTests[i].resultPts[l++]);
             }
         } while (gIterTests[i].resultVerbs[j++] != SkPath::kDone_Verb);
         REPORTER_ASSERT(reporter, j == (int)gIterTests[i].numResultVerbs);
     }
 
+    p.reset();
+    iter.setPath(p, false);
+    REPORTER_ASSERT(reporter, !iter.isClosedContour());
+    p.lineTo(1, 1);
+    p.close();
+    iter.setPath(p, false);
+    REPORTER_ASSERT(reporter, iter.isClosedContour());
+    p.reset();
+    iter.setPath(p, true);
+    REPORTER_ASSERT(reporter, !iter.isClosedContour());
+    p.lineTo(1, 1);
+    iter.setPath(p, true);
+    REPORTER_ASSERT(reporter, iter.isClosedContour());
+    p.moveTo(0, 0);
+    p.lineTo(2, 2);
+    iter.setPath(p, false);
+    REPORTER_ASSERT(reporter, !iter.isClosedContour());
+
+    // this checks to see if the NaN logic is executed in SkPath::autoClose(), but does not
+    // check to see if the result is correct.
+    for (int setNaN = 0; setNaN < 4; ++setNaN) {
+        p.reset();
+        p.moveTo(setNaN == 0 ? SK_ScalarNaN : 0, setNaN == 1 ? SK_ScalarNaN : 0);
+        p.lineTo(setNaN == 2 ? SK_ScalarNaN : 1, setNaN == 3 ? SK_ScalarNaN : 1);
+        iter.setPath(p, true);
+        iter.next(pts, false);
+        iter.next(pts, false);
+        REPORTER_ASSERT(reporter, SkPath::kClose_Verb == iter.next(pts, false));
+    }
+
+    p.reset();
+    p.quadTo(0, 0, 0, 0);
+    iter.setPath(p, false);
+    iter.next(pts, false);
+    REPORTER_ASSERT(reporter, SkPath::kQuad_Verb == iter.next(pts, false));
+    iter.setPath(p, false);
+    iter.next(pts, false);
+    REPORTER_ASSERT(reporter, SkPath::kDone_Verb == iter.next(pts, true));
+    
+    p.reset();
+    p.cubicTo(0, 0, 0, 0, 0, 0);
+    iter.setPath(p, false);
+    iter.next(pts, false);
+    REPORTER_ASSERT(reporter, SkPath::kCubic_Verb == iter.next(pts, false));
+    iter.setPath(p, false);
+    iter.next(pts, false);
+    REPORTER_ASSERT(reporter, SkPath::kDone_Verb == iter.next(pts, true));
+
     // The GM degeneratesegments.cpp test is more extensive
 }
 
 static void test_raw_iter(skiatest::Reporter* reporter) {
     SkPath p;
     SkPoint pts[4];
 
     // Test an iterator with no path
     SkPath::RawIter noPathIter;
     REPORTER_ASSERT(reporter, noPathIter.next(pts) == SkPath::kDone_Verb);
@@ skipping 239 matching lines @@
                              SkPath::Direction dir) {
     SkPath tmp;
 
     SkMatrix m;
     m.setSkew(SkIntToScalar(3), SkIntToScalar(5));
     path.transform(m, &tmp);
     // this matrix reverses the direction.
     if (SkPath::kCCW_Direction == dir) {
         dir = SkPath::kCW_Direction;
     } else {
-        SkASSERT(SkPath::kCW_Direction == dir);
+        REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);
         dir = SkPath::kCCW_Direction;
     }
     check_for_circle(reporter, tmp, false, dir);
 }
 
 static void test_circle_translate(skiatest::Reporter* reporter,
                                   const SkPath& path,
                                   SkPath::Direction dir) {
     SkPath tmp;
 
@@ skipping 37 matching lines @@
                                  SkPath::Direction dir) {
     SkPath tmp;
     SkMatrix m;
     m.reset();
     m.setScaleX(-SK_Scalar1);
     path.transform(m, &tmp);
 
     if (SkPath::kCW_Direction == dir) {
         dir = SkPath::kCCW_Direction;
     } else {
-        SkASSERT(SkPath::kCCW_Direction == dir);
+        REPORTER_ASSERT(reporter, SkPath::kCCW_Direction == dir);
         dir = SkPath::kCW_Direction;
     }
 
     check_for_circle(reporter, tmp, true, dir);
 }
 
 static void test_circle_mirror_y(skiatest::Reporter* reporter,
                                  const SkPath& path,
                                  SkPath::Direction dir) {
     SkPath tmp;
     SkMatrix m;
     m.reset();
     m.setScaleY(-SK_Scalar1);
     path.transform(m, &tmp);
 
     if (SkPath::kCW_Direction == dir) {
         dir = SkPath::kCCW_Direction;
     } else {
-        SkASSERT(SkPath::kCCW_Direction == dir);
+        REPORTER_ASSERT(reporter, SkPath::kCCW_Direction == dir);
         dir = SkPath::kCW_Direction;
     }
 
     check_for_circle(reporter, tmp, true, dir);
 }
 
 static void test_circle_mirror_xy(skiatest::Reporter* reporter,
                                  const SkPath& path,
                                  SkPath::Direction dir) {
     SkPath tmp;
@@ skipping 152 matching lines @@
     REPORTER_ASSERT(reporter, 0 == p.countPoints());
     REPORTER_ASSERT(reporter, 0 == p.countVerbs());
     REPORTER_ASSERT(reporter, 0 == p.getSegmentMasks());
     REPORTER_ASSERT(reporter, p.isConvex());
     REPORTER_ASSERT(reporter, p.getFillType() == SkPath::kWinding_FillType);
     REPORTER_ASSERT(reporter, !p.isInverseFillType());
     REPORTER_ASSERT(reporter, p == empty);
     REPORTER_ASSERT(reporter, !(p != empty));
 }
 
-static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path) {
+static void test_rrect_is_convex(skiatest::Reporter* reporter, SkPath* path,
+                                 SkPath::Direction dir) {
     REPORTER_ASSERT(reporter, path->isConvex());
+    REPORTER_ASSERT(reporter, path->cheapIsDirection(dir));
     path->setConvexity(SkPath::kUnknown_Convexity);
     REPORTER_ASSERT(reporter, path->isConvex());
     path->reset();
 }
 
 static void test_rrect(skiatest::Reporter* reporter) {
     SkPath p;
     SkRRect rr;
     SkVector radii[] = {{1, 2}, {3, 4}, {5, 6}, {7, 8}};
     SkRect r = {10, 20, 30, 40};
     rr.setRectRadii(r, radii);
     p.addRRect(rr);
-    test_rrect_is_convex(reporter, &p);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
     p.addRRect(rr, SkPath::kCCW_Direction);
-    test_rrect_is_convex(reporter, &p);
+    test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);
     p.addRoundRect(r, &radii[0].fX);
-    test_rrect_is_convex(reporter, &p);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
     p.addRoundRect(r, &radii[0].fX, SkPath::kCCW_Direction);
-    test_rrect_is_convex(reporter, &p);
+    test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);
     p.addRoundRect(r, radii[1].fX, radii[1].fY);
-    test_rrect_is_convex(reporter, &p);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
     p.addRoundRect(r, radii[1].fX, radii[1].fY, SkPath::kCCW_Direction);
-    test_rrect_is_convex(reporter, &p);
-}
+    test_rrect_is_convex(reporter, &p, SkPath::kCCW_Direction);
+    for (size_t i = 0; i < SK_ARRAY_COUNT(radii); ++i) {
+        SkVector save = radii[i];
+        radii[i].set(0, 0);
+        rr.setRectRadii(r, radii);
+        p.addRRect(rr);
+        test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+        radii[i] = save;
+    }
+    p.addRoundRect(r, 0, 0);
+    SkRect returnedRect;
+    REPORTER_ASSERT(reporter, p.isRect(&returnedRect));
+    REPORTER_ASSERT(reporter, returnedRect == r);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+    SkVector zeroRadii[] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}};
+    rr.setRectRadii(r, zeroRadii);
+    p.addRRect(rr);
+    bool closed;
+    SkPath::Direction dir;
+    REPORTER_ASSERT(reporter, p.isRect(&closed, &dir));
+    REPORTER_ASSERT(reporter, closed);
+    REPORTER_ASSERT(reporter, SkPath::kCW_Direction == dir);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+    p.addRRect(rr, SkPath::kCW_Direction);
+    p.addRRect(rr, SkPath::kCW_Direction);
+    REPORTER_ASSERT(reporter, !p.isConvex());
+    p.reset();
+    p.addRRect(rr, SkPath::kCCW_Direction);
+    p.addRRect(rr, SkPath::kCCW_Direction);
+    REPORTER_ASSERT(reporter, !p.isConvex());
+    p.reset();
+    SkRect emptyR = {10, 20, 10, 30};
+    rr.setRectRadii(emptyR, radii);
+    p.addRRect(rr);
+    REPORTER_ASSERT(reporter, p.isEmpty());
+    SkRect largeR = {0, 0, SK_ScalarMax, SK_ScalarMax};
+    rr.setRectRadii(largeR, radii);
+    p.addRRect(rr);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+    SkRect infR = {0, 0, SK_ScalarMax, SK_ScalarInfinity};
+    rr.setRectRadii(infR, radii);
+    p.addRRect(rr);
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+    SkRect tinyR = {0, 0, SkFloatToScalar(1e-9), SkFloatToScalar(1e-9)};
+    p.addRoundRect(tinyR, SkFloatToScalar(5e-11), SkFloatToScalar(5e-11));
+    test_rrect_is_convex(reporter, &p, SkPath::kCW_Direction);
+}
+
+static void test_arc(skiatest::Reporter* reporter) {
+    SkPath p;
+    SkRect emptyOval = {10, 20, 30, 20};
+    REPORTER_ASSERT(reporter, emptyOval.isEmpty());
+    p.addArc(emptyOval, 1, 2);
+    REPORTER_ASSERT(reporter, p.isEmpty());
+    p.reset();
+    SkRect oval = {10, 20, 30, 40};
+    p.addArc(oval, 1, 0);
+    REPORTER_ASSERT(reporter, p.isEmpty());
+    p.reset();
+    SkPath cwOval;
+    cwOval.addOval(oval);
+    p.addArc(oval, 1, 360);
+    REPORTER_ASSERT(reporter, p == cwOval);
+    p.reset();
+    SkPath ccwOval;
+    ccwOval.addOval(oval, SkPath::kCCW_Direction);
+    p.addArc(oval, 1, -360);
+    REPORTER_ASSERT(reporter, p == ccwOval);
+    p.reset();
+    p.addArc(oval, 1, 180);
+    REPORTER_ASSERT(reporter, p.isConvex());
+    REPORTER_ASSERT(reporter, p.cheapIsDirection(SkPath::kCW_Direction));
+    p.setConvexity(SkPath::kUnknown_Convexity);
+    REPORTER_ASSERT(reporter, p.isConvex());
+}
+
+static void check_move(skiatest::Reporter* reporter, SkPath::RawIter* iter,
+                       SkScalar x0, SkScalar y0) {
+    SkPoint pts[4];
+    SkPath::Verb v = iter->next(pts);
+    REPORTER_ASSERT(reporter, v == SkPath::kMove_Verb);
+    REPORTER_ASSERT(reporter, pts[0].fX == x0);
+    REPORTER_ASSERT(reporter, pts[0].fY == y0);
+}
+
+static void check_line(skiatest::Reporter* reporter, SkPath::RawIter* iter,
+                       SkScalar x1, SkScalar y1) {
+    SkPoint pts[4];
+    SkPath::Verb v = iter->next(pts);
+    REPORTER_ASSERT(reporter, v == SkPath::kLine_Verb);
+    REPORTER_ASSERT(reporter, pts[1].fX == x1);
+    REPORTER_ASSERT(reporter, pts[1].fY == y1);
+}
+
+static void check_quad(skiatest::Reporter* reporter, SkPath::RawIter* iter,
+                       SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
+    SkPoint pts[4];
+    SkPath::Verb v = iter->next(pts);
+    REPORTER_ASSERT(reporter, v == SkPath::kQuad_Verb);
+    REPORTER_ASSERT(reporter, pts[1].fX == x1);
+    REPORTER_ASSERT(reporter, pts[1].fY == y1);
+    REPORTER_ASSERT(reporter, pts[2].fX == x2);
+    REPORTER_ASSERT(reporter, pts[2].fY == y2);
+}
+
+static void check_done(skiatest::Reporter* reporter, SkPath* p, SkPath::RawIter* iter) {
+    SkPoint pts[4];
+    SkPath::Verb v = iter->next(pts);
+    REPORTER_ASSERT(reporter, v == SkPath::kDone_Verb);
+}
+
+static void check_done_and_reset(skiatest::Reporter* reporter, SkPath* p, SkPath::RawIter* iter) {
+    check_done(reporter, p, iter);
+    p->reset();
+}
+
+static void check_path_is_move_and_reset(skiatest::Reporter* reporter, SkPath* p,
+                                         SkScalar x0, SkScalar y0) {
+    SkPath::RawIter iter(*p);
+    check_move(reporter, &iter, x0, y0);
+    check_done_and_reset(reporter, p, &iter);
+}
+
+static void check_path_is_line_and_reset(skiatest::Reporter* reporter, SkPath* p,
+                                         SkScalar x1, SkScalar y1) {
+    SkPath::RawIter iter(*p);
+    check_move(reporter, &iter, 0, 0);
+    check_line(reporter, &iter, x1, y1);
+    check_done_and_reset(reporter, p, &iter);
+}
+
+static void check_path_is_line(skiatest::Reporter* reporter, SkPath* p,
+                                         SkScalar x1, SkScalar y1) {
+    SkPath::RawIter iter(*p);
+    check_move(reporter, &iter, 0, 0);
+    check_line(reporter, &iter, x1, y1);
+    check_done(reporter, p, &iter);
+}
+
+static void check_path_is_line_pair_and_reset(skiatest::Reporter* reporter, SkPath* p,
+                                    SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
+    SkPath::RawIter iter(*p);
+    check_move(reporter, &iter, 0, 0);
+    check_line(reporter, &iter, x1, y1);
+    check_line(reporter, &iter, x2, y2);
+    check_done_and_reset(reporter, p, &iter);
+}
+
+static void check_path_is_quad_and_reset(skiatest::Reporter* reporter, SkPath* p,
+                                    SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
+    SkPath::RawIter iter(*p);
+    check_move(reporter, &iter, 0, 0);
+    check_quad(reporter, &iter, x1, y1, x2, y2);
+    check_done_and_reset(reporter, p, &iter);
+}
+
+static void test_arcTo(skiatest::Reporter* reporter) {
+    SkPath p;
+    p.arcTo(0, 0, 1, 2, 1);
+    check_path_is_line_and_reset(reporter, &p, 0, 0);
+    p.arcTo(1, 2, 1, 2, 1);
+    check_path_is_line_and_reset(reporter, &p, 1, 2);
+    p.arcTo(1, 2, 3, 4, 0);
+    check_path_is_line_and_reset(reporter, &p, 1, 2);
+    p.arcTo(1, 2, 0, 0, 1);
+    check_path_is_line_and_reset(reporter, &p, 1, 2);
+    p.arcTo(1, 0, 1, 1, 1);
+    SkPoint pt;
+    REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt.fX == 1 && pt.fY == 1);
+    p.reset();
+    p.arcTo(1, 0, 1, -1, 1);
+    REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt.fX == 1 && pt.fY == -1);
+    p.reset();
+    SkRect oval = {1, 2, 3, 4};
+    p.arcTo(oval, 0, 0, true);
+    check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
+    p.arcTo(oval, 0, 0, false);
+    check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
+    p.arcTo(oval, 360, 0, true);
+    check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
+    p.arcTo(oval, 360, 0, false);
+    check_path_is_move_and_reset(reporter, &p, oval.fRight, oval.centerY());
+    for (float sweep = 359, delta = 0.5f; sweep != (float) (sweep + delta); ) {
+        p.arcTo(oval, 0, SkFloatToScalar(sweep), false);
+        REPORTER_ASSERT(reporter, p.getBounds() == oval);
+        sweep += delta;
+        delta /= 2;
+    }
+    for (float sweep = 361, delta = 0.5f; sweep != (float) (sweep - delta);) {
+        p.arcTo(oval, 0, SkFloatToScalar(sweep), false);
+        REPORTER_ASSERT(reporter, p.getBounds() == oval);
+        sweep -= delta;
+        delta /= 2;
+    }
+}
+
+static void test_addPath(skiatest::Reporter* reporter) {
+    SkPath p, q;
+    p.lineTo(1, 2);
+    q.moveTo(4, 4);
+    q.lineTo(7, 8);
+    q.conicTo(8, 7, 6, 5, SkFloatToScalar(0.5f));
+    q.quadTo(6, 7, 8, 6);
+    q.cubicTo(5, 6, 7, 8, 7, 5);
+    q.close();
+    p.addPath(q, -4, -4);
+    SkRect expected = {0, 0, 4, 4};
+    REPORTER_ASSERT(reporter, p.getBounds() == expected);
+    p.reset();
+    p.reverseAddPath(q);
+    SkRect reverseExpected = {4, 4, 8, 8};
+    REPORTER_ASSERT(reporter, p.getBounds() == reverseExpected);
+}
+
+static void test_conicTo_special_case(skiatest::Reporter* reporter) {
+    SkPath p;
+    p.conicTo(1, 2, 3, 4, -1);
+    check_path_is_line_and_reset(reporter, &p, 3, 4);
+    p.conicTo(1, 2, 3, 4, SK_ScalarInfinity);
+    check_path_is_line_pair_and_reset(reporter, &p, 1, 2, 3, 4);
+    p.conicTo(1, 2, 3, 4, 1);
+    check_path_is_quad_and_reset(reporter, &p, 1, 2, 3, 4);
+}
+
+static void test_get_point(skiatest::Reporter* reporter) {
+    SkPath p;
+    SkPoint pt = p.getPoint(0);
+    REPORTER_ASSERT(reporter, pt == SkPoint::Make(0, 0));
+    REPORTER_ASSERT(reporter, !p.getLastPt(NULL));
+    REPORTER_ASSERT(reporter, !p.getLastPt(&pt) && pt == SkPoint::Make(0, 0));
+    p.setLastPt(10, 10);
+    pt = p.getPoint(0);
+    REPORTER_ASSERT(reporter, pt == SkPoint::Make(10, 10));
+    REPORTER_ASSERT(reporter, p.getLastPt(NULL));
+    p.rMoveTo(10, 10);
+    REPORTER_ASSERT(reporter, p.getLastPt(&pt) && pt == SkPoint::Make(20, 20));
+}
+
+class PathTest_Private {
+public:
+    static void TestPathTo(skiatest::Reporter* reporter) {
+        SkPath p, q;
+        p.lineTo(4, 4);
+        p.reversePathTo(q);
+        check_path_is_line(reporter, &p, 4, 4);
+        q.moveTo(-4, -4);
+        p.reversePathTo(q);
+        check_path_is_line(reporter, &p, 4, 4);
+        q.lineTo(7, 8);
+        q.conicTo(8, 7, 6, 5, SkFloatToScalar(0.5f));
+        q.quadTo(6, 7, 8, 6);
+        q.cubicTo(5, 6, 7, 8, 7, 5);
+        q.close();
+        p.reversePathTo(q);
+        SkRect reverseExpected = {-4, -4, 8, 8};
+        REPORTER_ASSERT(reporter, p.getBounds() == reverseExpected);
+    }
+};
 
 static void TestPath(skiatest::Reporter* reporter) {
     SkTSize<SkScalar>::Make(3,4);
 
     SkPath  p, empty;
     SkRect  bounds, bounds2;
     test_empty(reporter, p);
 
     REPORTER_ASSERT(reporter, p.getBounds().isEmpty());
 
@@ skipping 83 matching lines @@
     test_tricky_cubic();
     test_clipped_cubic();
     test_crbug_170666();
     test_bad_cubic_crbug229478();
     test_bad_cubic_crbug234190();
     test_android_specific_behavior(reporter);
     test_gen_id(reporter);
     test_path_close_issue1474(reporter);
     test_path_to_region(reporter);
     test_rrect(reporter);
+    test_arc(reporter);
+    test_arcTo(reporter);
+    test_addPath(reporter);
+    test_conicTo_special_case(reporter);
+    test_get_point(reporter);
+    PathTest_Private::TestPathTo(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Path", PathTestClass, TestPath)