@@ -432,13 +432,10 @@ def iter_segments(self, transform=None, remove_nans=True, clip=None,
                     curr_vertices = np.append(curr_vertices, next(vertices))
             yield curr_vertices, code
 
-    def iter_curves(self, **kwargs):
+    def iter_bezier(self, **kwargs):
         """
         Iterate over each bezier curve (lines included) in a Path.
 
-        This is in contrast to iter_segments, which omits the first control
-        point of each curve.
-
         Parameters
         ----------
         kwargs : Dict[str, object]
@@ -455,30 +452,33 @@ def iter_curves(self, **kwargs):
             The code describing what kind of curve is being returned.
             Path.MOVETO, Path.LINETO, Path.CURVE3, Path.CURVE4 correspond to
             bezier curves with 1, 2, 3, and 4 control points (respectively).
+            Path.CLOSEPOLY is a Path.LINETO with the control points correctly
+            chosen based on the start/end points of the current stroke.
         """
-        first_vertex = None
-        prev_vertex = None
+        first_vert = None
+        prev_vert = None
         for vertices, code in self.iter_segments(**kwargs):
-            if first_vertex is None:
+            if first_vert is None:
                 if code != Path.MOVETO:
                     raise ValueError("Malformed path, must start with MOVETO.")
             if code == Path.MOVETO:  # a point is like "CURVE1"
-                first_vertex = vertices
-                yield np.array([first_vertex]), code
+                first_vert = vertices
+                yield BezierSegment(np.array([first_vert])), code
             elif code == Path.LINETO:  # "CURVE2"
-                yield np.array([prev_vertex, vertices]), code
+                yield BezierSegment(np.array([prev_vert, vertices])), code
             elif code == Path.CURVE3:
-                yield np.array([prev_vertex, vertices[:2], vertices[2:]]), code
+                yield BezierSegment(np.array([prev_vert, vertices[:2],
+                        vertices[2:]])), code
             elif code == Path.CURVE4:
-                yield np.array([prev_vertex, vertices[:2], vertices[2:4],
-                                vertices[4:]]), code
+                yield BezierSegment(np.array([prev_vert, vertices[:2],
+                        vertices[2:4], vertices[4:]])), code
             elif code == Path.CLOSEPOLY:
-                yield np.array([prev_vertex, first_vertex]), code
+                yield BezierSegment(np.array([prev_vert, first_vert])), code
             elif code == Path.STOP:
                 return
             else:
                 raise ValueError("Invalid Path.code_type: " + str(code))
-            prev_vertex = vertices[-2:]
+            prev_vert = vertices[-2:]
 
     @cbook._delete_parameter("3.3", "quantize")
     def cleaned(self, transform=None, remove_nans=False, clip=None,
@@ -611,7 +611,7 @@ def get_exact_extents(self, **kwargs):
         Parameters
         ----------
         kwargs : Dict[str, object]
-            Forwarded to self.iter_curves.
+            Forwarded to self.iter_bezier.
 
         Returns
         -------
@@ -621,8 +621,7 @@ def get_exact_extents(self, **kwargs):
         maxi = 2  # [xmin, ymin, *xmax, ymax]
         # return value for empty paths to match _path.h
         extents = np.array([np.inf, np.inf, -np.inf, -np.inf])
-        for curve, code in self.iter_curves(**kwargs):
-            curve = BezierSegment(curve)
+        for curve, code in self.iter_bezier(**kwargs):
             # start and endpoints can be extrema of the curve
             _update_extents(extents, curve(0))  # start point
             _update_extents(extents, curve(1))  # end point