diff --git a/engine/src/flutter/display_list/benchmarking/dl_benchmarks.cc b/engine/src/flutter/display_list/benchmarking/dl_benchmarks.cc
index a2ca7386196..2fdc376c41c 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_benchmarks.cc
+++ b/engine/src/flutter/display_list/benchmarking/dl_benchmarks.cc
@@ -10,12 +10,8 @@
 
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkImage.h"
-#include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/core/SkTextBlob.h"
-#include "third_party/skia/include/gpu/ganesh/GrDirectContext.h"
-#include "third_party/skia/include/gpu/ganesh/GrRecordingContext.h"
-#include "third_party/skia/include/gpu/ganesh/GrTypes.h"
 
 namespace flutter {
 namespace testing {
@@ -43,16 +39,6 @@ DlPaint GetPaintForRun(unsigned attributes) {
   return paint;
 }
 
-static void FlushSubmitCpuSync(const sk_sp<SkSurface>& surface) {
-  if (!surface) {
-    return;
-  }
-  if (GrDirectContext* dContext =
-          GrAsDirectContext(surface->recordingContext())) {
-    dContext->flushAndSubmit(surface.get(), GrSyncCpu::kYes);
-  }
-}
-
 void AnnotateAttributes(unsigned attributes,
                         benchmark::State& state,
                         const DisplayListAttributeFlags flags) {
@@ -98,8 +84,8 @@ void BM_DrawLine(benchmark::State& state,
   size_t length = state.range(0);
 
   surface_provider->InitializeSurface(length, length);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   state.counters["DrawCallCount"] = kLinesToDraw;
   for (size_t i = 0; i < kLinesToDraw; i++) {
@@ -111,8 +97,8 @@ void BM_DrawLine(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawLine-" +
@@ -136,23 +122,25 @@ void BM_DrawRect(benchmark::State& state,
   size_t length = state.range(0);
   size_t canvas_size = length * 2;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   // As rects have DlScalar dimensions, we want to ensure that we also
   // draw rects with non-integer position and size
-  const DlScalar offset = 0.5f;
-  DlRect rect = DlRect::MakeLTRB(0, 0, length, length);
+  const DlPoint offset(0.5f, 0.5f);
+  DlPoint origin;
+  DlSize size(length, length);
 
   state.counters["DrawCallCount"] = kRectsToDraw;
   for (size_t i = 0; i < kRectsToDraw; i++) {
+    DlRect rect = DlRect::MakeOriginSize(origin, size);
     builder.DrawRect(rect, paint);
-    rect = rect.Shift(offset, offset);
-    if (rect.GetRight() > canvas_size) {
-      rect = rect.Shift(-canvas_size, 0);
+    origin += offset;
+    if (origin.x + size.width > canvas_size) {
+      origin.x -= canvas_size;
     }
     if (rect.GetBottom() > canvas_size) {
-      rect = rect.Shift(0, -canvas_size);
+      origin.y -= canvas_size;
     }
   }
 
@@ -160,8 +148,8 @@ void BM_DrawRect(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawRect-" +
@@ -185,29 +173,31 @@ void BM_DrawOval(benchmark::State& state,
   size_t length = state.range(0);
   size_t canvas_size = length * 2;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
-  DlRect rect = DlRect::MakeXYWH(0, 0, length * 1.5f, length);
-  const DlScalar offset = 0.5f;
+  const DlPoint offset(0.5f, 0.5f);
+  DlPoint origin;
+  DlSize size(length * 1.5f, length);
 
   state.counters["DrawCallCount"] = kOvalsToDraw;
   for (size_t i = 0; i < kOvalsToDraw; i++) {
+    DlRect rect = DlRect::MakeOriginSize(origin, size);
     builder.DrawOval(rect, paint);
-    rect = rect.Shift(offset, offset);
-    if (rect.GetRight() > canvas_size) {
-      rect = rect.Shift(-canvas_size, 0);
+    origin += offset;
+    if (origin.x + size.width > canvas_size) {
+      origin.x -= canvas_size;
     }
-    if (rect.GetBottom() > canvas_size) {
-      rect = rect.Shift(0, -canvas_size);
+    if (origin.y + size.height > canvas_size) {
+      origin.y -= canvas_size;
     }
   }
   auto display_list = builder.Build();
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawOval-" +
@@ -231,19 +221,18 @@ void BM_DrawCircle(benchmark::State& state,
   size_t length = state.range(0);
   size_t canvas_size = length * 2;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   DlScalar radius = length / 2.0f;
-  const DlScalar offset = 0.5f;
+  const DlPoint offset(0.5f, 0.5f);
 
   DlPoint center = DlPoint(radius, radius);
-  DlPoint shift = DlPoint(offset, offset);
 
   state.counters["DrawCallCount"] = kCirclesToDraw;
   for (size_t i = 0; i < kCirclesToDraw; i++) {
     builder.DrawCircle(center, radius, paint);
-    center += shift;
+    center += offset;
     if (center.x + radius > canvas_size) {
       center.x = radius;
     }
@@ -255,8 +244,8 @@ void BM_DrawCircle(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawCircle-" +
@@ -281,8 +270,8 @@ void BM_DrawRRect(benchmark::State& state,
   size_t length = state.range(0);
   size_t canvas_size = length * 2;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   DlRoundingRadii radii;
   switch (type) {
@@ -329,8 +318,8 @@ void BM_DrawRRect(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawRRect-" +
@@ -358,8 +347,8 @@ void BM_DrawDRRect(benchmark::State& state,
   size_t length = state.range(0);
   size_t canvas_size = length * 2;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   DlRoundingRadii radii;
   switch (type) {
@@ -412,8 +401,8 @@ void BM_DrawDRRect(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawDRRect-" +
@@ -434,30 +423,32 @@ void BM_DrawArc(benchmark::State& state,
   size_t length = state.range(0);
   size_t canvas_size = length * 2;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   DlScalar starting_angle = 0.0f;
-  DlScalar offset = 0.5f;
+  DlPoint offset(0.5f, 0.5f);
 
   // Just some random sweeps that will mostly circumnavigate the circle
   std::vector<DlScalar> segment_sweeps = {5.5f,  -10.0f, 42.0f, 71.7f, 90.0f,
                                           37.5f, 17.9f,  32.0f, 379.4f};
 
-  DlRect bounds = DlRect::MakeLTRB(0, 0, length, length);
+  DlPoint origin;
+  DlSize size(length, length);
 
   state.counters["DrawCallCount"] = kArcSweepSetsToDraw * segment_sweeps.size();
   for (size_t i = 0; i < kArcSweepSetsToDraw; i++) {
+    DlRect bounds = DlRect::MakeOriginSize(origin, size);
     for (DlScalar sweep : segment_sweeps) {
       builder.DrawArc(bounds, starting_angle, sweep, false, paint);
       starting_angle += sweep + 5.0f;
     }
-    bounds = bounds.Shift(offset, offset);
-    if (bounds.GetRight() > canvas_size) {
-      bounds = bounds.Shift(-canvas_size, 0);
+    origin += offset;
+    if (origin.x + size.width > canvas_size) {
+      origin.x -= canvas_size;
     }
-    if (bounds.GetBottom() > canvas_size) {
-      bounds = bounds.Shift(0, -canvas_size);
+    if (origin.y + size.height > canvas_size) {
+      origin.y -= canvas_size;
     }
   }
 
@@ -465,8 +456,8 @@ void BM_DrawArc(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawArc-" +
@@ -474,18 +465,18 @@ void BM_DrawArc(benchmark::State& state,
   surface_provider->Snapshot(filename);
 }
 
-// Returns a list of SkPoints that represent `n` points equally spaced out
+// Returns a list of DlPoints that represent `n` points equally spaced out
 // along the circumference of a circle with radius `r` and centered on `center`.
-std::vector<SkPoint> GetPolygonPoints(size_t n, SkPoint center, DlScalar r) {
-  std::vector<SkPoint> points;
+std::vector<DlPoint> GetPolygonPoints(size_t n, DlPoint center, DlScalar r) {
+  std::vector<DlPoint> points;
   DlScalar x, y;
   float angle;
   float full_circle = 2.0f * M_PI;
   for (size_t i = 0; i < n; i++) {
     angle = (full_circle / static_cast<float>(n)) * static_cast<float>(i);
-    x = center.x() + r * std::cosf(angle);
-    y = center.y() + r * std::sinf(angle);
-    points.push_back(SkPoint::Make(x, y));
+    x = center.x + r * std::cosf(angle);
+    y = center.y + r * std::sinf(angle);
+    points.emplace_back(x, y);
   }
   return points;
 }
@@ -496,14 +487,17 @@ std::vector<SkPoint> GetPolygonPoints(size_t n, SkPoint center, DlScalar r) {
 // `radius` and `center`.
 //
 // The path segment connecting each control point is a line segment.
-void GetLinesPath(SkPath& path, size_t sides, SkPoint center, float radius) {
-  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
-  path.moveTo(points[0]);
+void GetLinesPath(DlPathBuilder& path_builder,
+                  size_t sides,
+                  DlPoint center,
+                  float radius) {
+  std::vector<DlPoint> points = GetPolygonPoints(sides, center, radius);
+  path_builder.MoveTo(points[0]);
   for (size_t i = 1; i < sides; i++) {
-    path.lineTo(points[i]);
+    path_builder.LineTo(points[i]);
   }
-  path.lineTo(points[0]);
-  path.close();
+  path_builder.LineTo(points[0]);
+  path_builder.Close();
 }
 
 // Creates a path that represents a regular polygon with `sides` sides,
@@ -515,17 +509,20 @@ void GetLinesPath(SkPath& path, size_t sides, SkPoint center, float radius) {
 // bezier control point being on a circle with 80% of `radius` and with the
 // control point angle half way between the start and end point angles for the
 // polygon segment.
-void GetQuadsPath(SkPath& path, size_t sides, SkPoint center, float radius) {
-  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
-  std::vector<SkPoint> control_points =
+void GetQuadsPath(DlPathBuilder& path_builder,
+                  size_t sides,
+                  DlPoint center,
+                  float radius) {
+  std::vector<DlPoint> points = GetPolygonPoints(sides, center, radius);
+  std::vector<DlPoint> control_points =
       GetPolygonPoints(sides * 2, center, radius * 0.8f);
 
-  path.moveTo(points[0]);
+  path_builder.MoveTo(points[0]);
   for (size_t i = 1; i < sides; i++) {
-    path.quadTo(control_points[2 * i - 1], points[i]);
+    path_builder.QuadraticCurveTo(control_points[2 * i - 1], points[i]);
   }
-  path.quadTo(control_points[2 * sides - 1], points[0]);
-  path.close();
+  path_builder.QuadraticCurveTo(control_points[2 * sides - 1], points[0]);
+  path_builder.Close();
 }
 
 // Creates a path that represents a regular polygon with `sides` sides,
@@ -537,17 +534,20 @@ void GetQuadsPath(SkPath& path, size_t sides, SkPoint center, float radius) {
 // control point being on a circle with 80% of `radius` and with the
 // control point angle half way between the start and end point angles for the
 // polygon segment, and the conic weight set to 3.7f.
-void GetConicsPath(SkPath& path, size_t sides, SkPoint center, float radius) {
-  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
-  std::vector<SkPoint> control_points =
+void GetConicsPath(DlPathBuilder& path_builder,
+                   size_t sides,
+                   DlPoint center,
+                   float radius) {
+  std::vector<DlPoint> points = GetPolygonPoints(sides, center, radius);
+  std::vector<DlPoint> control_points =
       GetPolygonPoints(sides * 2, center, radius * 0.8f);
 
-  path.moveTo(points[0]);
+  path_builder.MoveTo(points[0]);
   for (size_t i = 1; i < sides; i++) {
-    path.conicTo(control_points[2 * i - 1], points[i], 3.7f);
+    path_builder.ConicCurveTo(control_points[2 * i - 1], points[i], 3.7f);
   }
-  path.conicTo(control_points[2 * sides - 1], points[0], 3.7f);
-  path.close();
+  path_builder.ConicCurveTo(control_points[2 * sides - 1], points[0], 3.7f);
+  path_builder.Close();
 }
 
 // Creates a path that represents a regular polygon with `sides` sides,
@@ -560,21 +560,24 @@ void GetConicsPath(SkPath& path, size_t sides, SkPoint center, float radius) {
 // control point being on a circle with 120% of `radius`. The first
 // control point is 1/3, and the second control point is 2/3, of the angle
 // between the start and end point angles for the polygon segment.
-void GetCubicsPath(SkPath& path, size_t sides, SkPoint center, float radius) {
-  std::vector<SkPoint> points = GetPolygonPoints(sides, center, radius);
-  std::vector<SkPoint> inner_control_points =
+void GetCubicsPath(DlPathBuilder& path_builder,
+                   size_t sides,
+                   DlPoint center,
+                   float radius) {
+  std::vector<DlPoint> points = GetPolygonPoints(sides, center, radius);
+  std::vector<DlPoint> inner_control_points =
       GetPolygonPoints(sides * 3, center, radius * 0.8f);
-  std::vector<SkPoint> outer_control_points =
+  std::vector<DlPoint> outer_control_points =
       GetPolygonPoints(sides * 3, center, radius * 1.2f);
 
-  path.moveTo(points[0]);
+  path_builder.MoveTo(points[0]);
   for (size_t i = 1; i < sides; i++) {
-    path.cubicTo(inner_control_points[3 * i - 2],
-                 outer_control_points[3 * i - 1], points[i]);
+    path_builder.CubicCurveTo(inner_control_points[3 * i - 2],
+                              outer_control_points[3 * i - 1], points[i]);
   }
-  path.cubicTo(inner_control_points[3 * sides - 2],
-               outer_control_points[3 * sides - 1], points[0]);
-  path.close();
+  path_builder.CubicCurveTo(inner_control_points[3 * sides - 2],
+                            outer_control_points[3 * sides - 1], points[0]);
+  path_builder.Close();
 }
 
 // Returns a path generated by one of the above path generators
@@ -585,28 +588,28 @@ void GetCubicsPath(SkPath& path, size_t sides, SkPoint center, float radius) {
 // Each of the polygons will have `sides` sides, and the resulting path will be
 // bounded by a circle with radius of 150% of `radius` (or another 20% on top of
 // that for cubics)
-void MultiplyPath(SkPath& path,
-                  SkPath::Verb type,
-                  SkPoint center,
+void MultiplyPath(DlPathBuilder& path_builder,
+                  PathVerb type,
+                  DlPoint center,
                   size_t sides,
                   size_t number,
                   float radius) {
-  std::vector<SkPoint> center_points =
+  std::vector<DlPoint> center_points =
       GetPolygonPoints(number, center, radius / 2.0f);
 
-  for (SkPoint p : center_points) {
+  for (DlPoint p : center_points) {
     switch (type) {
-      case SkPath::Verb::kLine_Verb:
-        GetLinesPath(path, sides, p, radius);
+      case PathVerb::kLine:
+        GetLinesPath(path_builder, sides, p, radius);
         break;
-      case SkPath::Verb::kQuad_Verb:
-        GetQuadsPath(path, sides, p, radius);
+      case PathVerb::kQuad:
+        GetQuadsPath(path_builder, sides, p, radius);
         break;
-      case SkPath::Verb::kConic_Verb:
-        GetConicsPath(path, sides, p, radius);
+      case PathVerb::kConic:
+        GetConicsPath(path_builder, sides, p, radius);
         break;
-      case SkPath::Verb::kCubic_Verb:
-        GetCubicsPath(path, sides, p, radius);
+      case PathVerb::kCubic:
+        GetCubicsPath(path_builder, sides, p, radius);
         break;
       default:
         break;
@@ -614,15 +617,15 @@ void MultiplyPath(SkPath& path,
   }
 }
 
-std::string VerbToString(SkPath::Verb type) {
+std::string VerbToString(PathVerb type) {
   switch (type) {
-    case SkPath::Verb::kLine_Verb:
+    case PathVerb::kLine:
       return "Lines";
-    case SkPath::Verb::kQuad_Verb:
+    case PathVerb::kQuad:
       return "Quads";
-    case SkPath::Verb::kConic_Verb:
+    case PathVerb::kConic:
       return "Conics";
-    case SkPath::Verb::kCubic_Verb:
+    case PathVerb::kCubic:
       return "Cubics";
     default:
       return "Unknown";
@@ -630,7 +633,7 @@ std::string VerbToString(SkPath::Verb type) {
 }
 
 // Draws a series of overlapping 20-sided polygons where the path segment
-// between each point is one of the verb types defined in SkPath.
+// between each point is one of the verb types defined in PathVerb.
 //
 // The number of polygons drawn will be varied to get an overall path
 // with approximately 20*N verbs, so we can get an idea of the fixed
@@ -639,7 +642,7 @@ std::string VerbToString(SkPath::Verb type) {
 void BM_DrawPath(benchmark::State& state,
                  BackendType backend_type,
                  unsigned attributes,
-                 SkPath::Verb type) {
+                 PathVerb type) {
   auto surface_provider = DlSurfaceProvider::Create(backend_type);
   DisplayListBuilder builder;
   DlPaint paint = GetPaintForRun(attributes);
@@ -648,28 +651,33 @@ void BM_DrawPath(benchmark::State& state,
 
   size_t length = kFixedCanvasSize;
   surface_provider->InitializeSurface(length, length);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
-  SkPath path;
+  DlPathBuilder path_builder;
 
   std::string label = VerbToString(type);
-  SkPoint center = SkPoint::Make(length / 2.0f, length / 2.0f);
+  DlPoint center = DlPoint(length / 2.0f, length / 2.0f);
   float radius = length * 0.25f;
   state.SetComplexityN(state.range(0));
 
-  MultiplyPath(path, type, center, 20, state.range(0), radius);
+  MultiplyPath(path_builder, type, center, 20, state.range(0), radius);
+  DlPath path = DlPath(path_builder);
 
-  state.counters["VerbCount"] = path.countVerbs();
+  state.counters["VerbCount"] = path.GetPath().GetComponentCount();
   state.counters["DrawCallCount"] = 1;
 
   builder.DrawPath(path, paint);
   auto display_list = builder.Build();
 
+  // Prime any path conversions
+  canvas->DrawDisplayList(display_list);
+  surface->FlushSubmitCpuSync();
+
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawPath-" + label +
@@ -689,16 +697,16 @@ void BM_DrawPath(benchmark::State& state,
 // and the final vertex being the center point of the disc.
 //
 // Each vertex colour will alternate through Red, Green, Blue and Cyan.
-std::shared_ptr<DlVertices> GetTestVertices(SkPoint center,
+std::shared_ptr<DlVertices> GetTestVertices(DlPoint center,
                                             float radius,
                                             size_t vertex_count,
                                             DlVertexMode mode,
                                             size_t& final_vertex_count) {
   size_t outer_vertex_count = vertex_count / 2;
-  std::vector<SkPoint> outer_points =
+  std::vector<DlPoint> outer_points =
       GetPolygonPoints(outer_vertex_count, center, radius);
 
-  std::vector<SkPoint> vertices;
+  std::vector<DlPoint> vertices;
   std::vector<DlColor> colors;
 
   switch (mode) {
@@ -750,8 +758,8 @@ std::shared_ptr<DlVertices> GetTestVertices(SkPoint center,
   }
 
   final_vertex_count = vertices.size();
-  return DlVertices::Make(mode, vertices.size(), ToDlPoints(vertices.data()),
-                          nullptr, colors.data());
+  return DlVertices::Make(mode, vertices.size(), vertices.data(), nullptr,
+                          colors.data());
 }
 
 std::string VertexModeToString(DlVertexMode mode) {
@@ -786,21 +794,21 @@ void BM_DrawVertices(benchmark::State& state,
 
   size_t length = kFixedCanvasSize;
   surface_provider->InitializeSurface(length, length);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
-  SkPoint center = SkPoint::Make(length / 2.0f, length / 2.0f);
+  DlPoint center = DlPoint(length / 2.0f, length / 2.0f);
 
   float radius = length / 4.0f;
 
   size_t vertex_count, total_vertex_count = 0;
   size_t disc_count = state.range(0);
 
-  std::vector<SkPoint> center_points =
+  std::vector<DlPoint> center_points =
       GetPolygonPoints(disc_count, center, radius / 4.0f);
 
   state.counters["DrawCallCount"] = center_points.size();
-  for (SkPoint p : center_points) {
+  for (DlPoint p : center_points) {
     std::shared_ptr<DlVertices> vertices =
         GetTestVertices(p, radius, 50, mode, vertex_count);
     total_vertex_count += vertex_count;
@@ -814,8 +822,8 @@ void BM_DrawVertices(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawVertices-" +
@@ -830,22 +838,23 @@ void BM_DrawVertices(benchmark::State& state,
 // chosen to appear somewhat random.
 //
 // The points generated will wrap in x and y for the bounds of `canvas_size`.
-std::vector<SkPoint> GetTestPoints(size_t count, SkISize canvas_size) {
-  std::vector<SkPoint> points;
+std::vector<DlPoint> GetTestPoints(size_t count, DlISize canvas_size) {
+  std::vector<DlPoint> points;
 
   // Some arbitrary offsets to use when building the list of points
-  std::vector<SkScalar> delta_x = {10.0f, 6.3f, 15.0f, 3.5f, 22.6f, 4.7f};
-  std::vector<SkScalar> delta_y = {9.3f, -5.4f, 8.5f, -12.0f, 19.2f, -19.6f};
+  std::vector<DlScalar> delta_x = {10.0f, 6.3f, 15.0f, 3.5f, 22.6f, 4.7f};
+  std::vector<DlScalar> delta_y = {9.3f, -5.4f, 8.5f, -12.0f, 19.2f, -19.6f};
 
-  SkPoint current = SkPoint::Make(0.0f, 0.0f);
+  DlPoint current;
   for (size_t i = 0; i < count; i++) {
     points.push_back(current);
-    current.offset(delta_x[i % delta_x.size()], delta_y[i % delta_y.size()]);
-    if (current.x() > canvas_size.width()) {
-      current.offset(-canvas_size.width(), 25.0f);
+    current +=
+        DlPoint(delta_x[i % delta_x.size()], delta_y[i % delta_y.size()]);
+    if (current.x > canvas_size.width) {
+      current += DlPoint(-canvas_size.width, 25.0f);
     }
-    if (current.y() > canvas_size.height()) {
-      current.offset(0.0f, -canvas_size.height());
+    if (current.y > canvas_size.height) {
+      current += DlPoint(0.0f, -canvas_size.height);
     }
   }
 
@@ -895,23 +904,23 @@ void BM_DrawPoints(benchmark::State& state,
 
   size_t length = kFixedCanvasSize;
   surface_provider->InitializeSurface(length, length);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   size_t point_count = state.range(0);
   state.SetComplexityN(point_count);
   state.counters["PointCount"] = point_count;
   state.counters["DrawCallCount"] = 1;
 
-  std::vector<SkPoint> points =
-      GetTestPoints(point_count, SkISize::Make(length, length));
+  std::vector<DlPoint> points =
+      GetTestPoints(point_count, DlISize(length, length));
   builder.DrawPoints(mode, points.size(), points.data(), paint);
 
   auto display_list = builder.Build();
 
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawPoints-" +
@@ -946,8 +955,8 @@ void BM_DrawImage(benchmark::State& state,
   size_t bitmap_size = state.range(0);
   size_t canvas_size = 2 * bitmap_size;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   sk_sp<SkImage> image;
   std::shared_ptr<DlSurfaceInstance> offscreen_instance;
@@ -967,8 +976,8 @@ void BM_DrawImage(benchmark::State& state,
     offscreen->getCanvas()->clear(SK_ColorRED);
   }
 
-  SkScalar offset = 0.5f;
-  SkPoint dst = SkPoint::Make(0, 0);
+  const DlPoint offset(0.5f, 0.5f);
+  DlPoint dst;
 
   state.counters["DrawCallCount"] = kImagesToDraw;
   for (size_t i = 0; i < kImagesToDraw; i++) {
@@ -976,20 +985,20 @@ void BM_DrawImage(benchmark::State& state,
                           : offscreen->makeImageSnapshot();
     builder.DrawImage(DlImage::Make(image), dst, options, &paint);
 
-    dst.offset(offset, offset);
-    if (dst.x() + bitmap_size > canvas_size) {
-      dst.set(0, dst.y());
+    dst += offset;
+    if (dst.x + bitmap_size > canvas_size) {
+      dst.x = 0;
     }
-    if (dst.y() + bitmap_size > canvas_size) {
-      dst.set(dst.x(), 0);
+    if (dst.y + bitmap_size > canvas_size) {
+      dst.y = 0;
     }
   }
 
   auto display_list = builder.Build();
 
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawImage-" +
@@ -1029,8 +1038,8 @@ void BM_DrawImageRect(benchmark::State& state,
   size_t bitmap_size = state.range(0);
   size_t canvas_size = 2 * bitmap_size;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   sk_sp<SkImage> image;
   std::shared_ptr<DlSurfaceInstance> offscreen_instance;
@@ -1050,32 +1059,33 @@ void BM_DrawImageRect(benchmark::State& state,
     offscreen->getCanvas()->clear(SK_ColorRED);
   }
 
-  SkScalar offset = 0.5f;
-  SkRect src = SkRect::MakeXYWH(bitmap_size / 4.0f, bitmap_size / 4.0f,
+  const DlPoint offset(0.5f, 0.5f);
+  DlRect src = DlRect::MakeXYWH(bitmap_size / 4.0f, bitmap_size / 4.0f,
                                 bitmap_size / 2.0f, bitmap_size / 2.0f);
-  SkRect dst =
-      SkRect::MakeXYWH(0.0f, 0.0f, bitmap_size * 0.75f, bitmap_size * 0.75f);
+  DlPoint origin;
+  DlSize size(bitmap_size * 0.75f, bitmap_size * 0.75f);
 
   state.counters["DrawCallCount"] = kImagesToDraw;
   for (size_t i = 0; i < kImagesToDraw; i++) {
     image = upload_bitmap ? ImageFromBitmapWithNewID(bitmap)
                           : offscreen->makeImageSnapshot();
+    DlRect dst = DlRect::MakeOriginSize(origin, size);
     builder.DrawImageRect(DlImage::Make(image), src, dst, options, &paint,
                           constraint);
-    dst.offset(offset, offset);
-    if (dst.right() > canvas_size) {
-      dst.offsetTo(0, dst.y());
+    origin += offset;
+    if (origin.x + size.width > canvas_size) {
+      origin.x = 0.0f;
     }
-    if (dst.bottom() > canvas_size) {
-      dst.offsetTo(dst.x(), 0);
+    if (origin.y + size.height > canvas_size) {
+      origin.y = 0.0f;
     }
   }
 
   auto display_list = builder.Build();
 
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawImageRect-" +
@@ -1116,10 +1126,10 @@ void BM_DrawImageNine(benchmark::State& state,
   size_t bitmap_size = state.range(0);
   size_t canvas_size = 2 * bitmap_size;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
-  SkIRect center = SkIRect::MakeXYWH(bitmap_size / 4, bitmap_size / 4,
+  DlIRect center = DlIRect::MakeXYWH(bitmap_size / 4, bitmap_size / 4,
                                      bitmap_size / 2, bitmap_size / 2);
 
   sk_sp<SkImage> image;
@@ -1140,29 +1150,30 @@ void BM_DrawImageNine(benchmark::State& state,
     offscreen->getCanvas()->clear(SK_ColorRED);
   }
 
-  SkScalar offset = 0.5f;
-  SkRect dst =
-      SkRect::MakeXYWH(0.0f, 0.0f, bitmap_size * 0.75f, bitmap_size * 0.75f);
+  const DlPoint offset(0.5f, 0.5f);
+  DlPoint origin;
+  DlSize size(bitmap_size * 0.75f, bitmap_size * 0.75f);
 
   state.counters["DrawCallCount"] = kImagesToDraw;
   for (size_t i = 0; i < kImagesToDraw; i++) {
     image = upload_bitmap ? ImageFromBitmapWithNewID(bitmap)
                           : offscreen->makeImageSnapshot();
+    DlRect dst = DlRect::MakeOriginSize(origin, size);
     builder.DrawImageNine(DlImage::Make(image), center, dst, filter, &paint);
-    dst.offset(offset, offset);
-    if (dst.right() > canvas_size) {
-      dst.offsetTo(0, dst.y());
+    origin += offset;
+    if (origin.x + size.width > canvas_size) {
+      origin.x = 0.0f;
     }
-    if (dst.bottom() > canvas_size) {
-      dst.offsetTo(dst.x(), 0);
+    if (origin.y + size.height > canvas_size) {
+      origin.y = 0.0f;
     }
   }
 
   auto display_list = builder.Build();
 
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawImageNine-" +
@@ -1191,9 +1202,10 @@ void BM_DrawTextBlob(benchmark::State& state,
   size_t draw_calls = state.range(0);
   size_t canvas_size = kFixedCanvasSize;
   surface_provider->InitializeSurface(canvas_size, canvas_size);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
+  state.SetComplexityN(draw_calls);
   state.counters["DrawCallCount_Varies"] = draw_calls;
   state.counters["GlyphCount"] = draw_calls;
   char character[2] = {'A', '\0'};
@@ -1207,8 +1219,8 @@ void BM_DrawTextBlob(benchmark::State& state,
   auto display_list = builder.Build();
 
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawTextBlob-" +
@@ -1228,7 +1240,7 @@ void BM_DrawShadow(benchmark::State& state,
                    BackendType backend_type,
                    unsigned attributes,
                    bool transparent_occluder,
-                   SkPath::Verb type) {
+                   PathVerb type) {
   auto surface_provider = DlSurfaceProvider::Create(backend_type);
   DisplayListBuilder builder;
   DlPaint paint = GetPaintForRun(attributes);
@@ -1237,26 +1249,26 @@ void BM_DrawShadow(benchmark::State& state,
 
   size_t length = kFixedCanvasSize;
   surface_provider->InitializeSurface(length, length);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
-  SkPath path;
+  DlPathBuilder path_builder;
 
-  SkPoint center = SkPoint::Make(length / 2.0f, length / 2.0f);
+  DlPoint center = DlPoint(length / 2.0f, length / 2.0f);
   float radius = length * 0.25f;
 
   switch (type) {
-    case SkPath::Verb::kLine_Verb:
-      GetLinesPath(path, 10, center, radius);
+    case PathVerb::kLine:
+      GetLinesPath(path_builder, 10, center, radius);
       break;
-    case SkPath::Verb::kQuad_Verb:
-      GetQuadsPath(path, 10, center, radius);
+    case PathVerb::kQuad:
+      GetQuadsPath(path_builder, 10, center, radius);
       break;
-    case SkPath::Verb::kConic_Verb:
-      GetConicsPath(path, 10, center, radius);
+    case PathVerb::kConic:
+      GetConicsPath(path_builder, 10, center, radius);
       break;
-    case SkPath::Verb::kCubic_Verb:
-      GetCubicsPath(path, 10, center, radius);
+    case PathVerb::kCubic:
+      GetCubicsPath(path_builder, 10, center, radius);
       break;
     default:
       break;
@@ -1265,16 +1277,22 @@ void BM_DrawShadow(benchmark::State& state,
   float elevation = state.range(0);
   state.counters["DrawCallCount"] = 1;
 
+  DlPath path = DlPath(path_builder);
+
   // We can hardcode dpr to 1.0f as we're varying elevation, and dpr is only
   // ever used in conjunction with elevation.
   builder.DrawShadow(path, DlColor(SK_ColorBLUE), elevation,
                      transparent_occluder, 1.0f);
   auto display_list = builder.Build();
 
+  // Prime the path conversion.
+  canvas->DrawDisplayList(display_list);
+  surface->FlushSubmitCpuSync();
+
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-DrawShadow-" +
@@ -1302,20 +1320,20 @@ void BM_SaveLayer(benchmark::State& state,
 
   size_t length = kFixedCanvasSize;
   surface_provider->InitializeSurface(length, length);
-  auto surface = surface_provider->GetPrimarySurface()->sk_surface();
-  auto canvas = DlSkCanvasAdapter(surface->getCanvas());
+  auto surface = surface_provider->GetPrimarySurface();
+  auto canvas = surface->GetCanvas();
 
   size_t save_layer_calls = state.range(0);
 
   // Ensure we draw two overlapping rects to avoid any peephole optimisations
-  SkRect rect1 = SkRect::MakeLTRB(0, 0, 0.75f * length, 0.75f * length);
-  SkRect rect2 =
-      SkRect::MakeLTRB(0.25f * length, 0.25f * length, length, length);
+  DlRect rect1 = DlRect::MakeLTRB(0, 0, 0.75f * length, 0.75f * length);
+  DlRect rect2 =
+      DlRect::MakeLTRB(0.25f * length, 0.25f * length, length, length);
 
   state.counters["DrawCallCount_Varies"] = save_layer_calls * save_depth;
   for (size_t i = 0; i < save_layer_calls; i++) {
     for (size_t j = 0; j < save_depth; j++) {
-      builder.SaveLayer(nullptr, nullptr);
+      builder.SaveLayer(std::nullopt, nullptr);
       builder.DrawRect(rect1, paint);
       builder.DrawRect(rect2, paint);
     }
@@ -1327,8 +1345,8 @@ void BM_SaveLayer(benchmark::State& state,
 
   // We only want to time the actual rasterization.
   for ([[maybe_unused]] auto _ : state) {
-    canvas.DrawDisplayList(display_list);
-    FlushSubmitCpuSync(surface);
+    canvas->DrawDisplayList(display_list);
+    surface->FlushSubmitCpuSync();
   }
 
   auto filename = surface_provider->backend_name() + "-SaveLayer-" +
diff --git a/engine/src/flutter/display_list/benchmarking/dl_benchmarks.h b/engine/src/flutter/display_list/benchmarking/dl_benchmarks.h
index eff8be3952c..00f3a7deff7 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_benchmarks.h
+++ b/engine/src/flutter/display_list/benchmarking/dl_benchmarks.h
@@ -11,10 +11,6 @@
 #include "flutter/display_list/testing/dl_test_surface_provider.h"
 
 #include "third_party/benchmark/include/benchmark/benchmark.h"
-#include "third_party/skia/include/core/SkCanvas.h"
-#include "third_party/skia/include/core/SkPath.h"
-#include "third_party/skia/include/core/SkRRect.h"
-#include "third_party/skia/include/core/SkSurface.h"
 
 namespace flutter {
 namespace testing {
@@ -33,6 +29,13 @@ enum class RRectType {
   kComplex,
 };
 
+enum class PathVerb {
+  kLine,
+  kQuad,
+  kConic,
+  kCubic,
+};
+
 DlPaint GetPaintForRun(unsigned attributes);
 
 using BackendType = DlSurfaceProvider::BackendType;
@@ -65,7 +68,7 @@ void BM_DrawDRRect(benchmark::State& state,
 void BM_DrawPath(benchmark::State& state,
                  BackendType backend_type,
                  unsigned attributes,
-                 SkPath::Verb type);
+                 PathVerb type);
 void BM_DrawPoints(benchmark::State& state,
                    BackendType backend_type,
                    unsigned attributes,
@@ -97,7 +100,7 @@ void BM_DrawShadow(benchmark::State& state,
                    BackendType backend_type,
                    unsigned attributes,
                    bool transparent_occluder,
-                   SkPath::Verb type);
+                   PathVerb type);
 void BM_SaveLayer(benchmark::State& state,
                   BackendType backend_type,
                   unsigned attributes,
@@ -160,7 +163,7 @@ void BM_SaveLayer(benchmark::State& state,
                     Lines/BACKEND,                                      \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    SkPath::Verb::kLine_Verb)                           \
+                    PathVerb::kLine)                                    \
       ->RangeMultiplier(2)                                              \
       ->Range(8, 512)                                                   \
       ->UseRealTime()                                                   \
@@ -171,7 +174,7 @@ void BM_SaveLayer(benchmark::State& state,
                     Quads/BACKEND,                                      \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    SkPath::Verb::kQuad_Verb)                           \
+                    PathVerb::kQuad)                                    \
       ->RangeMultiplier(2)                                              \
       ->Range(8, 512)                                                   \
       ->UseRealTime()                                                   \
@@ -182,7 +185,7 @@ void BM_SaveLayer(benchmark::State& state,
                     Conics/BACKEND,                                     \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    SkPath::Verb::kConic_Verb)                          \
+                    PathVerb::kConic)                                   \
       ->RangeMultiplier(2)                                              \
       ->Range(8, 512)                                                   \
       ->UseRealTime()                                                   \
@@ -193,7 +196,7 @@ void BM_SaveLayer(benchmark::State& state,
                     Cubics/BACKEND,                                     \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    SkPath::Verb::kCubic_Verb)                          \
+                    PathVerb::kCubic)                                   \
       ->RangeMultiplier(2)                                              \
       ->Range(8, 512)                                                   \
       ->UseRealTime()                                                   \
@@ -205,7 +208,7 @@ void BM_SaveLayer(benchmark::State& state,
   BENCHMARK_CAPTURE(BM_DrawPoints, Points/BACKEND,                      \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    DlPointMode::kPoints)                       \
+                    DlPointMode::kPoints)                               \
       ->RangeMultiplier(2)                                              \
       ->Range(1024, 32768)                                              \
       ->UseRealTime()                                                   \
@@ -214,7 +217,7 @@ void BM_SaveLayer(benchmark::State& state,
   BENCHMARK_CAPTURE(BM_DrawPoints, Lines/BACKEND,                       \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    DlPointMode::kLines)                        \
+                    DlPointMode::kLines)                                \
       ->RangeMultiplier(2)                                              \
       ->Range(1024, 32768)                                              \
       ->UseRealTime()                                                   \
@@ -223,7 +226,7 @@ void BM_SaveLayer(benchmark::State& state,
   BENCHMARK_CAPTURE(BM_DrawPoints, Polygon/BACKEND,                     \
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
-                    DlPointMode::kPolygon)                      \
+                    DlPointMode::kPolygon)                              \
       ->RangeMultiplier(2)                                              \
       ->Range(1024, 32768)                                              \
       ->UseRealTime()                                                   \
@@ -443,7 +446,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     true,                                               \
-                    SkPath::Verb::kLine_Verb)                           \
+                    PathVerb::kLine)                                    \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -453,7 +456,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     true,                                               \
-                    SkPath::Verb::kQuad_Verb)                           \
+                    PathVerb::kQuad)                                    \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -463,7 +466,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     true,                                               \
-                    SkPath::Verb::kConic_Verb)                          \
+                    PathVerb::kConic)                                   \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -473,7 +476,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     true,                                               \
-                    SkPath::Verb::kCubic_Verb)                          \
+                    PathVerb::kCubic)                                   \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -483,7 +486,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     false,                                              \
-                    SkPath::Verb::kLine_Verb)                           \
+                    PathVerb::kLine)                                    \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -493,7 +496,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     false,                                              \
-                    SkPath::Verb::kQuad_Verb)                           \
+                    PathVerb::kQuad)                                    \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -503,7 +506,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     false,                                              \
-                    SkPath::Verb::kConic_Verb)                          \
+                    PathVerb::kConic)                                   \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
@@ -513,7 +516,7 @@ void BM_SaveLayer(benchmark::State& state,
                     BackendType::k##BACKEND##Backend,                   \
                     ATTRIBUTES,                                         \
                     false,                                              \
-                    SkPath::Verb::kCubic_Verb)                          \
+                    PathVerb::kCubic)                                   \
       ->RangeMultiplier(2)                                              \
       ->Range(1, 32)                                                    \
       ->UseRealTime()                                                   \
diff --git a/engine/src/flutter/display_list/benchmarking/dl_builder_benchmarks.cc b/engine/src/flutter/display_list/benchmarking/dl_builder_benchmarks.cc
index 36c717f4315..1f04802d144 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_builder_benchmarks.cc
+++ b/engine/src/flutter/display_list/benchmarking/dl_builder_benchmarks.cc
@@ -145,7 +145,7 @@ static void BM_DisplayListBuilderWithGlobalSaveLayer(
     DisplayListBuilder builder(prepare_rtree);
     builder.Scale(3.5, 3.5);
     builder.Translate(10.3, 6.9);
-    builder.SaveLayer(nullptr, nullptr);
+    builder.SaveLayer(std::nullopt, nullptr);
     builder.Translate(45.3, 27.9);
     DlOpReceiver& receiver = DisplayListBuilderBenchmarkAccessor(builder);
     for (auto& group : allRenderingOps) {
@@ -169,7 +169,7 @@ static void BM_DisplayListBuilderWithSaveLayer(
     for (auto& group : allRenderingOps) {
       for (size_t i = 0; i < group.variants.size(); i++) {
         auto& invocation = group.variants[i];
-        builder.SaveLayer(nullptr, nullptr);
+        builder.SaveLayer(std::nullopt, nullptr);
         invocation.Invoke(receiver);
         builder.Restore();
       }
diff --git a/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.cc b/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.cc
index 274ac85ef68..a30993fe656 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.cc
+++ b/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.cc
@@ -531,9 +531,9 @@ void DisplayListGLComplexityCalculator::GLHelper::drawImage(
   // If we don't need to upload, then the cost scales linearly with the
   // length of the image. If it needs uploading, the cost scales linearly
   // with the square of the area (!!!).
-  SkISize dimensions = image->dimensions();
-  unsigned int length = (dimensions.width() + dimensions.height()) / 2;
-  unsigned int area = dimensions.width() * dimensions.height();
+  DlISize dimensions = image->GetSize();
+  unsigned int length = (dimensions.width + dimensions.height) / 2;
+  unsigned int area = dimensions.Area();
 
   // m = 1/13
   // c = 0
@@ -561,7 +561,7 @@ void DisplayListGLComplexityCalculator::GLHelper::drawImage(
 }
 
 void DisplayListGLComplexityCalculator::GLHelper::ImageRect(
-    const SkISize& size,
+    const DlISize& size,
     bool texture_backed,
     bool render_with_attributes,
     bool enforce_src_edges) {
@@ -579,12 +579,12 @@ void DisplayListGLComplexityCalculator::GLHelper::ImageRect(
   unsigned int complexity;
   if (!texture_backed || (texture_backed && render_with_attributes &&
                           enforce_src_edges && IsAntiAliased())) {
-    unsigned int area = size.width() * size.height();
+    unsigned int area = size.Area();
     // m = 1/4000
     // c = 5
     complexity = (area + 20000) / 10;
   } else {
-    unsigned int length = (size.width() + size.height()) / 2;
+    unsigned int length = (size.width + size.height) / 2;
     // There's a little bit of spread here but the numbers are pretty large
     // anyway.
     //
@@ -606,8 +606,8 @@ void DisplayListGLComplexityCalculator::GLHelper::drawImageNine(
     return;
   }
 
-  SkISize dimensions = image->dimensions();
-  unsigned int area = dimensions.width() * dimensions.height();
+  DlISize dimensions = image->GetSize();
+  unsigned int area = dimensions.Area();
 
   // m = 1/3600
   // c = 3
diff --git a/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.h b/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.h
index 58d852bc7e0..7b9910f1b0b 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.h
+++ b/engine/src/flutter/display_list/benchmarking/dl_complexity_gl.h
@@ -85,7 +85,7 @@ class DisplayListGLComplexityCalculator
                     DlScalar dpr) override;
 
    protected:
-    void ImageRect(const SkISize& size,
+    void ImageRect(const DlISize& size,
                    bool texture_backed,
                    bool render_with_attributes,
                    bool enforce_src_edges) override;
diff --git a/engine/src/flutter/display_list/benchmarking/dl_complexity_helper.h b/engine/src/flutter/display_list/benchmarking/dl_complexity_helper.h
index 14aec150d8f..643e91dce6e 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_complexity_helper.h
+++ b/engine/src/flutter/display_list/benchmarking/dl_complexity_helper.h
@@ -104,7 +104,7 @@ class ComplexityCalculatorHelper
   void setInvertColors(bool invert) override {}
   void setStrokeCap(DlStrokeCap cap) override {}
   void setStrokeJoin(DlStrokeJoin join) override {}
-  void setStrokeMiter(SkScalar limit) override {}
+  void setStrokeMiter(DlScalar limit) override {}
   void setColor(DlColor color) override {}
   void setBlendMode(DlBlendMode mode) override {}
   void setColorSource(const DlColorSource* source) override {}
@@ -122,7 +122,7 @@ class ComplexityCalculatorHelper
     current_paint_.setDrawStyle(style);
   }
 
-  void setStrokeWidth(SkScalar width) override {
+  void setStrokeWidth(DlScalar width) override {
     current_paint_.setStrokeWidth(width);
   }
 
@@ -153,7 +153,7 @@ class ComplexityCalculatorHelper
     if (IsComplex()) {
       return;
     }
-    ImageRect(image->dimensions(), image->isTextureBacked(),
+    ImageRect(image->GetBounds().GetSize(), image->isTextureBacked(),
               render_with_attributes,
               constraint == DlSrcRectConstraint::kStrict);
   }
@@ -173,7 +173,7 @@ class ComplexityCalculatorHelper
     // This API just does a series of drawImage calls from the atlas
     // This is equivalent to calling drawImageRect lots of times
     for (int i = 0; i < count; i++) {
-      ImageRect(SkISize::Make(tex[i].GetWidth(), tex[i].GetHeight()), true,
+      ImageRect(DlIRect::RoundOut(tex[i]).GetSize(), true,
                 render_with_attributes, true);
     }
   }
@@ -220,32 +220,30 @@ class ComplexityCalculatorHelper
                                        unsigned int quad_verb_cost,
                                        unsigned int conic_verb_cost,
                                        unsigned int cubic_verb_cost) {
-    const SkPath& path = dl_path.GetSkPath();
-    int verb_count = path.countVerbs();
-    std::vector<uint8_t> verbs(verb_count);
-    path.getVerbs(verbs.data(), verbs.size());
-
+    const impeller::Path& path = dl_path.GetPath();
     unsigned int complexity = 0;
-    for (int i = 0; i < verb_count; i++) {
-      switch (verbs[i]) {
-        case SkPath::Verb::kLine_Verb:
+    for (auto it = path.begin(), end = path.end(); it != end; ++it) {
+      switch (it.type()) {
+        case impeller::Path::ComponentType::kLinear:
           complexity += line_verb_cost;
           break;
-        case SkPath::Verb::kQuad_Verb:
+        case impeller::Path::ComponentType::kQuadratic:
           complexity += quad_verb_cost;
           break;
-        case SkPath::Verb::kConic_Verb:
+        case impeller::Path::ComponentType::kConic:
           complexity += conic_verb_cost;
           break;
-        case SkPath::Verb::kCubic_Verb:
+        case impeller::Path::ComponentType::kCubic:
           complexity += cubic_verb_cost;
           break;
+        case impeller::Path::ComponentType::kContour:
+          break;
       }
     }
     return complexity;
   }
 
-  virtual void ImageRect(const SkISize& size,
+  virtual void ImageRect(const DlISize& size,
                          bool texture_backed,
                          bool render_with_attributes,
                          bool enforce_src_edges) = 0;
diff --git a/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.cc b/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.cc
index a04e5a2e37b..713096731cd 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.cc
+++ b/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.cc
@@ -481,8 +481,8 @@ void DisplayListMetalComplexityCalculator::MetalHelper::drawImage(
   // If we don't need to upload, then the cost scales linearly with the
   // area of the image. If it needs uploading, the cost scales linearly
   // with the square of the area (!!!).
-  SkISize dimensions = image->dimensions();
-  unsigned int area = dimensions.width() * dimensions.height();
+  DlISize dimensions = image->GetSize();
+  unsigned int area = dimensions.Area();
 
   // m = 1/17000
   // c = 3
@@ -502,7 +502,7 @@ void DisplayListMetalComplexityCalculator::MetalHelper::drawImage(
 }
 
 void DisplayListMetalComplexityCalculator::MetalHelper::ImageRect(
-    const SkISize& size,
+    const DlISize& size,
     bool texture_backed,
     bool render_with_attributes,
     bool enforce_src_edges) {
@@ -513,7 +513,7 @@ void DisplayListMetalComplexityCalculator::MetalHelper::ImageRect(
   //
   // Within each group, they all perform within a few % of each other *except*
   // when we have a strict constraint and anti-aliasing enabled.
-  unsigned int area = size.width() * size.height();
+  unsigned int area = size.Area();
 
   // These values were worked out by creating a straight line graph (y=mx+c)
   // approximately matching the measured data, normalising the data so that
@@ -554,8 +554,8 @@ void DisplayListMetalComplexityCalculator::MetalHelper::drawImageNine(
   }
   // Whether uploading or not, the performance is comparable across all
   // variations.
-  SkISize dimensions = image->dimensions();
-  unsigned int area = dimensions.width() * dimensions.height();
+  DlISize dimensions = image->GetSize();
+  unsigned int area = dimensions.Area();
 
   // m = 1/8000
   // c = 3
diff --git a/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.h b/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.h
index 109b9a29f7a..fc0e430dd0a 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.h
+++ b/engine/src/flutter/display_list/benchmarking/dl_complexity_metal.h
@@ -85,7 +85,7 @@ class DisplayListMetalComplexityCalculator
                     DlScalar dpr) override;
 
    protected:
-    void ImageRect(const SkISize& size,
+    void ImageRect(const DlISize& size,
                    bool texture_backed,
                    bool render_with_attributes,
                    bool enforce_src_edges) override;
diff --git a/engine/src/flutter/display_list/benchmarking/dl_complexity_unittests.cc b/engine/src/flutter/display_list/benchmarking/dl_complexity_unittests.cc
index 26ec176c964..8e2b0ed5230 100644
--- a/engine/src/flutter/display_list/benchmarking/dl_complexity_unittests.cc
+++ b/engine/src/flutter/display_list/benchmarking/dl_complexity_unittests.cc
@@ -11,10 +11,6 @@
 #include "flutter/display_list/testing/dl_test_snippets.h"
 #include "flutter/testing/testing.h"
 
-#include "third_party/skia/include/core/SkBitmap.h"
-#include "third_party/skia/include/core/SkColor.h"
-#include "third_party/skia/include/core/SkImage.h"
-
 namespace flutter {
 namespace testing {
 
@@ -31,13 +27,13 @@ std::vector<DisplayListComplexityCalculator*> AccumulatorCalculators() {
           DisplayListGLComplexityCalculator::GetInstance()};
 }
 
-std::vector<SkPoint> GetTestPoints() {
-  std::vector<SkPoint> points;
-  points.push_back(SkPoint::Make(0, 0));
-  points.push_back(SkPoint::Make(10, 0));
-  points.push_back(SkPoint::Make(10, 10));
-  points.push_back(SkPoint::Make(20, 10));
-  points.push_back(SkPoint::Make(20, 20));
+std::vector<DlPoint> GetTestPoints() {
+  std::vector<DlPoint> points;
+  points.emplace_back(0, 0);
+  points.emplace_back(10, 0);
+  points.emplace_back(10, 10);
+  points.emplace_back(20, 10);
+  points.emplace_back(20, 20);
 
   return points;
 }
@@ -79,12 +75,11 @@ TEST(DisplayListComplexity, NestedDisplayList) {
 
 TEST(DisplayListComplexity, AntiAliasing) {
   DisplayListBuilder builder_no_aa;
-  builder_no_aa.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
-                         DlPaint());
+  builder_no_aa.DrawLine(DlPoint(0, 0), DlPoint(100, 100), DlPaint());
   auto display_list_no_aa = builder_no_aa.Build();
 
   DisplayListBuilder builder_aa;
-  builder_aa.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
+  builder_aa.DrawLine(DlPoint(0, 0), DlPoint(100, 100),
                       DlPaint().setAntiAlias(true));
   auto display_list_aa = builder_aa.Build();
 
@@ -97,12 +92,12 @@ TEST(DisplayListComplexity, AntiAliasing) {
 
 TEST(DisplayListComplexity, StrokeWidth) {
   DisplayListBuilder builder_stroke_0;
-  builder_stroke_0.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
+  builder_stroke_0.DrawLine(DlPoint(0, 0), DlPoint(100, 100),
                             DlPaint().setStrokeWidth(0.0f));
   auto display_list_stroke_0 = builder_stroke_0.Build();
 
   DisplayListBuilder builder_stroke_1;
-  builder_stroke_1.DrawLine(SkPoint::Make(0, 0), SkPoint::Make(100, 100),
+  builder_stroke_1.DrawLine(DlPoint(0, 0), DlPoint(100, 100),
                             DlPaint().setStrokeWidth(1.0f));
   auto display_list_stroke_1 = builder_stroke_1.Build();
 
@@ -115,12 +110,12 @@ TEST(DisplayListComplexity, StrokeWidth) {
 
 TEST(DisplayListComplexity, Style) {
   DisplayListBuilder builder_filled;
-  builder_filled.DrawRect(SkRect::MakeXYWH(10, 10, 80, 80),
+  builder_filled.DrawRect(DlRect::MakeXYWH(10, 10, 80, 80),
                           DlPaint().setDrawStyle(DlDrawStyle::kFill));
   auto display_list_filled = builder_filled.Build();
 
   DisplayListBuilder builder_stroked;
-  builder_stroked.DrawRect(SkRect::MakeXYWH(10, 10, 80, 80),
+  builder_stroked.DrawRect(DlRect::MakeXYWH(10, 10, 80, 80),
                            DlPaint().setDrawStyle(DlDrawStyle::kStroke));
   auto display_list_stroked = builder_stroked.Build();
 
@@ -133,7 +128,7 @@ TEST(DisplayListComplexity, Style) {
 
 TEST(DisplayListComplexity, SaveLayers) {
   DisplayListBuilder builder;
-  builder.SaveLayer(nullptr, nullptr);
+  builder.SaveLayer(std::nullopt, nullptr);
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -144,35 +139,35 @@ TEST(DisplayListComplexity, SaveLayers) {
 
 TEST(DisplayListComplexity, DrawPath) {
   DisplayListBuilder builder_line;
-  SkPath line_path;
-  line_path.moveTo(SkPoint::Make(0, 0));
-  line_path.lineTo(SkPoint::Make(10, 10));
-  line_path.close();
-  builder_line.DrawPath(line_path, DlPaint());
+  DlPathBuilder line_path_builder;
+  line_path_builder.MoveTo(DlPoint(0, 0));
+  line_path_builder.LineTo(DlPoint(10, 10));
+  line_path_builder.Close();
+  builder_line.DrawPath(DlPath(line_path_builder), DlPaint());
   auto display_list_line = builder_line.Build();
 
   DisplayListBuilder builder_quad;
-  SkPath quad_path;
-  quad_path.moveTo(SkPoint::Make(0, 0));
-  quad_path.quadTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20));
-  quad_path.close();
-  builder_quad.DrawPath(quad_path, DlPaint());
+  DlPathBuilder quad_path_builder;
+  quad_path_builder.MoveTo(DlPoint(0, 0));
+  quad_path_builder.QuadraticCurveTo(DlPoint(10, 10), DlPoint(10, 20));
+  quad_path_builder.Close();
+  builder_quad.DrawPath(DlPath(quad_path_builder), DlPaint());
   auto display_list_quad = builder_quad.Build();
 
   DisplayListBuilder builder_conic;
-  SkPath conic_path;
-  conic_path.moveTo(SkPoint::Make(0, 0));
-  conic_path.conicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20), 1.5f);
-  conic_path.close();
-  builder_conic.DrawPath(conic_path, DlPaint());
+  DlPathBuilder conic_path_builder;
+  conic_path_builder.MoveTo(DlPoint(0, 0));
+  conic_path_builder.ConicCurveTo(DlPoint(10, 10), DlPoint(10, 20), 1.5f);
+  conic_path_builder.Close();
+  builder_conic.DrawPath(DlPath(conic_path_builder), DlPaint());
   auto display_list_conic = builder_conic.Build();
 
   DisplayListBuilder builder_cubic;
-  SkPath cubic_path;
-  cubic_path.moveTo(SkPoint::Make(0, 0));
-  cubic_path.cubicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20),
-                     SkPoint::Make(20, 20));
-  builder_cubic.DrawPath(cubic_path, DlPaint());
+  DlPathBuilder cubic_path_builder;
+  cubic_path_builder.MoveTo(DlPoint(0, 0));
+  cubic_path_builder.CubicCurveTo(DlPoint(10, 10), DlPoint(10, 20),
+                                  DlPoint(20, 20));
+  builder_cubic.DrawPath(DlPath(cubic_path_builder), DlPaint());
   auto display_list_cubic = builder_cubic.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -186,37 +181,39 @@ TEST(DisplayListComplexity, DrawPath) {
 
 TEST(DisplayListComplexity, DrawShadow) {
   DisplayListBuilder builder_line;
-  SkPath line_path;
-  line_path.moveTo(SkPoint::Make(0, 0));
-  line_path.lineTo(SkPoint::Make(10, 10));
-  line_path.close();
-  builder_line.DrawShadow(line_path, DlColor(SK_ColorRED), 10.0f, false, 1.0f);
+  DlPathBuilder line_path_builder;
+  line_path_builder.MoveTo(DlPoint(0, 0));
+  line_path_builder.LineTo(DlPoint(10, 10));
+  line_path_builder.Close();
+  builder_line.DrawShadow(DlPath(line_path_builder), DlColor(SK_ColorRED),
+                          10.0f, false, 1.0f);
   auto display_list_line = builder_line.Build();
 
   DisplayListBuilder builder_quad;
-  SkPath quad_path;
-  quad_path.moveTo(SkPoint::Make(0, 0));
-  quad_path.quadTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20));
-  quad_path.close();
-  builder_quad.DrawShadow(quad_path, DlColor(SK_ColorRED), 10.0f, false, 1.0f);
+  DlPathBuilder quad_path_builder;
+  quad_path_builder.MoveTo(DlPoint(0, 0));
+  quad_path_builder.QuadraticCurveTo(DlPoint(10, 10), DlPoint(10, 20));
+  quad_path_builder.Close();
+  builder_quad.DrawShadow(DlPath(quad_path_builder), DlColor(SK_ColorRED),
+                          10.0f, false, 1.0f);
   auto display_list_quad = builder_quad.Build();
 
   DisplayListBuilder builder_conic;
-  SkPath conic_path;
-  conic_path.moveTo(SkPoint::Make(0, 0));
-  conic_path.conicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20), 1.5f);
-  conic_path.close();
-  builder_conic.DrawShadow(conic_path, DlColor(SK_ColorRED), 10.0f, false,
-                           1.0f);
+  DlPathBuilder conic_path_builder;
+  conic_path_builder.MoveTo(DlPoint(0, 0));
+  conic_path_builder.ConicCurveTo(DlPoint(10, 10), DlPoint(10, 20), 1.5f);
+  conic_path_builder.Close();
+  builder_conic.DrawShadow(DlPath(conic_path_builder), DlColor(SK_ColorRED),
+                           10.0f, false, 1.0f);
   auto display_list_conic = builder_conic.Build();
 
   DisplayListBuilder builder_cubic;
-  SkPath cubic_path;
-  cubic_path.moveTo(SkPoint::Make(0, 0));
-  cubic_path.cubicTo(SkPoint::Make(10, 10), SkPoint::Make(10, 20),
-                     SkPoint::Make(20, 20));
-  builder_cubic.DrawShadow(cubic_path, DlColor(SK_ColorRED), 10.0f, false,
-                           1.0f);
+  DlPathBuilder cubic_path_builder;
+  cubic_path_builder.MoveTo(DlPoint(0, 0));
+  cubic_path_builder.CubicCurveTo(DlPoint(10, 10), DlPoint(10, 20),
+                                  DlPoint(20, 20));
+  builder_cubic.DrawShadow(DlPath(cubic_path_builder), DlColor(SK_ColorRED),
+                           10.0f, false, 1.0f);
   auto display_list_cubic = builder_cubic.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -230,7 +227,7 @@ TEST(DisplayListComplexity, DrawShadow) {
 
 TEST(DisplayListComplexity, DrawOval) {
   DisplayListBuilder builder;
-  builder.DrawOval(SkRect::MakeXYWH(10, 10, 100, 80), DlPaint());
+  builder.DrawOval(DlRect::MakeXYWH(10, 10, 100, 80), DlPaint());
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -241,7 +238,7 @@ TEST(DisplayListComplexity, DrawOval) {
 
 TEST(DisplayListComplexity, DrawCircle) {
   DisplayListBuilder builder;
-  builder.DrawCircle(SkPoint::Make(50, 50), 10.0f, DlPaint());
+  builder.DrawCircle(DlPoint(50, 50), 10.0f, DlPaint());
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -250,10 +247,10 @@ TEST(DisplayListComplexity, DrawCircle) {
   }
 }
 
-TEST(DisplayListComplexity, DrawRRect) {
+TEST(DisplayListComplexity, DrawRoundRect) {
   DisplayListBuilder builder;
-  builder.DrawRRect(
-      SkRRect::MakeRectXY(SkRect::MakeXYWH(10, 10, 80, 80), 2.0f, 3.0f),
+  builder.DrawRoundRect(
+      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(10, 10, 80, 80), 2.0f, 3.0f),
       DlPaint());
   auto display_list = builder.Build();
 
@@ -263,13 +260,13 @@ TEST(DisplayListComplexity, DrawRRect) {
   }
 }
 
-TEST(DisplayListComplexity, DrawDRRect) {
+TEST(DisplayListComplexity, DrawDiffRoundRect) {
   DisplayListBuilder builder;
-  SkRRect outer =
-      SkRRect::MakeRectXY(SkRect::MakeXYWH(10, 10, 80, 80), 2.0f, 3.0f);
-  SkRRect inner =
-      SkRRect::MakeRectXY(SkRect::MakeXYWH(15, 15, 70, 70), 1.5f, 1.5f);
-  builder.DrawDRRect(outer, inner, DlPaint());
+  DlRoundRect outer =
+      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(10, 10, 80, 80), 2.0f, 3.0f);
+  DlRoundRect inner =
+      DlRoundRect::MakeRectXY(DlRect::MakeXYWH(15, 15, 70, 70), 1.5f, 1.5f);
+  builder.DrawDiffRoundRect(outer, inner, DlPaint());
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -280,7 +277,7 @@ TEST(DisplayListComplexity, DrawDRRect) {
 
 TEST(DisplayListComplexity, DrawArc) {
   DisplayListBuilder builder;
-  builder.DrawArc(SkRect::MakeXYWH(10, 10, 100, 80), 0.0f, 10.0f, true,
+  builder.DrawArc(DlRect::MakeXYWH(10, 10, 100, 80), 0.0f, 10.0f, true,
                   DlPaint());
   auto display_list = builder.Build();
 
@@ -293,7 +290,7 @@ TEST(DisplayListComplexity, DrawArc) {
 TEST(DisplayListComplexity, DrawVertices) {
   auto points = GetTestPoints();
   auto vertices = DlVertices::Make(DlVertexMode::kTriangles, points.size(),
-                                   ToDlPoints(points.data()), nullptr, nullptr);
+                                   points.data(), nullptr, nullptr);
   DisplayListBuilder builder;
   builder.DrawVertices(vertices, DlBlendMode::kSrc, DlPaint());
   auto display_list = builder.Build();
@@ -305,8 +302,8 @@ TEST(DisplayListComplexity, DrawVertices) {
 }
 
 TEST(DisplayListComplexity, DrawTextBlob) {
-  auto text_blob = SkTextBlob::MakeFromString(
-      "The quick brown fox jumps over the lazy dog.", CreateTestFontOfSize(20));
+  auto text_blob =
+      GetTestTextBlob("The quick brown fox jumps over the lazy dog.", 20.0f);
 
   DisplayListBuilder builder;
   builder.DrawTextBlob(text_blob, 0.0f, 0.0f, DlPaint());
@@ -351,16 +348,11 @@ TEST(DisplayListComplexity, DrawPoints) {
 }
 
 TEST(DisplayListComplexity, DrawImage) {
-  SkImageInfo info =
-      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
-                        SkAlphaType::kPremul_SkAlphaType);
-  SkBitmap bitmap;
-  bitmap.allocPixels(info, 0);
-  auto image = SkImages::RasterFromBitmap(bitmap);
+  auto image = MakeTestImage(50, 50, DlColor::kBlue().withAlphaF(0.5));
 
   DisplayListBuilder builder;
-  builder.DrawImage(DlImage::Make(image), SkPoint::Make(0, 0),
-                    DlImageSampling::kNearestNeighbor, nullptr);
+  builder.DrawImage(image, DlPoint(0, 0), DlImageSampling::kNearestNeighbor,
+                    nullptr);
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -370,19 +362,13 @@ TEST(DisplayListComplexity, DrawImage) {
 }
 
 TEST(DisplayListComplexity, DrawImageNine) {
-  SkImageInfo info =
-      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
-                        SkAlphaType::kPremul_SkAlphaType);
-  SkBitmap bitmap;
-  bitmap.allocPixels(info, 0);
-  auto image = SkImages::RasterFromBitmap(bitmap);
+  auto image = MakeTestImage(50, 50, DlColor::kBlue().withAlphaF(0.5));
 
-  SkIRect center = SkIRect::MakeXYWH(5, 5, 20, 20);
-  SkRect dest = SkRect::MakeXYWH(0, 0, 50, 50);
+  DlIRect center = DlIRect::MakeXYWH(5, 5, 20, 20);
+  DlRect dest = DlRect::MakeXYWH(0, 0, 50, 50);
 
   DisplayListBuilder builder;
-  builder.DrawImageNine(DlImage::Make(image), center, dest,
-                        DlFilterMode::kNearest, nullptr);
+  builder.DrawImageNine(image, center, dest, DlFilterMode::kNearest, nullptr);
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -392,19 +378,14 @@ TEST(DisplayListComplexity, DrawImageNine) {
 }
 
 TEST(DisplayListComplexity, DrawImageRect) {
-  SkImageInfo info =
-      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
-                        SkAlphaType::kPremul_SkAlphaType);
-  SkBitmap bitmap;
-  bitmap.allocPixels(info, 0);
-  auto image = SkImages::RasterFromBitmap(bitmap);
+  auto image = MakeTestImage(50, 50, DlColor::kBlue().withAlphaF(0.5));
 
-  SkRect src = SkRect::MakeXYWH(0, 0, 50, 50);
-  SkRect dest = SkRect::MakeXYWH(0, 0, 50, 50);
+  DlRect src = DlRect::MakeXYWH(0, 0, 50, 50);
+  DlRect dest = DlRect::MakeXYWH(0, 0, 50, 50);
 
   DisplayListBuilder builder;
-  builder.DrawImageRect(DlImage::Make(image), src, dest,
-                        DlImageSampling::kNearestNeighbor, nullptr);
+  builder.DrawImageRect(image, src, dest, DlImageSampling::kNearestNeighbor,
+                        nullptr);
   auto display_list = builder.Build();
 
   auto calculators = AccumulatorCalculators();
@@ -414,12 +395,7 @@ TEST(DisplayListComplexity, DrawImageRect) {
 }
 
 TEST(DisplayListComplexity, DrawAtlas) {
-  SkImageInfo info =
-      SkImageInfo::Make(50, 50, SkColorType::kRGBA_8888_SkColorType,
-                        SkAlphaType::kPremul_SkAlphaType);
-  SkBitmap bitmap;
-  bitmap.allocPixels(info, 0);
-  auto image = SkImages::RasterFromBitmap(bitmap);
+  auto image = MakeTestImage(50, 50, DlColor::kBlue().withAlphaF(0.5));
 
   std::vector<DlRect> rects;
   std::vector<DlRSTransform> xforms;
@@ -429,8 +405,8 @@ TEST(DisplayListComplexity, DrawAtlas) {
   }
 
   DisplayListBuilder builder;
-  builder.DrawAtlas(DlImage::Make(image), xforms.data(), rects.data(), nullptr,
-                    10, DlBlendMode::kSrc, DlImageSampling::kNearestNeighbor,
+  builder.DrawAtlas(image, xforms.data(), rects.data(), nullptr, 10,
+                    DlBlendMode::kSrc, DlImageSampling::kNearestNeighbor,
                     nullptr, nullptr);
   auto display_list = builder.Build();
 
diff --git a/engine/src/flutter/display_list/dl_builder.cc b/engine/src/flutter/display_list/dl_builder.cc
index 26feed43345..134cb1f8f5e 100644
--- a/engine/src/flutter/display_list/dl_builder.cc
+++ b/engine/src/flutter/display_list/dl_builder.cc
@@ -149,8 +149,8 @@ DlISize DisplayListBuilder::GetBaseLayerDimensions() const {
 }
 
 SkImageInfo DisplayListBuilder::GetImageInfo() const {
-  SkISize size = GetBaseLayerSize();
-  return SkImageInfo::MakeUnknown(size.width(), size.height());
+  DlISize size = GetBaseLayerDimensions();
+  return SkImageInfo::MakeUnknown(size.width, size.height);
 }
 
 void DisplayListBuilder::onSetAntiAlias(bool aa) {
@@ -1288,7 +1288,7 @@ void DisplayListBuilder::drawPoints(DlPointMode mode,
   }
 
   FML_DCHECK(count < DlOpReceiver::kMaxDrawPointsCount);
-  int bytes = count * sizeof(SkPoint);
+  int bytes = count * sizeof(DlPoint);
   AccumulationRect accumulator;
   for (size_t i = 0; i < count; i++) {
     accumulator.accumulate(pts[i]);
diff --git a/engine/src/flutter/display_list/image/dl_image.h b/engine/src/flutter/display_list/image/dl_image.h
index fb84c30c4c7..fd993dbca2e 100644
--- a/engine/src/flutter/display_list/image/dl_image.h
+++ b/engine/src/flutter/display_list/image/dl_image.h
@@ -84,6 +84,11 @@ class DlImage : public SkRefCnt {
   ///
   virtual SkISize dimensions() const = 0;
 
+  //----------------------------------------------------------------------------
+  /// @return     The dimensions of the pixel grid.
+  ///
+  virtual DlISize GetSize() const = 0;
+
   //----------------------------------------------------------------------------
   /// @return     The approximate byte size of the allocation of this image.
   ///             This takes into account details such as mip-mapping. The
diff --git a/engine/src/flutter/display_list/image/dl_image_skia.cc b/engine/src/flutter/display_list/image/dl_image_skia.cc
index 8c896e5c6f6..bd82399cf1d 100644
--- a/engine/src/flutter/display_list/image/dl_image_skia.cc
+++ b/engine/src/flutter/display_list/image/dl_image_skia.cc
@@ -47,6 +47,11 @@ SkISize DlImageSkia::dimensions() const {
   return image_ ? image_->dimensions() : SkISize::MakeEmpty();
 }
 
+// |DlImage|
+DlISize DlImageSkia::GetSize() const {
+  return image_ ? ToDlISize(image_->dimensions()) : DlISize();
+}
+
 // |DlImage|
 size_t DlImageSkia::GetApproximateByteSize() const {
   auto size = sizeof(*this);
diff --git a/engine/src/flutter/display_list/image/dl_image_skia.h b/engine/src/flutter/display_list/image/dl_image_skia.h
index 03bcfa144a8..f8b4bd06e4a 100644
--- a/engine/src/flutter/display_list/image/dl_image_skia.h
+++ b/engine/src/flutter/display_list/image/dl_image_skia.h
@@ -35,6 +35,9 @@ class DlImageSkia final : public DlImage {
   // |DlImage|
   SkISize dimensions() const override;
 
+  // |DlImage|
+  DlISize GetSize() const override;
+
   // |DlImage|
   size_t GetApproximateByteSize() const override;
 
diff --git a/engine/src/flutter/display_list/testing/dl_rendering_unittests.cc b/engine/src/flutter/display_list/testing/dl_rendering_unittests.cc
index b6ef789a6c5..292aded3bfc 100644
--- a/engine/src/flutter/display_list/testing/dl_rendering_unittests.cc
+++ b/engine/src/flutter/display_list/testing/dl_rendering_unittests.cc
@@ -48,21 +48,19 @@ constexpr int kTestWidth = 200;
 constexpr int kTestHeight = 200;
 constexpr int kRenderWidth = 100;
 constexpr int kRenderHeight = 100;
-constexpr int kRenderHalfWidth = 50;
-constexpr int kRenderHalfHeight = 50;
 constexpr int kRenderLeft = (kTestWidth - kRenderWidth) / 2;
 constexpr int kRenderTop = (kTestHeight - kRenderHeight) / 2;
 constexpr int kRenderRight = kRenderLeft + kRenderWidth;
 constexpr int kRenderBottom = kRenderTop + kRenderHeight;
 constexpr int kRenderCenterX = (kRenderLeft + kRenderRight) / 2;
 constexpr int kRenderCenterY = (kRenderTop + kRenderBottom) / 2;
-constexpr SkScalar kRenderRadius = std::min(kRenderWidth, kRenderHeight) / 2.0;
-constexpr SkScalar kRenderCornerRadius = kRenderRadius / 5.0;
+constexpr DlScalar kRenderRadius = std::min(kRenderWidth, kRenderHeight) / 2.0;
+constexpr DlScalar kRenderCornerRadius = kRenderRadius / 5.0;
 
-constexpr SkPoint kTestCenter = SkPoint::Make(kTestWidth / 2, kTestHeight / 2);
-constexpr SkRect kTestBounds2 = SkRect::MakeWH(kTestWidth, kTestHeight);
-constexpr SkRect kRenderBounds =
-    SkRect::MakeLTRB(kRenderLeft, kRenderTop, kRenderRight, kRenderBottom);
+constexpr DlRect kTestBounds2 = DlRect::MakeWH(kTestWidth, kTestHeight);
+const DlPoint kTestCenter2 = kTestBounds2.GetCenter();
+constexpr DlRect kRenderBounds =
+    DlRect::MakeLTRB(kRenderLeft, kRenderTop, kRenderRight, kRenderBottom);
 
 // The tests try 3 miter limit values, 0.0, 4.0 (the default), and 10.0
 // These values will allow us to construct a diamond that spans the
@@ -74,29 +72,29 @@ constexpr SkRect kRenderBounds =
 
 // The X offsets which will be used for tall vertical diamonds are
 // expressed in terms of the rendering height to obtain the proper angle
-constexpr SkScalar kMiterExtremeDiamondOffsetX = kRenderHeight * 0.04;
-constexpr SkScalar kMiter10DiamondOffsetX = kRenderHeight * 0.051;
-constexpr SkScalar kMiter4DiamondOffsetX = kRenderHeight * 0.14;
+constexpr DlScalar kMiterExtremeDiamondOffsetX = kRenderHeight * 0.04;
+constexpr DlScalar kMiter10DiamondOffsetX = kRenderHeight * 0.051;
+constexpr DlScalar kMiter4DiamondOffsetX = kRenderHeight * 0.14;
 
 // The Y offsets which will be used for long horizontal diamonds are
 // expressed in terms of the rendering width to obtain the proper angle
-constexpr SkScalar kMiterExtremeDiamondOffsetY = kRenderWidth * 0.04;
-constexpr SkScalar kMiter10DiamondOffsetY = kRenderWidth * 0.051;
-constexpr SkScalar kMiter4DiamondOffsetY = kRenderWidth * 0.14;
+constexpr DlScalar kMiterExtremeDiamondOffsetY = kRenderWidth * 0.04;
+constexpr DlScalar kMiter10DiamondOffsetY = kRenderWidth * 0.051;
+constexpr DlScalar kMiter4DiamondOffsetY = kRenderWidth * 0.14;
 
 // Render 3 vertical and horizontal diamonds each
 // designed to break at the tested miter limits
 // 0.0, 4.0 and 10.0
 // Center is biased by 0.5 to include more pixel centers in the
 // thin miters
-constexpr SkScalar kXOffset0 = kRenderCenterX + 0.5;
-constexpr SkScalar kXOffsetL1 = kXOffset0 - kMiter4DiamondOffsetX;
-constexpr SkScalar kXOffsetL2 = kXOffsetL1 - kMiter10DiamondOffsetX;
-constexpr SkScalar kXOffsetL3 = kXOffsetL2 - kMiter10DiamondOffsetX;
-constexpr SkScalar kXOffsetR1 = kXOffset0 + kMiter4DiamondOffsetX;
-constexpr SkScalar kXOffsetR2 = kXOffsetR1 + kMiterExtremeDiamondOffsetX;
-constexpr SkScalar kXOffsetR3 = kXOffsetR2 + kMiterExtremeDiamondOffsetX;
-constexpr SkPoint kVerticalMiterDiamondPoints[] = {
+constexpr DlScalar kXOffset0 = kRenderCenterX + 0.5;
+constexpr DlScalar kXOffsetL1 = kXOffset0 - kMiter4DiamondOffsetX;
+constexpr DlScalar kXOffsetL2 = kXOffsetL1 - kMiter10DiamondOffsetX;
+constexpr DlScalar kXOffsetL3 = kXOffsetL2 - kMiter10DiamondOffsetX;
+constexpr DlScalar kXOffsetR1 = kXOffset0 + kMiter4DiamondOffsetX;
+constexpr DlScalar kXOffsetR2 = kXOffsetR1 + kMiterExtremeDiamondOffsetX;
+constexpr DlScalar kXOffsetR3 = kXOffsetR2 + kMiterExtremeDiamondOffsetX;
+constexpr DlPoint kVerticalMiterDiamondPoints[] = {
     // Vertical diamonds:
     //  M10   M4  Mextreme
     //   /\   /|\   /\       top of RenderBounds
@@ -105,50 +103,50 @@ constexpr SkPoint kVerticalMiterDiamondPoints[] = {
     //  \  / \ | / \  /              to
     //   \/   \|/   \/      bottom of RenderBounds
     // clang-format off
-    SkPoint::Make(kXOffsetL3, kRenderCenterY),
-    SkPoint::Make(kXOffsetL2, kRenderTop),
-    SkPoint::Make(kXOffsetL1, kRenderCenterY),
-    SkPoint::Make(kXOffset0,  kRenderTop),
-    SkPoint::Make(kXOffsetR1, kRenderCenterY),
-    SkPoint::Make(kXOffsetR2, kRenderTop),
-    SkPoint::Make(kXOffsetR3, kRenderCenterY),
-    SkPoint::Make(kXOffsetR2, kRenderBottom),
-    SkPoint::Make(kXOffsetR1, kRenderCenterY),
-    SkPoint::Make(kXOffset0,  kRenderBottom),
-    SkPoint::Make(kXOffsetL1, kRenderCenterY),
-    SkPoint::Make(kXOffsetL2, kRenderBottom),
-    SkPoint::Make(kXOffsetL3, kRenderCenterY),
+    DlPoint(kXOffsetL3, kRenderCenterY),
+    DlPoint(kXOffsetL2, kRenderTop),
+    DlPoint(kXOffsetL1, kRenderCenterY),
+    DlPoint(kXOffset0,  kRenderTop),
+    DlPoint(kXOffsetR1, kRenderCenterY),
+    DlPoint(kXOffsetR2, kRenderTop),
+    DlPoint(kXOffsetR3, kRenderCenterY),
+    DlPoint(kXOffsetR2, kRenderBottom),
+    DlPoint(kXOffsetR1, kRenderCenterY),
+    DlPoint(kXOffset0,  kRenderBottom),
+    DlPoint(kXOffsetL1, kRenderCenterY),
+    DlPoint(kXOffsetL2, kRenderBottom),
+    DlPoint(kXOffsetL3, kRenderCenterY),
     // clang-format on
 };
 const int kVerticalMiterDiamondPointCount =
     sizeof(kVerticalMiterDiamondPoints) /
     sizeof(kVerticalMiterDiamondPoints[0]);
 
-constexpr SkScalar kYOffset0 = kRenderCenterY + 0.5;
-constexpr SkScalar kYOffsetU1 = kXOffset0 - kMiter4DiamondOffsetY;
-constexpr SkScalar kYOffsetU2 = kYOffsetU1 - kMiter10DiamondOffsetY;
-constexpr SkScalar kYOffsetU3 = kYOffsetU2 - kMiter10DiamondOffsetY;
-constexpr SkScalar kYOffsetD1 = kXOffset0 + kMiter4DiamondOffsetY;
-constexpr SkScalar kYOffsetD2 = kYOffsetD1 + kMiterExtremeDiamondOffsetY;
-constexpr SkScalar kYOffsetD3 = kYOffsetD2 + kMiterExtremeDiamondOffsetY;
-const SkPoint kHorizontalMiterDiamondPoints[] = {
+constexpr DlScalar kYOffset0 = kRenderCenterY + 0.5;
+constexpr DlScalar kYOffsetU1 = kXOffset0 - kMiter4DiamondOffsetY;
+constexpr DlScalar kYOffsetU2 = kYOffsetU1 - kMiter10DiamondOffsetY;
+constexpr DlScalar kYOffsetU3 = kYOffsetU2 - kMiter10DiamondOffsetY;
+constexpr DlScalar kYOffsetD1 = kXOffset0 + kMiter4DiamondOffsetY;
+constexpr DlScalar kYOffsetD2 = kYOffsetD1 + kMiterExtremeDiamondOffsetY;
+constexpr DlScalar kYOffsetD3 = kYOffsetD2 + kMiterExtremeDiamondOffsetY;
+const DlPoint kHorizontalMiterDiamondPoints[] = {
     // Horizontal diamonds
     // Same configuration as Vertical diamonds above but
     // rotated 90 degrees
     // clang-format off
-    SkPoint::Make(kRenderCenterX, kYOffsetU3),
-    SkPoint::Make(kRenderLeft,    kYOffsetU2),
-    SkPoint::Make(kRenderCenterX, kYOffsetU1),
-    SkPoint::Make(kRenderLeft,    kYOffset0),
-    SkPoint::Make(kRenderCenterX, kYOffsetD1),
-    SkPoint::Make(kRenderLeft,    kYOffsetD2),
-    SkPoint::Make(kRenderCenterX, kYOffsetD3),
-    SkPoint::Make(kRenderRight,   kYOffsetD2),
-    SkPoint::Make(kRenderCenterX, kYOffsetD1),
-    SkPoint::Make(kRenderRight,   kYOffset0),
-    SkPoint::Make(kRenderCenterX, kYOffsetU1),
-    SkPoint::Make(kRenderRight,   kYOffsetU2),
-    SkPoint::Make(kRenderCenterX, kYOffsetU3),
+    DlPoint(kRenderCenterX, kYOffsetU3),
+    DlPoint(kRenderLeft,    kYOffsetU2),
+    DlPoint(kRenderCenterX, kYOffsetU1),
+    DlPoint(kRenderLeft,    kYOffset0),
+    DlPoint(kRenderCenterX, kYOffsetD1),
+    DlPoint(kRenderLeft,    kYOffsetD2),
+    DlPoint(kRenderCenterX, kYOffsetD3),
+    DlPoint(kRenderRight,   kYOffsetD2),
+    DlPoint(kRenderCenterX, kYOffsetD1),
+    DlPoint(kRenderRight,   kYOffset0),
+    DlPoint(kRenderCenterX, kYOffsetU1),
+    DlPoint(kRenderRight,   kYOffsetU2),
+    DlPoint(kRenderCenterX, kYOffsetU3),
     // clang-format on
 };
 const int kHorizontalMiterDiamondPointCount =
@@ -193,12 +191,12 @@ static void DrawCheckerboard(DlCanvas* canvas) {
   // Some pixels need some transparency for DstIn testing
   p1.setAlpha(128);
   int cbdim = 5;
-  int width = canvas->GetBaseLayerSize().width();
-  int height = canvas->GetBaseLayerSize().height();
+  int width = canvas->GetBaseLayerDimensions().width;
+  int height = canvas->GetBaseLayerDimensions().height;
   for (int y = 0; y < width; y += cbdim) {
     for (int x = 0; x < height; x += cbdim) {
       DlPaint& cellp = ((x + y) & 1) == 0 ? p0 : p1;
-      canvas->DrawRect(SkRect::MakeXYWH(x, y, cbdim, cbdim), cellp);
+      canvas->DrawRect(DlRect::MakeXYWH(x, y, cbdim, cbdim), cellp);
     }
   }
 }
@@ -262,70 +260,65 @@ class BoundsTolerance {
   BoundsTolerance() = default;
   BoundsTolerance(const BoundsTolerance&) = default;
 
-  BoundsTolerance addBoundsPadding(SkScalar bounds_pad_x,
-                                   SkScalar bounds_pad_y) const {
+  BoundsTolerance addBoundsPadding(DlScalar bounds_pad_x,
+                                   DlScalar bounds_pad_y) const {
     BoundsTolerance copy = BoundsTolerance(*this);
-    copy.bounds_pad_.offset(bounds_pad_x, bounds_pad_y);
+    copy.bounds_pad_ += DlPoint(bounds_pad_x, bounds_pad_y);
     return copy;
   }
 
-  BoundsTolerance mulScale(SkScalar scale_x, SkScalar scale_y) const {
+  BoundsTolerance mulScale(DlScalar scale_x, DlScalar scale_y) const {
     BoundsTolerance copy = BoundsTolerance(*this);
-    copy.scale_.fX *= scale_x;
-    copy.scale_.fY *= scale_y;
+    copy.scale_ *= DlPoint(scale_x, scale_y);
     return copy;
   }
 
-  BoundsTolerance addAbsolutePadding(SkScalar absolute_pad_x,
-                                     SkScalar absolute_pad_y) const {
+  BoundsTolerance addAbsolutePadding(DlScalar absolute_pad_x,
+                                     DlScalar absolute_pad_y) const {
     BoundsTolerance copy = BoundsTolerance(*this);
-    copy.absolute_pad_.offset(absolute_pad_x, absolute_pad_y);
+    copy.absolute_pad_ += DlPoint(absolute_pad_x, absolute_pad_y);
     return copy;
   }
 
-  BoundsTolerance addPostClipPadding(SkScalar absolute_pad_x,
-                                     SkScalar absolute_pad_y) const {
+  BoundsTolerance addPostClipPadding(DlScalar absolute_pad_x,
+                                     DlScalar absolute_pad_y) const {
     BoundsTolerance copy = BoundsTolerance(*this);
-    copy.clip_pad_.offset(absolute_pad_x, absolute_pad_y);
+    copy.clip_pad_ += DlPoint(absolute_pad_x, absolute_pad_y);
     return copy;
   }
 
-  BoundsTolerance addDiscreteOffset(SkScalar discrete_offset) const {
+  BoundsTolerance addDiscreteOffset(DlScalar discrete_offset) const {
     BoundsTolerance copy = BoundsTolerance(*this);
     copy.discrete_offset_ += discrete_offset;
     return copy;
   }
 
-  BoundsTolerance clip(SkRect clip) const {
+  BoundsTolerance clip(DlRect clip) const {
     BoundsTolerance copy = BoundsTolerance(*this);
-    if (!copy.clip_.intersect(clip)) {
-      copy.clip_.setEmpty();
-    }
+    copy.clip_ = copy.clip_.IntersectionOrEmpty(clip);
     return copy;
   }
 
-  static SkRect Scale(const SkRect& rect, const SkPoint& scales) {
-    SkScalar outset_x = rect.width() * (scales.fX - 1);
-    SkScalar outset_y = rect.height() * (scales.fY - 1);
-    return rect.makeOutset(outset_x, outset_y);
+  static DlRect Scale(const DlRect& rect, const DlPoint& scales) {
+    DlScalar outset_x = rect.GetWidth() * (scales.x - 1);
+    DlScalar outset_y = rect.GetHeight() * (scales.y - 1);
+    return rect.Expand(outset_x, outset_y);
   }
 
-  bool overflows(SkIRect pix_bounds,
+  bool overflows(DlIRect pix_bounds,
                  int worst_bounds_pad_x,
                  int worst_bounds_pad_y) const {
-    SkRect allowed = SkRect::Make(pix_bounds);
-    allowed.outset(bounds_pad_.fX, bounds_pad_.fY);
+    DlRect allowed = DlRect::Make(pix_bounds);
+    allowed = allowed.Expand(bounds_pad_.x, bounds_pad_.y);
     allowed = Scale(allowed, scale_);
-    allowed.outset(absolute_pad_.fX, absolute_pad_.fY);
-    if (!allowed.intersect(clip_)) {
-      allowed.setEmpty();
-    }
-    allowed.outset(clip_pad_.fX, clip_pad_.fY);
-    SkIRect rounded = allowed.roundOut();
-    int pad_left = std::max(0, pix_bounds.fLeft - rounded.fLeft);
-    int pad_top = std::max(0, pix_bounds.fTop - rounded.fTop);
-    int pad_right = std::max(0, pix_bounds.fRight - rounded.fRight);
-    int pad_bottom = std::max(0, pix_bounds.fBottom - rounded.fBottom);
+    allowed = allowed.Expand(absolute_pad_.x, absolute_pad_.y);
+    allowed = allowed.IntersectionOrEmpty(clip_);
+    allowed = allowed.Expand(clip_pad_.x, clip_pad_.y);
+    DlIRect rounded = DlIRect::RoundOut(allowed);
+    int pad_left = std::max(0, pix_bounds.GetLeft() - rounded.GetLeft());
+    int pad_top = std::max(0, pix_bounds.GetTop() - rounded.GetTop());
+    int pad_right = std::max(0, pix_bounds.GetRight() - rounded.GetRight());
+    int pad_bottom = std::max(0, pix_bounds.GetBottom() - rounded.GetBottom());
     int allowed_pad_x = std::max(pad_left, pad_right);
     int allowed_pad_y = std::max(pad_top, pad_bottom);
     if (worst_bounds_pad_x > allowed_pad_x ||
@@ -337,7 +330,7 @@ class BoundsTolerance {
             worst_bounds_pad_y > allowed_pad_y);
   }
 
-  SkScalar discrete_offset() const { return discrete_offset_; }
+  DlScalar discrete_offset() const { return discrete_offset_; }
 
   bool operator==(BoundsTolerance const& other) const {
     return bounds_pad_ == other.bounds_pad_ && scale_ == other.scale_ &&
@@ -347,13 +340,13 @@ class BoundsTolerance {
   }
 
  private:
-  SkPoint bounds_pad_ = {0, 0};
-  SkPoint scale_ = {1, 1};
-  SkPoint absolute_pad_ = {0, 0};
-  SkRect clip_ = {-1E9, -1E9, 1E9, 1E9};
-  SkPoint clip_pad_ = {0, 0};
+  DlPoint bounds_pad_ = {0, 0};
+  DlPoint scale_ = {1, 1};
+  DlPoint absolute_pad_ = {0, 0};
+  DlRect clip_ = DlRect::MakeLTRB(-1E9, -1E9, 1E9, 1E9);
+  DlPoint clip_pad_ = {0, 0};
 
-  SkScalar discrete_offset_ = 0;
+  DlScalar discrete_offset_ = 0;
 };
 
 template <typename C, typename P, typename I>
@@ -429,7 +422,7 @@ class SkRenderResult final : public RenderResult {
 class ImpellerRenderResult final : public RenderResult {
  public:
   explicit ImpellerRenderResult(sk_sp<DlPixelData> screenshot,
-                                SkRect render_bounds)
+                                DlRect render_bounds)
       : screenshot_(std::move(screenshot)), render_bounds_(render_bounds) {}
   ~ImpellerRenderResult() override = default;
 
@@ -442,19 +435,19 @@ class ImpellerRenderResult final : public RenderResult {
   void write(const std::string& path) const override {
     screenshot_->write(path);
   }
-  const SkRect& render_bounds() const { return render_bounds_; }
+  const DlRect& render_bounds() const { return render_bounds_; }
 
  private:
   const sk_sp<DlPixelData> screenshot_;
-  SkRect render_bounds_;
+  DlRect render_bounds_;
 };
 
 struct RenderJobInfo {
   int width = kTestWidth;
   int height = kTestHeight;
   DlColor bg = DlColor::kTransparent();
-  SkScalar scale = SK_Scalar1;
-  SkScalar opacity = SK_Scalar1;
+  DlScalar scale = SK_Scalar1;
+  DlScalar opacity = SK_Scalar1;
 };
 
 struct JobRenderer {
@@ -464,20 +457,20 @@ struct JobRenderer {
 
 struct MatrixClipJobRenderer : public JobRenderer {
  public:
-  const SkMatrix& setup_matrix() const {
+  const DlMatrix& setup_matrix() const {
     FML_CHECK(is_setup_);
     return setup_matrix_;
   }
 
-  const SkIRect& setup_clip_bounds() const {
+  const DlIRect& setup_clip_bounds() const {
     FML_CHECK(is_setup_);
     return setup_clip_bounds_;
   }
 
  protected:
   bool is_setup_ = false;
-  SkMatrix setup_matrix_;
-  SkIRect setup_clip_bounds_;
+  DlMatrix setup_matrix_;
+  DlIRect setup_clip_bounds_;
 };
 
 struct SkJobRenderer : public MatrixClipJobRenderer {
@@ -495,8 +488,8 @@ struct SkJobRenderer : public MatrixClipJobRenderer {
     SkPaint paint;
     sk_setup_({canvas, paint, sk_image_});
     setup_paint_ = paint;
-    setup_matrix_ = canvas->getTotalMatrix();
-    setup_clip_bounds_ = canvas->getDeviceClipBounds();
+    setup_matrix_ = ToDlMatrix(canvas->getLocalToDevice());
+    setup_clip_bounds_ = ToDlIRect(canvas->getDeviceClipBounds());
     is_setup_ = true;
     sk_render_({canvas, paint, sk_image_});
     sk_restore_({canvas, paint, sk_image_});
@@ -505,7 +498,8 @@ struct SkJobRenderer : public MatrixClipJobRenderer {
   sk_sp<SkPicture> MakePicture(const RenderJobInfo& info) {
     SkPictureRecorder recorder;
     SkRTreeFactory rtree_factory;
-    SkCanvas* cv = recorder.beginRecording(kTestBounds2, &rtree_factory);
+    SkCanvas* cv =
+        recorder.beginRecording(ToSkRect(kTestBounds2), &rtree_factory);
     Render(cv, info);
     return recorder.finishRecordingAsPicture();
   }
@@ -543,8 +537,9 @@ struct DlJobRenderer : public MatrixClipJobRenderer {
     DlPaint paint;
     dl_setup_({canvas, paint, dl_image_});
     setup_paint_ = paint;
-    setup_matrix_ = canvas->GetTransform();
-    setup_clip_bounds_ = canvas->GetDestinationClipBounds().roundOut();
+    setup_matrix_ = canvas->GetMatrix();
+    setup_clip_bounds_ =
+        DlIRect::RoundOut(canvas->GetDestinationClipCoverage());
     is_setup_ = true;
     dl_render_({canvas, paint, dl_image_});
     dl_restore_({canvas, paint, dl_image_});
@@ -683,7 +678,7 @@ class RenderEnvironment {
     auto dl = builder.Build();
     auto snap = provider_->ImpellerSnapshot(dl, kTestWidth, kTestHeight);
     return std::make_unique<ImpellerRenderResult>(std::move(snap),
-                                                  render_dl->bounds());
+                                                  render_dl->GetBounds());
   }
 
   const DlSurfaceProvider* provider() const { return provider_; }
@@ -695,8 +690,8 @@ class RenderEnvironment {
 
   PixelFormat format() const { return format_; }
   const DlPaint& ref_dl_paint() const { return ref_dl_paint_; }
-  const SkMatrix& ref_matrix() const { return ref_matrix_; }
-  const SkIRect& ref_clip_bounds() const { return ref_clip_bounds_; }
+  const DlMatrix& ref_matrix() const { return ref_matrix_; }
+  const DlIRect& ref_clip_bounds() const { return ref_clip_bounds_; }
   const RenderResult* ref_sk_result() const { return ref_sk_result_.get(); }
   const RenderResult* ref_dl_result() const { return ref_dl_result_.get(); }
   const ImpellerRenderResult* ref_impeller_result() const {
@@ -730,8 +725,8 @@ class RenderEnvironment {
   std::shared_ptr<DlSurfaceInstance> surface_2x_;
 
   DlPaint ref_dl_paint_;
-  SkMatrix ref_matrix_;
-  SkIRect ref_clip_bounds_;
+  DlMatrix ref_matrix_;
+  DlIRect ref_clip_bounds_;
   std::unique_ptr<RenderResult> ref_sk_result_;
   std::unique_ptr<RenderResult> ref_dl_result_;
   std::unique_ptr<ImpellerRenderResult> ref_impeller_result_;
@@ -748,7 +743,7 @@ class RenderEnvironment {
   static const sk_sp<DlImage> makeTestImpellerImage(
       const DlSurfaceProvider* provider) {
     FML_DCHECK(provider->supports_impeller());
-    DisplayListBuilder builder(SkRect::MakeWH(kRenderWidth, kRenderHeight));
+    DisplayListBuilder builder(DlRect::MakeWH(kRenderWidth, kRenderHeight));
     DrawCheckerboard(&builder);
     return provider->MakeImpellerImage(builder.Build(),  //
                                        kRenderWidth, kRenderHeight);
@@ -945,8 +940,8 @@ class TestParameters {
         return false;
       }
       if (ref_attr.getStrokeJoin() == DlStrokeJoin::kMiter) {
-        SkScalar ref_miter = ref_attr.getStrokeMiter();
-        SkScalar test_miter = attr.getStrokeMiter();
+        DlScalar ref_miter = ref_attr.getStrokeMiter();
+        DlScalar test_miter = attr.getStrokeMiter();
         // miter limit < 1.4 affects right angles
         if (geo_flags.may_have_acute_joins() ||  //
             ref_miter < 1.4 || test_miter < 1.4) {
@@ -970,7 +965,7 @@ class TestParameters {
 
   const BoundsTolerance adjust(const BoundsTolerance& tolerance,
                                const DlPaint& paint,
-                               const SkMatrix& matrix) const {
+                               const DlMatrix& matrix) const {
     if (is_draw_text_blob() && tolerance.discrete_offset() > 0) {
       // drawTextBlob needs just a little more leeway when using a
       // discrete path effect.
@@ -986,7 +981,7 @@ class TestParameters {
         // its bounds in any of our test cases, but the bounds code needs
         // to take it into account for the cases where it might, so we
         // relax our tolerance to reflect the miter bounds padding.
-        SkScalar miter_pad =
+        DlScalar miter_pad =
             paint.getStrokeMiter() * paint.getStrokeWidth() * 0.5f;
         return tolerance.addBoundsPadding(miter_pad, miter_pad);
       }
@@ -996,9 +991,9 @@ class TestParameters {
 
   const BoundsTolerance lineAdjust(const BoundsTolerance& tolerance,
                                    const DlPaint& paint,
-                                   const SkMatrix& matrix) const {
-    SkScalar adjust = 0.0;
-    SkScalar half_width = paint.getStrokeWidth() * 0.5f;
+                                   const DlMatrix& matrix) const {
+    DlScalar adjust = 0.0;
+    DlScalar half_width = paint.getStrokeWidth() * 0.5f;
     if (tolerance.discrete_offset() > 0) {
       // When a discrete path effect is added, the bounds calculations must
       // allow for miters in any direction, but a horizontal line will not
@@ -1019,8 +1014,8 @@ class TestParameters {
     if (adjust == 0) {
       return tolerance;
     }
-    SkScalar h_tolerance;
-    SkScalar v_tolerance;
+    DlScalar h_tolerance;
+    DlScalar v_tolerance;
     if (is_horizontal_line()) {
       FML_DCHECK(!is_vertical_line());
       h_tolerance = adjust;
@@ -1176,13 +1171,14 @@ class CanvasCompareTester {
   static void RenderWithSaveRestore(const TestParameters& testP,
                                     const RenderEnvironment& env,
                                     const BoundsTolerance& tolerance) {
-    SkRect clip =
-        SkRect::MakeXYWH(kRenderCenterX - 1, kRenderCenterY - 1, 2, 2);
-    SkRect rect = SkRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 10, 10);
+    DlRect clip =
+        DlRect::MakeXYWH(kRenderCenterX - 1, kRenderCenterY - 1, 2, 2);
+    DlRect rect = DlRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 10, 10);
     DlColor alpha_layer_color = DlColor::kCyan().withAlpha(0x7f);
     SkRenderer sk_safe_restore = [=](const SkRenderContext& ctx) {
       // Draw another primitive to disable peephole optimizations
-      ctx.canvas->drawRect(kRenderBounds.makeOffset(500, 500), SkPaint());
+      ctx.canvas->drawRect(ToSkRect(kRenderBounds).makeOffset(500, 500),
+                           SkPaint());
       ctx.canvas->restore();
     };
     DlRenderer dl_safe_restore = [=](const DlRenderContext& ctx) {
@@ -1193,7 +1189,7 @@ class CanvasCompareTester {
       // won't practically show up in the output, but technically
       // can't be culled.
       ctx.canvas->DrawRect(
-          SkRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 0.0001, 0.0001),
+          DlRect::MakeXYWH(kRenderCenterX, kRenderCenterY, 0.0001, 0.0001),
           DlPaint());
       ctx.canvas->Restore();
     };
@@ -1205,17 +1201,18 @@ class CanvasCompareTester {
       // Just a simple restore to allow peephole optimizations to occur
       ctx.canvas->Restore();
     };
-    SkRect layer_bounds = kRenderBounds.makeInset(15, 15);
+    DlRect layer_bounds = kRenderBounds.Expand(-15, -15);
     RenderWith(testP, env, tolerance,
                CaseParameters(
                    "With prior save/clip/restore",
                    [=](const SkSetupContext& ctx) {
                      ctx.canvas->save();
-                     ctx.canvas->clipRect(clip, SkClipOp::kIntersect, false);
+                     ctx.canvas->clipRect(ToSkRect(clip), SkClipOp::kIntersect,
+                                          false);
                      SkPaint p2;
-                     ctx.canvas->drawRect(rect, p2);
+                     ctx.canvas->drawRect(ToSkRect(rect), p2);
                      p2.setBlendMode(SkBlendMode::kClear);
-                     ctx.canvas->drawRect(rect, p2);
+                     ctx.canvas->drawRect(ToSkRect(rect), p2);
                      ctx.canvas->restore();
                    },
                    [=](const DlSetupContext& ctx) {
@@ -1234,17 +1231,17 @@ class CanvasCompareTester {
                      ctx.canvas->saveLayer(nullptr, nullptr);
                    },
                    [=](const DlSetupContext& ctx) {
-                     ctx.canvas->SaveLayer(nullptr, nullptr);
+                     ctx.canvas->SaveLayer(std::nullopt, nullptr);
                    })
                    .with_restore(sk_safe_restore, dl_safe_restore, false));
     RenderWith(testP, env, tolerance,
                CaseParameters(
                    "saveLayer no paint, with bounds",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->saveLayer(layer_bounds, nullptr);
+                     ctx.canvas->saveLayer(ToSkRect(layer_bounds), nullptr);
                    },
                    [=](const DlSetupContext& ctx) {
-                     ctx.canvas->SaveLayer(&layer_bounds, nullptr);
+                     ctx.canvas->SaveLayer(layer_bounds, nullptr);
                    })
                    .with_restore(sk_safe_restore, dl_safe_restore, true));
     RenderWith(testP, env, tolerance,
@@ -1258,7 +1255,7 @@ class CanvasCompareTester {
                    [=](const DlSetupContext& ctx) {
                      DlPaint save_p;
                      save_p.setColor(alpha_layer_color);
-                     ctx.canvas->SaveLayer(nullptr, &save_p);
+                     ctx.canvas->SaveLayer(std::nullopt, &save_p);
                    })
                    .with_restore(sk_safe_restore, dl_safe_restore, true));
     RenderWith(testP, env, tolerance,
@@ -1272,7 +1269,7 @@ class CanvasCompareTester {
                    [=](const DlSetupContext& ctx) {
                      DlPaint save_p;
                      save_p.setColor(alpha_layer_color);
-                     ctx.canvas->SaveLayer(nullptr, &save_p);
+                     ctx.canvas->SaveLayer(std::nullopt, &save_p);
                    })
                    .with_restore(sk_opt_restore, dl_opt_restore, true, true));
     RenderWith(testP, env, tolerance,
@@ -1281,12 +1278,12 @@ class CanvasCompareTester {
                    [=](const SkSetupContext& ctx) {
                      SkPaint save_p;
                      save_p.setColor(ToSk(alpha_layer_color));
-                     ctx.canvas->saveLayer(layer_bounds, &save_p);
+                     ctx.canvas->saveLayer(ToSkRect(layer_bounds), &save_p);
                    },
                    [=](const DlSetupContext& ctx) {
                      DlPaint save_p;
                      save_p.setColor(alpha_layer_color);
-                     ctx.canvas->SaveLayer(&layer_bounds, &save_p);
+                     ctx.canvas->SaveLayer(layer_bounds, &save_p);
                    })
                    .with_restore(sk_safe_restore, dl_safe_restore, true));
     {
@@ -1323,57 +1320,59 @@ class CanvasCompareTester {
       DlBlurImageFilter dl_backdrop(5, 5, DlTileMode::kDecal);
       auto sk_backdrop =
           SkImageFilters::Blur(5, 5, SkTileMode::kDecal, nullptr);
-      RenderWith(testP, backdrop_env, tolerance,
-                 CaseParameters(
-                     "saveLayer with backdrop",
-                     [=](const SkSetupContext& ctx) {
-                       sk_backdrop_setup(ctx);
-                       ctx.canvas->saveLayer(SkCanvas::SaveLayerRec(
-                           nullptr, nullptr, sk_backdrop.get(),
-                           SkTileMode::kDecal, nullptr, 0));
-                       sk_content_setup(ctx);
-                     },
-                     [=](const DlSetupContext& ctx) {
-                       dl_backdrop_setup(ctx);
-                       ctx.canvas->SaveLayer(nullptr, nullptr, &dl_backdrop);
-                       dl_content_setup(ctx);
-                     })
-                     .with_restore(sk_safe_restore, dl_safe_restore, true));
+      RenderWith(
+          testP, backdrop_env, tolerance,
+          CaseParameters(
+              "saveLayer with backdrop",
+              [=](const SkSetupContext& ctx) {
+                sk_backdrop_setup(ctx);
+                ctx.canvas->saveLayer(
+                    SkCanvas::SaveLayerRec(nullptr, nullptr, sk_backdrop.get(),
+                                           SkTileMode::kDecal, nullptr, 0));
+                sk_content_setup(ctx);
+              },
+              [=](const DlSetupContext& ctx) {
+                dl_backdrop_setup(ctx);
+                ctx.canvas->SaveLayer(std::nullopt, nullptr, &dl_backdrop);
+                dl_content_setup(ctx);
+              })
+              .with_restore(sk_safe_restore, dl_safe_restore, true));
       RenderWith(testP, backdrop_env, tolerance,
                  CaseParameters(
                      "saveLayer with bounds and backdrop",
                      [=](const SkSetupContext& ctx) {
                        sk_backdrop_setup(ctx);
                        ctx.canvas->saveLayer(SkCanvas::SaveLayerRec(
-                           &layer_bounds, nullptr, sk_backdrop.get(),
+                           &ToSkRect(layer_bounds), nullptr, sk_backdrop.get(),
                            SkTileMode::kDecal, nullptr, 0));
                        sk_content_setup(ctx);
                      },
                      [=](const DlSetupContext& ctx) {
                        dl_backdrop_setup(ctx);
-                       ctx.canvas->SaveLayer(&layer_bounds, nullptr,
+                       ctx.canvas->SaveLayer(layer_bounds, nullptr,
                                              &dl_backdrop);
                        dl_content_setup(ctx);
                      })
                      .with_restore(sk_safe_restore, dl_safe_restore, true));
-      RenderWith(testP, backdrop_env, tolerance,
-                 CaseParameters(
-                     "clipped saveLayer with backdrop",
-                     [=](const SkSetupContext& ctx) {
-                       sk_backdrop_setup(ctx);
-                       ctx.canvas->clipRect(layer_bounds);
-                       ctx.canvas->saveLayer(SkCanvas::SaveLayerRec(
-                           nullptr, nullptr, sk_backdrop.get(),
-                           SkTileMode::kDecal, nullptr, 0));
-                       sk_content_setup(ctx);
-                     },
-                     [=](const DlSetupContext& ctx) {
-                       dl_backdrop_setup(ctx);
-                       ctx.canvas->ClipRect(layer_bounds);
-                       ctx.canvas->SaveLayer(nullptr, nullptr, &dl_backdrop);
-                       dl_content_setup(ctx);
-                     })
-                     .with_restore(sk_safe_restore, dl_safe_restore, true));
+      RenderWith(
+          testP, backdrop_env, tolerance,
+          CaseParameters(
+              "clipped saveLayer with backdrop",
+              [=](const SkSetupContext& ctx) {
+                sk_backdrop_setup(ctx);
+                ctx.canvas->clipRect(ToSkRect(layer_bounds));
+                ctx.canvas->saveLayer(
+                    SkCanvas::SaveLayerRec(nullptr, nullptr, sk_backdrop.get(),
+                                           SkTileMode::kDecal, nullptr, 0));
+                sk_content_setup(ctx);
+              },
+              [=](const DlSetupContext& ctx) {
+                dl_backdrop_setup(ctx);
+                ctx.canvas->ClipRect(layer_bounds);
+                ctx.canvas->SaveLayer(std::nullopt, nullptr, &dl_backdrop);
+                dl_content_setup(ctx);
+              })
+              .with_restore(sk_safe_restore, dl_safe_restore, true));
     }
 
     {
@@ -1402,7 +1401,7 @@ class CanvasCompareTester {
                        [=](const DlSetupContext& ctx) {
                          DlPaint save_p;
                          save_p.setColorFilter(dl_alpha_rotate_filter);
-                         ctx.canvas->SaveLayer(nullptr, &save_p);
+                         ctx.canvas->SaveLayer(std::nullopt, &save_p);
                          ctx.paint.setStrokeWidth(5.0);
                        })
                        .with_restore(sk_safe_restore, dl_safe_restore, true));
@@ -1414,13 +1413,14 @@ class CanvasCompareTester {
                        [=](const SkSetupContext& ctx) {
                          SkPaint save_p;
                          save_p.setColorFilter(sk_alpha_rotate_filter);
-                         ctx.canvas->saveLayer(kRenderBounds, &save_p);
+                         ctx.canvas->saveLayer(ToSkRect(kRenderBounds),
+                                               &save_p);
                          ctx.paint.setStrokeWidth(5.0);
                        },
                        [=](const DlSetupContext& ctx) {
                          DlPaint save_p;
                          save_p.setColorFilter(dl_alpha_rotate_filter);
-                         ctx.canvas->SaveLayer(&kRenderBounds, &save_p);
+                         ctx.canvas->SaveLayer(kRenderBounds, &save_p);
                          ctx.paint.setStrokeWidth(5.0);
                        })
                        .with_restore(sk_safe_restore, dl_safe_restore, true));
@@ -1453,7 +1453,7 @@ class CanvasCompareTester {
                        [=](const DlSetupContext& ctx) {
                          DlPaint save_p;
                          save_p.setImageFilter(dl_cf_image_filter);
-                         ctx.canvas->SaveLayer(nullptr, &save_p);
+                         ctx.canvas->SaveLayer(std::nullopt, &save_p);
                          ctx.paint.setStrokeWidth(5.0);
                        })
                        .with_restore(sk_safe_restore, dl_safe_restore, true));
@@ -1465,13 +1465,14 @@ class CanvasCompareTester {
                        [=](const SkSetupContext& ctx) {
                          SkPaint save_p;
                          save_p.setImageFilter(sk_cf_image_filter);
-                         ctx.canvas->saveLayer(kRenderBounds, &save_p);
+                         ctx.canvas->saveLayer(ToSkRect(kRenderBounds),
+                                               &save_p);
                          ctx.paint.setStrokeWidth(5.0);
                        },
                        [=](const DlSetupContext& ctx) {
                          DlPaint save_p;
                          save_p.setImageFilter(dl_cf_image_filter);
-                         ctx.canvas->SaveLayer(&kRenderBounds, &save_p);
+                         ctx.canvas->SaveLayer(kRenderBounds, &save_p);
                          ctx.paint.setStrokeWidth(5.0);
                        })
                        .with_restore(sk_safe_restore, dl_safe_restore, true));
@@ -1764,13 +1765,9 @@ class CanvasCompareTester {
     }
 
     {
-      SkPoint sk_end_points[] = {
-          SkPoint::Make(kRenderBounds.fLeft, kRenderBounds.fTop),
-          SkPoint::Make(kRenderBounds.fRight, kRenderBounds.fBottom),
-      };
       DlPoint dl_end_points[] = {
-          DlPoint(kRenderBounds.fLeft, kRenderBounds.fTop),
-          DlPoint(kRenderBounds.fRight, kRenderBounds.fBottom),
+          kRenderBounds.GetLeftTop(),
+          kRenderBounds.GetRightBottom(),
       };
       DlColor dl_colors[] = {
           DlColor::kGreen(),
@@ -1791,7 +1788,8 @@ class CanvasCompareTester {
           DlColorSource::MakeLinear(dl_end_points[0], dl_end_points[1], 3,
                                     dl_colors, stops, DlTileMode::kMirror);
       auto sk_gradient = SkGradientShader::MakeLinear(
-          sk_end_points, sk_colors, stops, 3, SkTileMode::kMirror, 0, nullptr);
+          ToSkPoints(dl_end_points), sk_colors, stops, 3, SkTileMode::kMirror,
+          0, nullptr);
       {
         RenderWith(testP, env, tolerance,
                    CaseParameters(
@@ -2025,33 +2023,83 @@ class CanvasCompareTester {
       // in calculation when we are comparing rendering with an alpha
       // to rendering opaque colors in the group opacity tests, for
       // example.
-      SkScalar tweak = 1.0 / 16.0;
-      SkMatrix tx = SkMatrix::MakeAll(1.0 + tweak, tweak, 5,   //
-                                      tweak, 1.0 + tweak, 10,  //
-                                      0, 0, 1);
+      DlScalar tweak = 1.0 / 16.0;
+      DlMatrix matrix = DlMatrix::MakeRow(
+          // clang-format off
+          1.0 + tweak, tweak,       0, 5,
+          tweak,       1.0 + tweak, 0, 10,
+          0, 0, 1, 0,
+          0, 0, 0, 1
+          // clang-format on
+      );
       RenderWith(  //
           testP, env, skewed_tolerance,
           CaseParameters(
-              "Transform 2D Affine",
-              [=](const SkSetupContext& ctx) { ctx.canvas->concat(tx); },
-              [=](const DlSetupContext& ctx) { ctx.canvas->Transform(tx); }));
+              "Transform 2D Affine Matrix",
+              [=](const SkSetupContext& ctx) {
+                ctx.canvas->concat(ToSkMatrix(matrix));
+              },
+              [=](const DlSetupContext& ctx) {
+                ctx.canvas->Transform(matrix);
+              }));
+      RenderWith(  //
+          testP, env, skewed_tolerance,
+          CaseParameters(
+              "Transform 2D Affine inline",
+              [=](const SkSetupContext& ctx) {
+                ctx.canvas->concat(SkMatrix::MakeAll(1.0 + tweak, tweak, 5,   //
+                                                     tweak, 1.0 + tweak, 10,  //
+                                                     0, 0, 1));
+              },
+              [=](const DlSetupContext& ctx) {
+                ctx.canvas->Transform2DAffine(1.0 + tweak, tweak, 5,  //
+                                              tweak, 1.0 + tweak, 10);
+              }));
     }
     {
-      SkM44 m44 = SkM44(1, 0, 0, kRenderCenterX,  //
-                        0, 1, 0, kRenderCenterY,  //
-                        0, 0, 1, 0,               //
-                        0, 0, .001, 1);
-      m44.preConcat(
-          SkM44::Rotate({1, 0, 0}, math::kPi / 60));  // 3 degrees around X
-      m44.preConcat(
-          SkM44::Rotate({0, 1, 0}, math::kPi / 45));  // 4 degrees around Y
-      m44.preTranslate(-kRenderCenterX, -kRenderCenterY);
+      DlMatrix matrix = DlMatrix::MakeRow(1.0f, 0.0f, 0.0f, kRenderCenterX,  //
+                                          0.0f, 1.0f, 0.0f, kRenderCenterY,  //
+                                          0.0f, 0.0f, 1.0f, 0.0f,            //
+                                          0.0f, 0.0f, .001f, 1.0f);
+      matrix = matrix * DlMatrix::MakeRotationX(DlDegrees(3));
+      matrix = matrix * DlMatrix::MakeRotationY(DlDegrees(4));
+      matrix = matrix.Translate({-kRenderCenterX, -kRenderCenterY, 0.0f});
       RenderWith(  //
           testP, env, skewed_tolerance,
           CaseParameters(
-              "Transform Full Perspective",
-              [=](const SkSetupContext& ctx) { ctx.canvas->concat(m44); },
-              [=](const DlSetupContext& ctx) { ctx.canvas->Transform(m44); }));
+              "Transform Full Perspective Matrix",
+              [=](const SkSetupContext& ctx) {
+                ctx.canvas->concat(ToSkM44(matrix));
+              },
+              [=](const DlSetupContext& ctx) {
+                ctx.canvas->Transform(matrix);
+              }));
+      RenderWith(  //
+          testP, env, skewed_tolerance,
+          CaseParameters(
+              "Transform Full Perspective inline",
+              [=](const SkSetupContext& ctx) {
+                ctx.canvas->concat(SkM44(
+                    // These values match what ends up in matrix above
+                    // clang-format off
+                     0.997564,   0.000000,   0.069756,   0.243591,
+                     0.003651,   0.998630,  -0.052208,  -0.228027,
+                    -0.069661,   0.052336,   0.996197,   1.732491,
+                    -0.000070,   0.000052,   0.000996,   1.001732
+                    // clang-format on
+                    ));
+              },
+              [=](const DlSetupContext& ctx) {
+                ctx.canvas->TransformFullPerspective(
+                    // These values match what ends up in matrix above
+                    // clang-format off
+                     0.997564,   0.000000,   0.069756,   0.243591,
+                     0.003651,   0.998630,  -0.052208,  -0.228027,
+                    -0.069661,   0.052336,   0.996197,   1.732491,
+                    -0.000070,   0.000052,   0.000996,   1.001732
+                    // clang-format on
+                );
+              }));
     }
   }
 
@@ -2066,14 +2114,15 @@ class CanvasCompareTester {
     // right features fully filling the clips based on the SW rounding. By
     // moving to a 15.4 inset, the edge of the clip is never on the "rounding
     // edge" of a pixel.
-    SkRect r_clip = kRenderBounds.makeInset(15.4, 15.4);
+    DlRect r_clip = kRenderBounds.Expand(-15.4, -15.4);
     BoundsTolerance intersect_tolerance = diff_tolerance.clip(r_clip);
     intersect_tolerance = intersect_tolerance.addPostClipPadding(1, 1);
     RenderWith(testP, env, intersect_tolerance,
                CaseParameters(
                    "Hard ClipRect inset by 15.4",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRect(r_clip, SkClipOp::kIntersect, false);
+                     ctx.canvas->clipRect(ToSkRect(r_clip),
+                                          SkClipOp::kIntersect, false);
                    },
                    [=](const DlSetupContext& ctx) {
                      ctx.canvas->ClipRect(r_clip, DlClipOp::kIntersect, false);
@@ -2082,7 +2131,8 @@ class CanvasCompareTester {
                CaseParameters(
                    "AntiAlias ClipRect inset by 15.4",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRect(r_clip, SkClipOp::kIntersect, true);
+                     ctx.canvas->clipRect(ToSkRect(r_clip),
+                                          SkClipOp::kIntersect, true);
                    },
                    [=](const DlSetupContext& ctx) {
                      ctx.canvas->ClipRect(r_clip, DlClipOp::kIntersect, true);
@@ -2091,20 +2141,20 @@ class CanvasCompareTester {
                CaseParameters(
                    "Hard ClipRect Diff, inset by 15.4",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRect(r_clip, SkClipOp::kDifference, false);
+                     ctx.canvas->clipRect(ToSkRect(r_clip),
+                                          SkClipOp::kDifference, false);
                    },
                    [=](const DlSetupContext& ctx) {
                      ctx.canvas->ClipRect(r_clip, DlClipOp::kDifference, false);
                    })
                    .with_diff_clip());
-    // Skia lacks clipOval and requires us to make an oval SkRRect
-    SkRRect rr_oval_clip = SkRRect::MakeOval(r_clip);
     RenderWith(testP, env, intersect_tolerance,
                CaseParameters(
                    "Hard ClipOval",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRRect(rr_oval_clip, SkClipOp::kIntersect,
-                                           false);
+                     // Skia lacks clipOval so we use an oval SkRRect
+                     ctx.canvas->clipRRect(SkRRect::MakeOval(ToSkRect(r_clip)),
+                                           SkClipOp::kIntersect, false);
                    },
                    [=](const DlSetupContext& ctx) {
                      ctx.canvas->ClipOval(r_clip, DlClipOp::kIntersect, false);
@@ -2113,8 +2163,9 @@ class CanvasCompareTester {
                CaseParameters(
                    "AntiAlias ClipOval",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRRect(rr_oval_clip, SkClipOp::kIntersect,
-                                           true);
+                     // Skia lacks clipOval so we use an oval SkRRect
+                     ctx.canvas->clipRRect(SkRRect::MakeOval(ToSkRect(r_clip)),
+                                           SkClipOp::kIntersect, true);
                    },
                    [=](const DlSetupContext& ctx) {
                      ctx.canvas->ClipOval(r_clip, DlClipOp::kIntersect, true);
@@ -2123,8 +2174,9 @@ class CanvasCompareTester {
                CaseParameters(
                    "Hard ClipOval Diff",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRRect(rr_oval_clip, SkClipOp::kDifference,
-                                           false);
+                     // Skia lacks clipOval so we use an oval SkRRect
+                     ctx.canvas->clipRRect(SkRRect::MakeOval(ToSkRect(r_clip)),
+                                           SkClipOp::kDifference, false);
                    },
                    [=](const DlSetupContext& ctx) {
                      ctx.canvas->ClipOval(r_clip, DlClipOp::kDifference, false);
@@ -2135,72 +2187,79 @@ class CanvasCompareTester {
     // bulges in the corners of the RRect which were interpreted as
     // "clip overruns" by the clip OOB pixel testing code. Using less
     // abusively small radii fixes the problem.
-    SkRRect rr_clip = SkRRect::MakeRectXY(r_clip, 9, 9);
-    RenderWith(
-        testP, env, intersect_tolerance,
-        CaseParameters(
-            "Hard ClipRRect with radius of 15.4",
-            [=](const SkSetupContext& ctx) {
-              ctx.canvas->clipRRect(rr_clip, SkClipOp::kIntersect, false);
-            },
-            [=](const DlSetupContext& ctx) {
-              ctx.canvas->ClipRRect(rr_clip, DlClipOp::kIntersect, false);
-            }));
+    DlRoundRect rr_clip = DlRoundRect::MakeRectXY(r_clip, 9, 9);
     RenderWith(testP, env, intersect_tolerance,
                CaseParameters(
-                   "AntiAlias ClipRRect with radius of 15.4",
+                   "Hard ClipRRect with radius of 9",
                    [=](const SkSetupContext& ctx) {
-                     ctx.canvas->clipRRect(rr_clip, SkClipOp::kIntersect, true);
+                     ctx.canvas->clipRRect(ToSkRRect(rr_clip),
+                                           SkClipOp::kIntersect, false);
                    },
                    [=](const DlSetupContext& ctx) {
-                     ctx.canvas->ClipRRect(rr_clip, DlClipOp::kIntersect, true);
+                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kIntersect,
+                                               false);
                    }));
-    RenderWith(
-        testP, env, diff_tolerance,
-        CaseParameters(
-            "Hard ClipRRect Diff, with radius of 15.4",
-            [=](const SkSetupContext& ctx) {
-              ctx.canvas->clipRRect(rr_clip, SkClipOp::kDifference, false);
-            },
-            [=](const DlSetupContext& ctx) {
-              ctx.canvas->ClipRRect(rr_clip, DlClipOp::kDifference, false);
-            })
-            .with_diff_clip());
-    SkPath path_clip = SkPath();
-    path_clip.setFillType(SkPathFillType::kEvenOdd);
-    path_clip.addRect(r_clip);
-    path_clip.addCircle(kRenderCenterX, kRenderCenterY, 1.0);
-    RenderWith(
-        testP, env, intersect_tolerance,
-        CaseParameters(
-            "Hard ClipPath inset by 15.4",
-            [=](const SkSetupContext& ctx) {
-              ctx.canvas->clipPath(path_clip, SkClipOp::kIntersect, false);
-            },
-            [=](const DlSetupContext& ctx) {
-              ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect, false);
-            }));
-    RenderWith(
-        testP, env, intersect_tolerance,
-        CaseParameters(
-            "AntiAlias ClipPath inset by 15.4",
-            [=](const SkSetupContext& ctx) {
-              ctx.canvas->clipPath(path_clip, SkClipOp::kIntersect, true);
-            },
-            [=](const DlSetupContext& ctx) {
-              ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect, true);
-            }));
-    RenderWith(
-        testP, env, diff_tolerance,
-        CaseParameters(
-            "Hard ClipPath Diff, inset by 15.4",
-            [=](const SkSetupContext& ctx) {
-              ctx.canvas->clipPath(path_clip, SkClipOp::kDifference, false);
-            },
-            [=](const DlSetupContext& ctx) {
-              ctx.canvas->ClipPath(path_clip, DlClipOp::kDifference, false);
-            })
-            .with_diff_clip());
+    RenderWith(testP, env, intersect_tolerance,
+               CaseParameters(
+                   "AntiAlias ClipRRect with radius of 9",
+                   [=](const SkSetupContext& ctx) {
+                     ctx.canvas->clipRRect(ToSkRRect(rr_clip),
+                                           SkClipOp::kIntersect, true);
+                   },
+                   [=](const DlSetupContext& ctx) {
+                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kIntersect,
+                                               true);
+                   }));
+    RenderWith(testP, env, diff_tolerance,
+               CaseParameters(
+                   "Hard ClipRRect Diff, with radius of 9",
+                   [=](const SkSetupContext& ctx) {
+                     ctx.canvas->clipRRect(ToSkRRect(rr_clip),
+                                           SkClipOp::kDifference, false);
+                   },
+                   [=](const DlSetupContext& ctx) {
+                     ctx.canvas->ClipRoundRect(rr_clip, DlClipOp::kDifference,
+                                               false);
+                   })
+                   .with_diff_clip());
+    DlPathBuilder path_builder;
+    path_builder.AddRect(r_clip);
+    path_builder.AddCircle(DlPoint(kRenderCenterX, kRenderCenterY), 1.0f);
+    DlPath path_clip(path_builder, DlPathFillType::kOdd);
+    RenderWith(testP, env, intersect_tolerance,
+               CaseParameters(
+                   "Hard ClipPath inset by 15.4",
+                   [=](const SkSetupContext& ctx) {
+                     ctx.canvas->clipPath(path_clip.GetSkPath(),
+                                          SkClipOp::kIntersect, false);
+                   },
+                   [=](const DlSetupContext& ctx) {
+                     ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect,
+                                          false);
+                   }));
+    RenderWith(testP, env, intersect_tolerance,
+               CaseParameters(
+                   "AntiAlias ClipPath inset by 15.4",
+                   [=](const SkSetupContext& ctx) {
+                     ctx.canvas->clipPath(path_clip.GetSkPath(),
+                                          SkClipOp::kIntersect, true);
+                   },
+                   [=](const DlSetupContext& ctx) {
+                     ctx.canvas->ClipPath(path_clip, DlClipOp::kIntersect,
+                                          true);
+                   }));
+    RenderWith(testP, env, diff_tolerance,
+               CaseParameters(
+                   "Hard ClipPath Diff, inset by 15.4",
+                   [=](const SkSetupContext& ctx) {
+                     ctx.canvas->clipPath(path_clip.GetSkPath(),
+                                          SkClipOp::kDifference, false);
+                   },
+                   [=](const DlSetupContext& ctx) {
+                     ctx.canvas->ClipPath(path_clip, DlClipOp::kDifference,
+                                          false);
+                   })
+                   .with_diff_clip());
   }
 
   enum class DirectoryStatus {
@@ -2301,7 +2360,9 @@ class CanvasCompareTester {
                          env.dl_image());
     auto dl_result = env.getResult(base_info, dl_job);
 
-    EXPECT_EQ(sk_job.setup_matrix(), dl_job.setup_matrix());
+    if (sk_job.setup_matrix() != dl_job.setup_matrix()) {
+      EXPECT_EQ(sk_job.setup_matrix(), dl_job.setup_matrix());
+    }
     EXPECT_EQ(sk_job.setup_clip_bounds(), dl_job.setup_clip_bounds());
     ASSERT_EQ(sk_result->width(), kTestWidth) << info;
     ASSERT_EQ(sk_result->height(), kTestHeight) << info;
@@ -2313,7 +2374,7 @@ class CanvasCompareTester {
     const sk_sp<SkPicture> sk_picture = sk_job.MakePicture(base_info);
     const sk_sp<DisplayList> display_list = dl_job.MakeDisplayList(base_info);
 
-    SkRect sk_bounds = sk_picture->cullRect();
+    DlRect sk_bounds = ToDlRect(sk_picture->cullRect());
     checkPixels(sk_result.get(), sk_bounds, info + " (Skia reference)", bg);
 
     if (testP.should_match(env, caseP, dl_job.setup_paint(), dl_job)) {
@@ -2368,20 +2429,17 @@ class CanvasCompareTester {
                             info + " (DlCanvas output matches SkCanvas)");
 
     {
-      SkRect dl_bounds = display_list->bounds();
-      if (!sk_bounds.roundOut().contains(dl_bounds)) {
+      DlRect dl_bounds = display_list->GetBounds();
+      DlRect sk_padded_bounds = DlRect::RoundOut(sk_bounds);
+      if (!sk_padded_bounds.Contains(dl_bounds)) {
         FML_LOG(ERROR) << "For " << info;
-        FML_LOG(ERROR) << "sk ref: "  //
-                       << sk_bounds.fLeft << ", " << sk_bounds.fTop << " => "
-                       << sk_bounds.fRight << ", " << sk_bounds.fBottom;
-        FML_LOG(ERROR) << "dl: "  //
-                       << dl_bounds.fLeft << ", " << dl_bounds.fTop << " => "
-                       << dl_bounds.fRight << ", " << dl_bounds.fBottom;
-        if (!dl_bounds.contains(sk_bounds)) {
+        FML_LOG(ERROR) << "sk ref: " << sk_bounds;
+        FML_LOG(ERROR) << "dl: " << dl_bounds;
+        if (!dl_bounds.Contains(sk_bounds)) {
           FML_LOG(ERROR) << "DisplayList bounds are too small!";
         }
-        if (!dl_bounds.isEmpty() &&
-            !sk_bounds.roundOut().contains(dl_bounds.roundOut())) {
+        if (!dl_bounds.IsEmpty() &&
+            !sk_padded_bounds.Contains(DlRect::RoundOut(dl_bounds))) {
           FML_LOG(ERROR) << "###### DisplayList bounds larger than reference!";
         }
       }
@@ -2438,7 +2496,7 @@ class CanvasCompareTester {
       // recording time and rendering time.
       const int test_width_2 = kTestWidth * 2;
       const int test_height_2 = kTestHeight * 2;
-      const SkScalar test_scale = 2.0;
+      const DlScalar test_scale = 2.0;
 
       SkPictureJobRenderer sk_job_x2(sk_picture);
       RenderJobInfo info_2x = {
@@ -2487,7 +2545,7 @@ class CanvasCompareTester {
                                 const RenderResult* ref_result,
                                 const std::string& info,
                                 DlColor bg) {
-    SkScalar opacity = 128.0 / 255.0;
+    DlScalar opacity = 128.0 / 255.0;
 
     DisplayListJobRenderer opacity_job(display_list);
     RenderJobInfo opacity_info = {
@@ -2525,7 +2583,7 @@ class CanvasCompareTester {
           for (int i = 0; i < 32; i += 8) {
             int ref_comp = (ref_pixel >> i) & 0xff;
             int bg_comp = (bg.argb() >> i) & 0xff;
-            SkScalar faded_comp = bg_comp + (ref_comp - bg_comp) * opacity;
+            DlScalar faded_comp = bg_comp + (ref_comp - bg_comp) * opacity;
             int test_comp = (test_pixel >> i) & 0xff;
             if (std::abs(faded_comp - test_comp) > fudge) {
               int diff = std::abs(faded_comp - test_comp);
@@ -2547,13 +2605,13 @@ class CanvasCompareTester {
   }
 
   static bool checkPixels(const RenderResult* ref_result,
-                          const SkRect ref_bounds,
+                          const DlRect ref_bounds,
                           const std::string& info,
                           const DlColor bg = DlColor::kTransparent()) {
     uint32_t untouched = PremultipliedArgb(bg);
     int pixels_touched = 0;
     int pixels_oob = 0;
-    SkIRect i_bounds = ref_bounds.roundOut();
+    DlIRect i_bounds = DlIRect::RoundOut(ref_bounds);
     EXPECT_EQ(ref_result->width(), kTestWidth) << info;
     EXPECT_EQ(ref_result->height(), kTestWidth) << info;
     for (int y = 0; y < kTestHeight; y++) {
@@ -2561,7 +2619,7 @@ class CanvasCompareTester {
       for (int x = 0; x < kTestWidth; x++) {
         if (ref_row[x] != untouched) {
           pixels_touched++;
-          if (!i_bounds.contains(x, y)) {
+          if (!i_bounds.Contains({x, y})) {
             pixels_oob++;
           }
         }
@@ -2628,7 +2686,7 @@ class CanvasCompareTester {
   static void compareToReference(const RenderResult* test_result,
                                  const RenderResult* ref_result,
                                  const std::string& info,
-                                 const SkRect* bounds,
+                                 const DlRect* bounds,
                                  const BoundsTolerance* tolerance,
                                  const DlColor bg,
                                  bool fuzzyCompares = false,
@@ -2638,8 +2696,8 @@ class CanvasCompareTester {
     uint32_t untouched = PremultipliedArgb(bg);
     ASSERT_EQ(test_result->width(), width) << info;
     ASSERT_EQ(test_result->height(), height) << info;
-    SkIRect i_bounds =
-        bounds ? bounds->roundOut() : SkIRect::MakeWH(width, height);
+    DlIRect i_bounds =
+        bounds ? DlIRect::RoundOut(*bounds) : DlIRect::MakeWH(width, height);
 
     int pixels_different = 0;
     int pixels_oob = 0;
@@ -2664,7 +2722,7 @@ class CanvasCompareTester {
           if (max_y <= y) {
             max_y = y + 1;
           }
-          if (!i_bounds.contains(x, y)) {
+          if (!i_bounds.Contains({x, y})) {
             pixels_oob++;
           }
         }
@@ -2681,14 +2739,10 @@ class CanvasCompareTester {
       }
     }
     if (pixels_oob > 0) {
-      FML_LOG(ERROR) << "pix bounds["  //
-                     << min_x << ", " << min_y << " => " << max_x << ", "
-                     << max_y << "]";
-      FML_LOG(ERROR) << "dl_bounds["                               //
-                     << bounds->fLeft << ", " << bounds->fTop      //
-                     << " => "                                     //
-                     << bounds->fRight << ", " << bounds->fBottom  //
+      FML_LOG(ERROR) << "pix bounds["
+                     << DlIRect::MakeLTRB(min_x, min_y, max_x, max_y)  //
                      << "]";
+      FML_LOG(ERROR) << "dl_bounds[" << bounds << "]";
     } else if (bounds) {
       showBoundsOverflow(info, i_bounds, tolerance, min_x, min_y, max_x, max_y);
     }
@@ -2697,21 +2751,21 @@ class CanvasCompareTester {
   }
 
   static void showBoundsOverflow(const std::string& info,
-                                 SkIRect& bounds,
+                                 DlIRect& bounds,
                                  const BoundsTolerance* tolerance,
                                  int pixLeft,
                                  int pixTop,
                                  int pixRight,
                                  int pixBottom) {
-    int pad_left = std::max(0, pixLeft - bounds.fLeft);
-    int pad_top = std::max(0, pixTop - bounds.fTop);
-    int pad_right = std::max(0, bounds.fRight - pixRight);
-    int pad_bottom = std::max(0, bounds.fBottom - pixBottom);
-    SkIRect pix_bounds =
-        SkIRect::MakeLTRB(pixLeft, pixTop, pixRight, pixBottom);
-    SkISize pix_size = pix_bounds.size();
-    int pix_width = pix_size.width();
-    int pix_height = pix_size.height();
+    int pad_left = std::max(0, pixLeft - bounds.GetLeft());
+    int pad_top = std::max(0, pixTop - bounds.GetTop());
+    int pad_right = std::max(0, bounds.GetRight() - pixRight);
+    int pad_bottom = std::max(0, bounds.GetBottom() - pixBottom);
+    DlIRect pix_bounds =
+        DlIRect::MakeLTRB(pixLeft, pixTop, pixRight, pixBottom);
+    DlISize pix_size = pix_bounds.GetSize();
+    int pix_width = pix_size.width;
+    int pix_height = pix_size.height;
     int worst_pad_x = std::max(pad_left, pad_right);
     int worst_pad_y = std::max(pad_top, pad_bottom);
     if (tolerance->overflows(pix_bounds, worst_pad_x, worst_pad_y)) {
@@ -2720,17 +2774,13 @@ class CanvasCompareTester {
                      << pixLeft << ", " << pixTop << " => "  //
                      << pixRight << ", " << pixBottom        //
                      << "]";
-      FML_LOG(ERROR) << "dl_bounds["                             //
-                     << bounds.fLeft << ", " << bounds.fTop      //
-                     << " => "                                   //
-                     << bounds.fRight << ", " << bounds.fBottom  //
-                     << "]";
+      FML_LOG(ERROR) << "dl_bounds[" << bounds << "]";
       FML_LOG(ERROR) << "Bounds overly conservative by up to "     //
                      << worst_pad_x << ", " << worst_pad_y         //
                      << " (" << (worst_pad_x * 100.0 / pix_width)  //
                      << "%, " << (worst_pad_y * 100.0 / pix_height) << "%)";
-      int pix_area = pix_size.area();
-      int dl_area = bounds.width() * bounds.height();
+      int pix_area = pix_size.Area();
+      int dl_area = bounds.Area();
       FML_LOG(ERROR) << "Total overflow area: " << (dl_area - pix_area)  //
                      << " (+" << (dl_area * 100.0 / pix_area - 100.0)    //
                      << "% larger)";
@@ -2739,7 +2789,7 @@ class CanvasCompareTester {
   }
 
   static sk_sp<SkTextBlob> MakeTextBlob(const std::string& string,
-                                        SkScalar font_height) {
+                                        DlScalar font_height) {
     SkFont font = CreateTestFontOfSize(font_height);
     sk_sp<SkTypeface> face = font.refTypeface();
     FML_CHECK(face);
@@ -2903,18 +2953,18 @@ TEST_F(DisplayListRendering, DrawAlphaColor) {
 }
 
 TEST_F(DisplayListRendering, DrawDiagonalLines) {
-  SkPoint p1 = SkPoint::Make(kRenderLeft, kRenderTop);
-  SkPoint p2 = SkPoint::Make(kRenderRight, kRenderBottom);
-  SkPoint p3 = SkPoint::Make(kRenderLeft, kRenderBottom);
-  SkPoint p4 = SkPoint::Make(kRenderRight, kRenderTop);
+  DlPoint p1 = DlPoint(kRenderLeft, kRenderTop);
+  DlPoint p2 = DlPoint(kRenderRight, kRenderBottom);
+  DlPoint p3 = DlPoint(kRenderLeft, kRenderBottom);
+  DlPoint p4 = DlPoint(kRenderRight, kRenderTop);
   // Adding some edge to edge diagonals that run through the points about
   // 16 units in from the center of that edge.
   // Adding some edge center to edge center diagonals to better fill
   // out the RRect Clip so bounds checking sees less empty bounds space.
-  SkPoint p5 = SkPoint::Make(kRenderCenterX, kRenderTop + 15);
-  SkPoint p6 = SkPoint::Make(kRenderRight - 15, kRenderCenterY);
-  SkPoint p7 = SkPoint::Make(kRenderCenterX, kRenderBottom - 15);
-  SkPoint p8 = SkPoint::Make(kRenderLeft + 15, kRenderCenterY);
+  DlPoint p5 = DlPoint(kRenderCenterX, kRenderTop + 15);
+  DlPoint p6 = DlPoint(kRenderRight - 15, kRenderCenterY);
+  DlPoint p7 = DlPoint(kRenderCenterX, kRenderBottom - 15);
+  DlPoint p8 = DlPoint(kRenderLeft + 15, kRenderCenterY);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
@@ -2924,10 +2974,10 @@ TEST_F(DisplayListRendering, DrawDiagonalLines) {
             // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
-            ctx.canvas->drawLine(p1, p2, p);
-            ctx.canvas->drawLine(p3, p4, p);
-            ctx.canvas->drawLine(p5, p6, p);
-            ctx.canvas->drawLine(p7, p8, p);
+            ctx.canvas->drawLine(ToSkPoint(p1), ToSkPoint(p2), p);
+            ctx.canvas->drawLine(ToSkPoint(p3), ToSkPoint(p4), p);
+            ctx.canvas->drawLine(ToSkPoint(p5), ToSkPoint(p6), p);
+            ctx.canvas->drawLine(ToSkPoint(p7), ToSkPoint(p8), p);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawLine(p1, p2, ctx.paint);
@@ -2940,12 +2990,12 @@ TEST_F(DisplayListRendering, DrawDiagonalLines) {
 }
 
 TEST_F(DisplayListRendering, DrawHorizontalLines) {
-  SkPoint p1 = SkPoint::Make(kRenderLeft, kRenderTop + 16);
-  SkPoint p2 = SkPoint::Make(kRenderRight, kRenderTop + 16);
-  SkPoint p3 = SkPoint::Make(kRenderLeft, kRenderCenterY);
-  SkPoint p4 = SkPoint::Make(kRenderRight, kRenderCenterY);
-  SkPoint p5 = SkPoint::Make(kRenderLeft, kRenderBottom - 16);
-  SkPoint p6 = SkPoint::Make(kRenderRight, kRenderBottom - 16);
+  DlPoint p1 = DlPoint(kRenderLeft, kRenderTop + 16);
+  DlPoint p2 = DlPoint(kRenderRight, kRenderTop + 16);
+  DlPoint p3 = DlPoint(kRenderLeft, kRenderCenterY);
+  DlPoint p4 = DlPoint(kRenderRight, kRenderCenterY);
+  DlPoint p5 = DlPoint(kRenderLeft, kRenderBottom - 16);
+  DlPoint p6 = DlPoint(kRenderRight, kRenderBottom - 16);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
@@ -2955,9 +3005,9 @@ TEST_F(DisplayListRendering, DrawHorizontalLines) {
             // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
-            ctx.canvas->drawLine(p1, p2, p);
-            ctx.canvas->drawLine(p3, p4, p);
-            ctx.canvas->drawLine(p5, p6, p);
+            ctx.canvas->drawLine(ToSkPoint(p1), ToSkPoint(p2), p);
+            ctx.canvas->drawLine(ToSkPoint(p3), ToSkPoint(p4), p);
+            ctx.canvas->drawLine(ToSkPoint(p5), ToSkPoint(p6), p);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawLine(p1, p2, ctx.paint);
@@ -2970,12 +3020,12 @@ TEST_F(DisplayListRendering, DrawHorizontalLines) {
 }
 
 TEST_F(DisplayListRendering, DrawVerticalLines) {
-  SkPoint p1 = SkPoint::Make(kRenderLeft + 16, kRenderTop);
-  SkPoint p2 = SkPoint::Make(kRenderLeft + 16, kRenderBottom);
-  SkPoint p3 = SkPoint::Make(kRenderCenterX, kRenderTop);
-  SkPoint p4 = SkPoint::Make(kRenderCenterX, kRenderBottom);
-  SkPoint p5 = SkPoint::Make(kRenderRight - 16, kRenderTop);
-  SkPoint p6 = SkPoint::Make(kRenderRight - 16, kRenderBottom);
+  DlPoint p1 = DlPoint(kRenderLeft + 16, kRenderTop);
+  DlPoint p2 = DlPoint(kRenderLeft + 16, kRenderBottom);
+  DlPoint p3 = DlPoint(kRenderCenterX, kRenderTop);
+  DlPoint p4 = DlPoint(kRenderCenterX, kRenderBottom);
+  DlPoint p5 = DlPoint(kRenderRight - 16, kRenderTop);
+  DlPoint p6 = DlPoint(kRenderRight - 16, kRenderBottom);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
@@ -2985,9 +3035,9 @@ TEST_F(DisplayListRendering, DrawVerticalLines) {
             // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
-            ctx.canvas->drawLine(p1, p2, p);
-            ctx.canvas->drawLine(p3, p4, p);
-            ctx.canvas->drawLine(p5, p6, p);
+            ctx.canvas->drawLine(ToSkPoint(p1), ToSkPoint(p2), p);
+            ctx.canvas->drawLine(ToSkPoint(p3), ToSkPoint(p4), p);
+            ctx.canvas->drawLine(ToSkPoint(p5), ToSkPoint(p6), p);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawLine(p1, p2, ctx.paint);
@@ -3000,18 +3050,18 @@ TEST_F(DisplayListRendering, DrawVerticalLines) {
 }
 
 TEST_F(DisplayListRendering, DrawDiagonalDashedLines) {
-  SkPoint p1 = SkPoint::Make(kRenderLeft, kRenderTop);
-  SkPoint p2 = SkPoint::Make(kRenderRight, kRenderBottom);
-  SkPoint p3 = SkPoint::Make(kRenderLeft, kRenderBottom);
-  SkPoint p4 = SkPoint::Make(kRenderRight, kRenderTop);
+  DlPoint p1 = DlPoint(kRenderLeft, kRenderTop);
+  DlPoint p2 = DlPoint(kRenderRight, kRenderBottom);
+  DlPoint p3 = DlPoint(kRenderLeft, kRenderBottom);
+  DlPoint p4 = DlPoint(kRenderRight, kRenderTop);
   // Adding some edge to edge diagonals that run through the points about
   // 16 units in from the center of that edge.
   // Adding some edge center to edge center diagonals to better fill
   // out the RRect Clip so bounds checking sees less empty bounds space.
-  SkPoint p5 = SkPoint::Make(kRenderCenterX, kRenderTop + 15);
-  SkPoint p6 = SkPoint::Make(kRenderRight - 15, kRenderCenterY);
-  SkPoint p7 = SkPoint::Make(kRenderCenterX, kRenderBottom - 15);
-  SkPoint p8 = SkPoint::Make(kRenderLeft + 15, kRenderCenterY);
+  DlPoint p5 = DlPoint(kRenderCenterX, kRenderTop + 15);
+  DlPoint p6 = DlPoint(kRenderRight - 15, kRenderCenterY);
+  DlPoint p7 = DlPoint(kRenderCenterX, kRenderBottom - 15);
+  DlPoint p8 = DlPoint(kRenderLeft + 15, kRenderCenterY);
 
   // Full diagonals are 100x100 which are 140 in length
   // Dashing them with 25 on, 5 off means that the last
@@ -3031,22 +3081,18 @@ TEST_F(DisplayListRendering, DrawDiagonalDashedLines) {
             // See https://bugs.chromium.org/p/skia/issues/detail?id=12446
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
-            SkScalar intervals[2] = {25.0f, 5.0f};
+            DlScalar intervals[2] = {25.0f, 5.0f};
             p.setPathEffect(SkDashPathEffect::Make(intervals, 2, 0.0f));
-            ctx.canvas->drawLine(p1, p2, p);
-            ctx.canvas->drawLine(p3, p4, p);
-            ctx.canvas->drawLine(p5, p6, p);
-            ctx.canvas->drawLine(p7, p8, p);
+            ctx.canvas->drawLine(ToSkPoint(p1), ToSkPoint(p2), p);
+            ctx.canvas->drawLine(ToSkPoint(p3), ToSkPoint(p4), p);
+            ctx.canvas->drawLine(ToSkPoint(p5), ToSkPoint(p6), p);
+            ctx.canvas->drawLine(ToSkPoint(p7), ToSkPoint(p8), p);
           },
-          [=](const DlRenderContext& ctx) {                           //
-            ctx.canvas->DrawDashedLine(ToDlPoint(p1), ToDlPoint(p2),  //
-                                       25.0f, 5.0f, ctx.paint);
-            ctx.canvas->DrawDashedLine(ToDlPoint(p3), ToDlPoint(p4),  //
-                                       25.0f, 5.0f, ctx.paint);
-            ctx.canvas->DrawDashedLine(ToDlPoint(p5), ToDlPoint(p6),  //
-                                       25.0f, 5.0f, ctx.paint);
-            ctx.canvas->DrawDashedLine(ToDlPoint(p7), ToDlPoint(p8),  //
-                                       25.0f, 5.0f, ctx.paint);
+          [=](const DlRenderContext& ctx) {  //
+            ctx.canvas->DrawDashedLine(p1, p2, 25.0f, 5.0f, ctx.paint);
+            ctx.canvas->DrawDashedLine(p3, p4, 25.0f, 5.0f, ctx.paint);
+            ctx.canvas->DrawDashedLine(p5, p6, 25.0f, 5.0f, ctx.paint);
+            ctx.canvas->DrawDashedLine(p7, p8, 25.0f, 5.0f, ctx.paint);
           },
           kDrawLineFlags)
           .set_draw_line());
@@ -3054,24 +3100,26 @@ TEST_F(DisplayListRendering, DrawDiagonalDashedLines) {
 
 TEST_F(DisplayListRendering, DrawRect) {
   // Bounds are offset by 0.5 pixels to induce AA
+  DlRect rect = kRenderBounds.Shift(0.5f, 0.5f);
+
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawRect(kRenderBounds.makeOffset(0.5, 0.5), ctx.paint);
+            ctx.canvas->drawRect(ToSkRect(rect), ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
-            ctx.canvas->DrawRect(kRenderBounds.makeOffset(0.5, 0.5), ctx.paint);
+            ctx.canvas->DrawRect(rect, ctx.paint);
           },
           kDrawRectFlags));
 }
 
 TEST_F(DisplayListRendering, DrawOval) {
-  SkRect rect = kRenderBounds.makeInset(0, 10);
+  DlRect rect = kRenderBounds.Expand(0, -10);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawOval(rect, ctx.paint);
+            ctx.canvas->drawOval(ToSkRect(rect), ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawOval(rect, ctx.paint);
@@ -3080,75 +3128,85 @@ TEST_F(DisplayListRendering, DrawOval) {
 }
 
 TEST_F(DisplayListRendering, DrawCircle) {
+  DlPoint center = kRenderBounds.GetCenter();
+
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawCircle(kTestCenter, kRenderRadius, ctx.paint);
+            ctx.canvas->drawCircle(ToSkPoint(center), kRenderRadius, ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
-            ctx.canvas->DrawCircle(kTestCenter, kRenderRadius, ctx.paint);
+            ctx.canvas->DrawCircle(center, kRenderRadius, ctx.paint);
           },
           kDrawCircleFlags));
 }
 
-TEST_F(DisplayListRendering, DrawRRect) {
-  SkRRect rrect = SkRRect::MakeRectXY(kRenderBounds, kRenderCornerRadius,
-                                      kRenderCornerRadius);
+TEST_F(DisplayListRendering, DrawRoundRect) {
+  DlRoundRect rrect = DlRoundRect::MakeRectXY(kRenderBounds,        //
+                                              kRenderCornerRadius,  //
+                                              kRenderCornerRadius);
+
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawRRect(rrect, ctx.paint);
+            ctx.canvas->drawRRect(ToSkRRect(rrect), ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
-            ctx.canvas->DrawRRect(rrect, ctx.paint);
+            ctx.canvas->DrawRoundRect(rrect, ctx.paint);
           },
           kDrawRRectFlags));
 }
 
-TEST_F(DisplayListRendering, DrawDRRect) {
-  SkRRect outer = SkRRect::MakeRectXY(kRenderBounds, kRenderCornerRadius,
-                                      kRenderCornerRadius);
-  SkRect inner_bounds = kRenderBounds.makeInset(30.0, 30.0);
-  SkRRect inner = SkRRect::MakeRectXY(inner_bounds, kRenderCornerRadius,
-                                      kRenderCornerRadius);
+TEST_F(DisplayListRendering, DrawDiffRoundRect) {
+  DlRoundRect outer = DlRoundRect::MakeRectXY(kRenderBounds,        //
+                                              kRenderCornerRadius,  //
+                                              kRenderCornerRadius);
+  DlRect inner_bounds = kRenderBounds.Expand(-30.0f, -30.0f);
+  DlRoundRect inner = DlRoundRect::MakeRectXY(inner_bounds,         //
+                                              kRenderCornerRadius,  //
+                                              kRenderCornerRadius);
+
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawDRRect(outer, inner, ctx.paint);
+            ctx.canvas->drawDRRect(ToSkRRect(outer), ToSkRRect(inner),
+                                   ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
-            ctx.canvas->DrawDRRect(outer, inner, ctx.paint);
+            ctx.canvas->DrawDiffRoundRect(outer, inner, ctx.paint);
           },
           kDrawDRRectFlags));
 }
 
 TEST_F(DisplayListRendering, DrawPath) {
-  SkPath path;
+  DlPathBuilder path_builder;
 
   // unclosed lines to show some caps
-  path.moveTo(kRenderLeft + 15, kRenderTop + 15);
-  path.lineTo(kRenderRight - 15, kRenderBottom - 15);
-  path.moveTo(kRenderLeft + 15, kRenderBottom - 15);
-  path.lineTo(kRenderRight - 15, kRenderTop + 15);
+  path_builder.MoveTo(DlPoint(kRenderLeft + 15, kRenderTop + 15));
+  path_builder.LineTo(DlPoint(kRenderRight - 15, kRenderBottom - 15));
+  path_builder.MoveTo(DlPoint(kRenderLeft + 15, kRenderBottom - 15));
+  path_builder.LineTo(DlPoint(kRenderRight - 15, kRenderTop + 15));
 
-  path.addRect(kRenderBounds);
+  path_builder.AddRect(kRenderBounds);
 
   // miter diamonds horizontally and vertically to show miters
-  path.moveTo(kVerticalMiterDiamondPoints[0]);
+  path_builder.MoveTo(kVerticalMiterDiamondPoints[0]);
   for (int i = 1; i < kVerticalMiterDiamondPointCount; i++) {
-    path.lineTo(kVerticalMiterDiamondPoints[i]);
+    path_builder.LineTo(kVerticalMiterDiamondPoints[i]);
   }
-  path.close();
-  path.moveTo(kHorizontalMiterDiamondPoints[0]);
+  path_builder.Close();
+  path_builder.MoveTo(kHorizontalMiterDiamondPoints[0]);
   for (int i = 1; i < kHorizontalMiterDiamondPointCount; i++) {
-    path.lineTo(kHorizontalMiterDiamondPoints[i]);
+    path_builder.LineTo(kHorizontalMiterDiamondPoints[i]);
   }
-  path.close();
+  path_builder.Close();
+
+  DlPath path = DlPath(path_builder);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawPath(path, ctx.paint);
+            ctx.canvas->drawPath(path.GetSkPath(), ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawPath(path, ctx.paint);
@@ -3161,7 +3219,8 @@ TEST_F(DisplayListRendering, DrawArc) {
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawArc(kRenderBounds, 60, 330, false, ctx.paint);
+            ctx.canvas->drawArc(ToSkRect(kRenderBounds), 60, 330, false,
+                                ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawArc(kRenderBounds, 60, 330, false, ctx.paint);
@@ -3183,7 +3242,8 @@ TEST_F(DisplayListRendering, DrawArcCenter) {
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            ctx.canvas->drawArc(kRenderBounds, 60, 360 - 12, true, ctx.paint);
+            ctx.canvas->drawArc(ToSkRect(kRenderBounds), 60, 360 - 12, true,
+                                ctx.paint);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawArc(kRenderBounds, 60, 360 - 12, true, ctx.paint);
@@ -3196,24 +3256,24 @@ TEST_F(DisplayListRendering, DrawPointsAsPoints) {
   // The +/- 16 points are designed to fall just inside the clips
   // that are tested against so we avoid lots of undrawn pixels
   // in the accumulated bounds.
-  const SkScalar x0 = kRenderLeft;
-  const SkScalar x1 = kRenderLeft + 16;
-  const SkScalar x2 = (kRenderLeft + kRenderCenterX) * 0.5;
-  const SkScalar x3 = kRenderCenterX + 0.1;
-  const SkScalar x4 = (kRenderRight + kRenderCenterX) * 0.5;
-  const SkScalar x5 = kRenderRight - 16;
-  const SkScalar x6 = kRenderRight - 1;
+  const DlScalar x0 = kRenderLeft;
+  const DlScalar x1 = kRenderLeft + 16;
+  const DlScalar x2 = (kRenderLeft + kRenderCenterX) * 0.5;
+  const DlScalar x3 = kRenderCenterX + 0.1;
+  const DlScalar x4 = (kRenderRight + kRenderCenterX) * 0.5;
+  const DlScalar x5 = kRenderRight - 16;
+  const DlScalar x6 = kRenderRight - 1;
 
-  const SkScalar y0 = kRenderTop;
-  const SkScalar y1 = kRenderTop + 16;
-  const SkScalar y2 = (kRenderTop + kRenderCenterY) * 0.5;
-  const SkScalar y3 = kRenderCenterY + 0.1;
-  const SkScalar y4 = (kRenderBottom + kRenderCenterY) * 0.5;
-  const SkScalar y5 = kRenderBottom - 16;
-  const SkScalar y6 = kRenderBottom - 1;
+  const DlScalar y0 = kRenderTop;
+  const DlScalar y1 = kRenderTop + 16;
+  const DlScalar y2 = (kRenderTop + kRenderCenterY) * 0.5;
+  const DlScalar y3 = kRenderCenterY + 0.1;
+  const DlScalar y4 = (kRenderBottom + kRenderCenterY) * 0.5;
+  const DlScalar y5 = kRenderBottom - 16;
+  const DlScalar y6 = kRenderBottom - 1;
 
   // clang-format off
-  const SkPoint points[] = {
+  const DlPoint points[] = {
       {x0, y0}, {x1, y0}, {x2, y0}, {x3, y0}, {x4, y0}, {x5, y0}, {x6, y0},
       {x0, y1}, {x1, y1}, {x2, y1}, {x3, y1}, {x4, y1}, {x5, y1}, {x6, y1},
       {x0, y2}, {x1, y2}, {x2, y2}, {x3, y2}, {x4, y2}, {x5, y2}, {x6, y2},
@@ -3234,7 +3294,7 @@ TEST_F(DisplayListRendering, DrawPointsAsPoints) {
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
             auto mode = SkCanvas::kPoints_PointMode;
-            ctx.canvas->drawPoints(mode, count, points, p);
+            ctx.canvas->drawPoints(mode, count, ToSkPoints(points), p);
           },
           [=](const DlRenderContext& ctx) {
             auto mode = DlPointMode::kPoints;
@@ -3246,18 +3306,18 @@ TEST_F(DisplayListRendering, DrawPointsAsPoints) {
 }
 
 TEST_F(DisplayListRendering, DrawPointsAsLines) {
-  const SkScalar x0 = kRenderLeft + 1;
-  const SkScalar x1 = kRenderLeft + 16;
-  const SkScalar x2 = kRenderRight - 16;
-  const SkScalar x3 = kRenderRight - 1;
+  const DlScalar x0 = kRenderLeft + 1;
+  const DlScalar x1 = kRenderLeft + 16;
+  const DlScalar x2 = kRenderRight - 16;
+  const DlScalar x3 = kRenderRight - 1;
 
-  const SkScalar y0 = kRenderTop;
-  const SkScalar y1 = kRenderTop + 16;
-  const SkScalar y2 = kRenderBottom - 16;
-  const SkScalar y3 = kRenderBottom - 1;
+  const DlScalar y0 = kRenderTop;
+  const DlScalar y1 = kRenderTop + 16;
+  const DlScalar y2 = kRenderBottom - 16;
+  const DlScalar y3 = kRenderBottom - 1;
 
   // clang-format off
-  const SkPoint points[] = {
+  const DlPoint points[] = {
       // Outer box
       {x0, y0}, {x3, y0},
       {x3, y0}, {x3, y3},
@@ -3286,7 +3346,7 @@ TEST_F(DisplayListRendering, DrawPointsAsLines) {
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
             auto mode = SkCanvas::kLines_PointMode;
-            ctx.canvas->drawPoints(mode, count, points, p);
+            ctx.canvas->drawPoints(mode, count, ToSkPoints(points), p);
           },
           [=](const DlRenderContext& ctx) {
             auto mode = DlPointMode::kLines;
@@ -3296,19 +3356,19 @@ TEST_F(DisplayListRendering, DrawPointsAsLines) {
 }
 
 TEST_F(DisplayListRendering, DrawPointsAsPolygon) {
-  const SkPoint points1[] = {
+  const DlPoint points1[] = {
       // RenderBounds box with a diamond
-      SkPoint::Make(kRenderLeft, kRenderTop),
-      SkPoint::Make(kRenderRight, kRenderTop),
-      SkPoint::Make(kRenderRight, kRenderBottom),
-      SkPoint::Make(kRenderLeft, kRenderBottom),
-      SkPoint::Make(kRenderLeft, kRenderTop),
+      DlPoint(kRenderLeft, kRenderTop),
+      DlPoint(kRenderRight, kRenderTop),
+      DlPoint(kRenderRight, kRenderBottom),
+      DlPoint(kRenderLeft, kRenderBottom),
+      DlPoint(kRenderLeft, kRenderTop),
 
-      SkPoint::Make(kRenderCenterX, kRenderTop + 15),
-      SkPoint::Make(kRenderRight - 15, kRenderCenterY),
-      SkPoint::Make(kRenderCenterX, kRenderBottom - 15),
-      SkPoint::Make(kRenderLeft + 15, kRenderCenterY),
-      SkPoint::Make(kRenderCenterX, kRenderTop + 15),
+      DlPoint(kRenderCenterX, kRenderTop + 15),
+      DlPoint(kRenderRight - 15, kRenderCenterY),
+      DlPoint(kRenderCenterX, kRenderBottom - 15),
+      DlPoint(kRenderLeft + 15, kRenderCenterY),
+      DlPoint(kRenderCenterX, kRenderTop + 15),
   };
   const int count1 = sizeof(points1) / sizeof(points1[0]);
 
@@ -3321,7 +3381,7 @@ TEST_F(DisplayListRendering, DrawPointsAsPolygon) {
             SkPaint p = ctx.paint;
             p.setStyle(SkPaint::kStroke_Style);
             auto mode = SkCanvas::kPolygon_PointMode;
-            ctx.canvas->drawPoints(mode, count1, points1, p);
+            ctx.canvas->drawPoints(mode, count1, ToSkPoints(points1), p);
           },
           [=](const DlRenderContext& ctx) {
             auto mode = DlPointMode::kPolygon;
@@ -3340,15 +3400,15 @@ TEST_F(DisplayListRendering, DrawVerticesWithColors) {
   // |xxxxxx    |
   // |xxxxxxxxxx|
   // +----------|
-  const SkPoint pts[6] = {
+  const DlPoint pts[6] = {
       // Upper-Right corner, full top, half right coverage
-      SkPoint::Make(kRenderLeft, kRenderTop),
-      SkPoint::Make(kRenderRight, kRenderTop),
-      SkPoint::Make(kRenderRight, kRenderCenterY),
+      DlPoint(kRenderLeft, kRenderTop),
+      DlPoint(kRenderRight, kRenderTop),
+      DlPoint(kRenderRight, kRenderCenterY),
       // Lower-Left corner, full bottom, half left coverage
-      SkPoint::Make(kRenderLeft, kRenderBottom),
-      SkPoint::Make(kRenderLeft, kRenderCenterY),
-      SkPoint::Make(kRenderRight, kRenderBottom),
+      DlPoint(kRenderLeft, kRenderBottom),
+      DlPoint(kRenderLeft, kRenderCenterY),
+      DlPoint(kRenderRight, kRenderBottom),
   };
   const DlColor dl_colors[6] = {
       DlColor::kRed(),  DlColor::kBlue(),   DlColor::kGreen(),
@@ -3358,11 +3418,11 @@ TEST_F(DisplayListRendering, DrawVerticesWithColors) {
       SK_ColorRED,  SK_ColorBLUE,   SK_ColorGREEN,
       SK_ColorCYAN, SK_ColorYELLOW, SK_ColorMAGENTA,
   };
-  const std::shared_ptr<DlVertices> dl_vertices = DlVertices::Make(
-      DlVertexMode::kTriangles, 6, ToDlPoints(pts), nullptr, dl_colors);
+  const std::shared_ptr<DlVertices> dl_vertices =
+      DlVertices::Make(DlVertexMode::kTriangles, 6, pts, nullptr, dl_colors);
   const auto sk_vertices =
       SkVertices::MakeCopy(SkVertices::VertexMode::kTriangles_VertexMode, 6,
-                           pts, nullptr, sk_colors);
+                           ToSkPoints(pts), nullptr, sk_colors);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
@@ -3387,28 +3447,29 @@ TEST_F(DisplayListRendering, DrawVerticesWithImage) {
   // |xxxxxx    |
   // |xxxxxxxxxx|
   // +----------|
-  const SkPoint pts[6] = {
+  const DlPoint pts[6] = {
       // Upper-Right corner, full top, half right coverage
-      SkPoint::Make(kRenderLeft, kRenderTop),
-      SkPoint::Make(kRenderRight, kRenderTop),
-      SkPoint::Make(kRenderRight, kRenderCenterY),
+      DlPoint(kRenderLeft, kRenderTop),
+      DlPoint(kRenderRight, kRenderTop),
+      DlPoint(kRenderRight, kRenderCenterY),
       // Lower-Left corner, full bottom, half left coverage
-      SkPoint::Make(kRenderLeft, kRenderBottom),
-      SkPoint::Make(kRenderLeft, kRenderCenterY),
-      SkPoint::Make(kRenderRight, kRenderBottom),
+      DlPoint(kRenderLeft, kRenderBottom),
+      DlPoint(kRenderLeft, kRenderCenterY),
+      DlPoint(kRenderRight, kRenderBottom),
   };
-  const SkPoint tex[6] = {
-      SkPoint::Make(kRenderWidth / 2.0, 0),
-      SkPoint::Make(0, kRenderHeight),
-      SkPoint::Make(kRenderWidth, kRenderHeight),
-      SkPoint::Make(kRenderWidth / 2, kRenderHeight),
-      SkPoint::Make(0, 0),
-      SkPoint::Make(kRenderWidth, 0),
+  const DlPoint tex[6] = {
+      DlPoint(kRenderWidth / 2.0, 0),
+      DlPoint(0, kRenderHeight),
+      DlPoint(kRenderWidth, kRenderHeight),
+      DlPoint(kRenderWidth / 2, kRenderHeight),
+      DlPoint(0, 0),
+      DlPoint(kRenderWidth, 0),
   };
-  const std::shared_ptr<DlVertices> dl_vertices = DlVertices::Make(
-      DlVertexMode::kTriangles, 6, ToDlPoints(pts), ToDlPoints(tex), nullptr);
-  const auto sk_vertices = SkVertices::MakeCopy(
-      SkVertices::VertexMode::kTriangles_VertexMode, 6, pts, tex, nullptr);
+  const std::shared_ptr<DlVertices> dl_vertices =
+      DlVertices::Make(DlVertexMode::kTriangles, 6, pts, tex, nullptr);
+  const auto sk_vertices =
+      SkVertices::MakeCopy(SkVertices::VertexMode::kTriangles_VertexMode, 6,
+                           ToSkPoints(pts), ToSkPoints(tex), nullptr);
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
@@ -3440,8 +3501,7 @@ TEST_F(DisplayListRendering, DrawImageNearest) {
                                   &ctx.paint);
           },
           [=](const DlRenderContext& ctx) {
-            ctx.canvas->DrawImage(ctx.image,  //
-                                  SkPoint::Make(kRenderLeft, kRenderTop),
+            ctx.canvas->DrawImage(ctx.image, DlPoint(kRenderLeft, kRenderTop),
                                   DlImageSampling::kNearestNeighbor,
                                   &ctx.paint);
           },
@@ -3456,8 +3516,7 @@ TEST_F(DisplayListRendering, DrawImageNearestNoPaint) {
                                   SkImageSampling::kNearestNeighbor, nullptr);
           },
           [=](const DlRenderContext& ctx) {
-            ctx.canvas->DrawImage(ctx.image,
-                                  SkPoint::Make(kRenderLeft, kRenderTop),
+            ctx.canvas->DrawImage(ctx.image, DlPoint(kRenderLeft, kRenderTop),
                                   DlImageSampling::kNearestNeighbor, nullptr);
           },
           kDrawImageFlags));
@@ -3471,22 +3530,22 @@ TEST_F(DisplayListRendering, DrawImageLinear) {
                                   SkImageSampling::kLinear, &ctx.paint);
           },
           [=](const DlRenderContext& ctx) {
-            ctx.canvas->DrawImage(ctx.image,
-                                  SkPoint::Make(kRenderLeft, kRenderTop),
+            ctx.canvas->DrawImage(ctx.image, DlPoint(kRenderLeft, kRenderTop),
                                   DlImageSampling::kLinear, &ctx.paint);
           },
           kDrawImageWithPaintFlags));
 }
 
 TEST_F(DisplayListRendering, DrawImageRectNearest) {
-  SkRect src = SkRect::MakeIWH(kRenderWidth, kRenderHeight).makeInset(5, 5);
-  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
+  DlRect src = DlRect::MakeWH(kRenderWidth, kRenderHeight).Expand(-5, -5);
+  DlRect dst = kRenderBounds.Expand(-10.5f, -10.5f);
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawImageRect(
-                ctx.image, src, dst, SkImageSampling::kNearestNeighbor,
-                &ctx.paint, SkCanvas::kFast_SrcRectConstraint);
+            ctx.canvas->drawImageRect(ctx.image, ToSkRect(src), ToSkRect(dst),
+                                      SkImageSampling::kNearestNeighbor,
+                                      &ctx.paint,
+                                      SkCanvas::kFast_SrcRectConstraint);
           },
           [=](const DlRenderContext& ctx) {
             ctx.canvas->DrawImageRect(ctx.image, src, dst,
@@ -3497,14 +3556,15 @@ TEST_F(DisplayListRendering, DrawImageRectNearest) {
 }
 
 TEST_F(DisplayListRendering, DrawImageRectNearestNoPaint) {
-  SkRect src = SkRect::MakeIWH(kRenderWidth, kRenderHeight).makeInset(5, 5);
-  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
+  DlRect src = DlRect::MakeWH(kRenderWidth, kRenderHeight).Expand(-5, -5);
+  DlRect dst = kRenderBounds.Expand(-10.5f, -10.5f);
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawImageRect(
-                ctx.image, src, dst, SkImageSampling::kNearestNeighbor,  //
-                nullptr, SkCanvas::kFast_SrcRectConstraint);
+            ctx.canvas->drawImageRect(ctx.image, ToSkRect(src), ToSkRect(dst),
+                                      SkImageSampling::kNearestNeighbor,
+                                      nullptr,
+                                      SkCanvas::kFast_SrcRectConstraint);
           },
           [=](const DlRenderContext& ctx) {
             ctx.canvas->DrawImageRect(ctx.image, src, dst,
@@ -3515,14 +3575,14 @@ TEST_F(DisplayListRendering, DrawImageRectNearestNoPaint) {
 }
 
 TEST_F(DisplayListRendering, DrawImageRectLinear) {
-  SkRect src = SkRect::MakeIWH(kRenderWidth, kRenderHeight).makeInset(5, 5);
-  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
+  DlRect src = DlRect::MakeWH(kRenderWidth, kRenderHeight).Expand(-5, -5);
+  DlRect dst = kRenderBounds.Expand(-10.5f, -10.5f);
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawImageRect(
-                ctx.image, src, dst, SkImageSampling::kLinear,  //
-                &ctx.paint, SkCanvas::kFast_SrcRectConstraint);
+            ctx.canvas->drawImageRect(ctx.image, ToSkRect(src), ToSkRect(dst),
+                                      SkImageSampling::kLinear, &ctx.paint,
+                                      SkCanvas::kFast_SrcRectConstraint);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawImageRect(ctx.image, src, dst,
@@ -3533,13 +3593,14 @@ TEST_F(DisplayListRendering, DrawImageRectLinear) {
 }
 
 TEST_F(DisplayListRendering, DrawImageNineNearest) {
-  SkIRect src = SkIRect::MakeWH(kRenderWidth, kRenderHeight).makeInset(25, 25);
-  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
+  DlIRect src = DlIRect::MakeWH(kRenderWidth, kRenderHeight).Expand(-25, -25);
+  DlRect dst = kRenderBounds.Expand(-10.5f, -10.5f);
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawImageNine(ctx.image.get(), src, dst,
-                                      SkFilterMode::kNearest, &ctx.paint);
+            ctx.canvas->drawImageNine(ctx.image.get(), ToSkIRect(src),
+                                      ToSkRect(dst), SkFilterMode::kNearest,
+                                      &ctx.paint);
           },
           [=](const DlRenderContext& ctx) {
             ctx.canvas->DrawImageNine(ctx.image, src, dst,
@@ -3549,13 +3610,14 @@ TEST_F(DisplayListRendering, DrawImageNineNearest) {
 }
 
 TEST_F(DisplayListRendering, DrawImageNineNearestNoPaint) {
-  SkIRect src = SkIRect::MakeWH(kRenderWidth, kRenderHeight).makeInset(25, 25);
-  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
+  DlIRect src = DlIRect::MakeWH(kRenderWidth, kRenderHeight).Expand(-25, -25);
+  DlRect dst = kRenderBounds.Expand(-10.5f, -10.5f);
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawImageNine(ctx.image.get(), src, dst,
-                                      SkFilterMode::kNearest, nullptr);
+            ctx.canvas->drawImageNine(ctx.image.get(), ToSkIRect(src),
+                                      ToSkRect(dst), SkFilterMode::kNearest,
+                                      nullptr);
           },
           [=](const DlRenderContext& ctx) {
             ctx.canvas->DrawImageNine(ctx.image, src, dst,
@@ -3565,13 +3627,14 @@ TEST_F(DisplayListRendering, DrawImageNineNearestNoPaint) {
 }
 
 TEST_F(DisplayListRendering, DrawImageNineLinear) {
-  SkIRect src = SkIRect::MakeWH(kRenderWidth, kRenderHeight).makeInset(25, 25);
-  SkRect dst = kRenderBounds.makeInset(10.5, 10.5);
+  DlIRect src = DlIRect::MakeWH(kRenderWidth, kRenderHeight).Expand(-25, -25);
+  DlRect dst = kRenderBounds.Expand(-10.5f, -10.5f);
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawImageNine(ctx.image.get(), src, dst,
-                                      SkFilterMode::kLinear, &ctx.paint);
+            ctx.canvas->drawImageNine(ctx.image.get(), ToSkIRect(src),
+                                      ToSkRect(dst), SkFilterMode::kLinear,
+                                      &ctx.paint);
           },
           [=](const DlRenderContext& ctx) {
             ctx.canvas->DrawImageNine(ctx.image, src, dst,
@@ -3581,6 +3644,13 @@ TEST_F(DisplayListRendering, DrawImageNineLinear) {
 }
 
 TEST_F(DisplayListRendering, DrawAtlasNearest) {
+  auto relative_rect = [](DlScalar relative_left, DlScalar relative_top,
+                          DlScalar relative_right, DlScalar relative_bottom) {
+    return DlRect::MakeLTRB(
+        kRenderWidth * relative_left, kRenderHeight * relative_top,
+        kRenderWidth * relative_right, kRenderHeight * relative_bottom);
+  };
+
   const SkRSXform sk_xform[] = {
       // clang-format off
       { 1.2f,  0.0f, kRenderLeft,  kRenderTop},
@@ -3597,13 +3667,11 @@ TEST_F(DisplayListRendering, DrawAtlasNearest) {
       { 0.0f, -1.2f, kRenderLeft,  kRenderBottom},
       // clang-format on
   };
-  const SkRect tex[] = {
-      // clang-format off
-      {0,                0,                 kRenderHalfWidth, kRenderHalfHeight},
-      {kRenderHalfWidth, 0,                 kRenderWidth,     kRenderHalfHeight},
-      {kRenderHalfWidth, kRenderHalfHeight, kRenderWidth,     kRenderHeight},
-      {0,                kRenderHalfHeight, kRenderHalfWidth, kRenderHeight},
-      // clang-format on
+  const DlRect tex[] = {
+      relative_rect(0.0f, 0.0f, 0.5f, 0.5f),
+      relative_rect(0.5f, 0.0f, 1.0f, 0.5f),
+      relative_rect(0.5f, 0.5f, 1.0f, 1.0f),
+      relative_rect(0.0f, 0.5f, 0.5f, 1.0f),
   };
   const SkColor sk_colors[] = {
       SK_ColorBLUE,
@@ -3622,19 +3690,26 @@ TEST_F(DisplayListRendering, DrawAtlasNearest) {
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawAtlas(ctx.image.get(), sk_xform, tex, sk_colors, 4,
-                                  SkBlendMode::kSrcOver, sk_sampling, nullptr,
-                                  &ctx.paint);
+            ctx.canvas->drawAtlas(ctx.image.get(), sk_xform, ToSkRects(tex),
+                                  sk_colors, 4, SkBlendMode::kSrcOver,
+                                  sk_sampling, nullptr, &ctx.paint);
           },
           [=](const DlRenderContext& ctx) {
-            ctx.canvas->DrawAtlas(ctx.image, dl_xform, ToDlRects(tex),
-                                  dl_colors, 4, DlBlendMode::kSrcOver,
-                                  dl_sampling, nullptr, &ctx.paint);
+            ctx.canvas->DrawAtlas(ctx.image, dl_xform, tex, dl_colors, 4,
+                                  DlBlendMode::kSrcOver, dl_sampling, nullptr,
+                                  &ctx.paint);
           },
           kDrawAtlasWithPaintFlags));
 }
 
 TEST_F(DisplayListRendering, DrawAtlasNearestNoPaint) {
+  auto relative_rect = [](DlScalar relative_left, DlScalar relative_top,
+                          DlScalar relative_right, DlScalar relative_bottom) {
+    return DlRect::MakeLTRB(
+        kRenderWidth * relative_left, kRenderHeight * relative_top,
+        kRenderWidth * relative_right, kRenderHeight * relative_bottom);
+  };
+
   const SkRSXform sk_xform[] = {
       // clang-format off
       { 1.2f,  0.0f, kRenderLeft,  kRenderTop},
@@ -3651,13 +3726,11 @@ TEST_F(DisplayListRendering, DrawAtlasNearestNoPaint) {
       { 0.0f, -1.2f, kRenderLeft,  kRenderBottom},
       // clang-format on
   };
-  const SkRect tex[] = {
-      // clang-format off
-      {0,                0,                 kRenderHalfWidth, kRenderHalfHeight},
-      {kRenderHalfWidth, 0,                 kRenderWidth,     kRenderHalfHeight},
-      {kRenderHalfWidth, kRenderHalfHeight, kRenderWidth,     kRenderHeight},
-      {0,                kRenderHalfHeight, kRenderHalfWidth, kRenderHeight},
-      // clang-format on
+  const DlRect tex[] = {
+      relative_rect(0.0f, 0.0f, 0.5f, 0.5f),
+      relative_rect(0.5f, 0.0f, 1.0f, 0.5f),
+      relative_rect(0.5f, 0.5f, 1.0f, 1.0f),
+      relative_rect(0.0f, 0.5f, 0.5f, 1.0f),
   };
   const SkColor sk_colors[] = {
       SK_ColorBLUE,
@@ -3676,19 +3749,26 @@ TEST_F(DisplayListRendering, DrawAtlasNearestNoPaint) {
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawAtlas(ctx.image.get(), sk_xform, tex, sk_colors, 4,
-                                  SkBlendMode::kSrcOver, sk_sampling,  //
-                                  nullptr, nullptr);
+            ctx.canvas->drawAtlas(ctx.image.get(), sk_xform, ToSkRects(tex),
+                                  sk_colors, 4, SkBlendMode::kSrcOver,
+                                  sk_sampling, nullptr, nullptr);
           },
           [=](const DlRenderContext& ctx) {
-            ctx.canvas->DrawAtlas(ctx.image, dl_xform, ToDlRects(tex),
-                                  dl_colors, 4, DlBlendMode::kSrcOver,
-                                  dl_sampling, nullptr, nullptr);
+            ctx.canvas->DrawAtlas(ctx.image, dl_xform, tex, dl_colors, 4,
+                                  DlBlendMode::kSrcOver, dl_sampling, nullptr,
+                                  nullptr);
           },
           kDrawAtlasFlags));
 }
 
 TEST_F(DisplayListRendering, DrawAtlasLinear) {
+  auto relative_rect = [](DlScalar relative_left, DlScalar relative_top,
+                          DlScalar relative_right, DlScalar relative_bottom) {
+    return DlRect::MakeLTRB(
+        kRenderWidth * relative_left, kRenderHeight * relative_top,
+        kRenderWidth * relative_right, kRenderHeight * relative_bottom);
+  };
+
   const SkRSXform sk_xform[] = {
       // clang-format off
       { 1.2f,  0.0f, kRenderLeft,  kRenderTop},
@@ -3705,13 +3785,11 @@ TEST_F(DisplayListRendering, DrawAtlasLinear) {
       { 0.0f, -1.2f, kRenderLeft,  kRenderBottom},
       // clang-format on
   };
-  const SkRect tex[] = {
-      // clang-format off
-      {0,                0,                 kRenderHalfWidth, kRenderHalfHeight},
-      {kRenderHalfWidth, 0,                 kRenderWidth,     kRenderHalfHeight},
-      {kRenderHalfWidth, kRenderHalfHeight, kRenderWidth,     kRenderHeight},
-      {0,                kRenderHalfHeight, kRenderHalfWidth, kRenderHeight},
-      // clang-format on
+  const DlRect tex[] = {
+      relative_rect(0.0f, 0.0f, 0.5f, 0.5f),
+      relative_rect(0.5f, 0.0f, 1.0f, 0.5f),
+      relative_rect(0.5f, 0.5f, 1.0f, 1.0f),
+      relative_rect(0.0f, 0.5f, 0.5f, 1.0f),
   };
   const SkColor sk_colors[] = {
       SK_ColorBLUE,
@@ -3730,14 +3808,14 @@ TEST_F(DisplayListRendering, DrawAtlasLinear) {
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
-            ctx.canvas->drawAtlas(ctx.image.get(), sk_xform, tex, sk_colors, 2,
-                                  SkBlendMode::kSrcOver, sk_sampling,  //
-                                  nullptr, &ctx.paint);
+            ctx.canvas->drawAtlas(ctx.image.get(), sk_xform, ToSkRects(tex),
+                                  sk_colors, 2, SkBlendMode::kSrcOver,
+                                  sk_sampling, nullptr, &ctx.paint);
           },
           [=](const DlRenderContext& ctx) {
-            ctx.canvas->DrawAtlas(ctx.image, dl_xform, ToDlRects(tex),
-                                  dl_colors, 2, DlBlendMode::kSrcOver,
-                                  dl_sampling, nullptr, &ctx.paint);
+            ctx.canvas->DrawAtlas(ctx.image, dl_xform, tex, dl_colors, 2,
+                                  DlBlendMode::kSrcOver, dl_sampling, nullptr,
+                                  &ctx.paint);
           },
           kDrawAtlasWithPaintFlags));
 }
@@ -3747,19 +3825,21 @@ sk_sp<DisplayList> makeTestDisplayList() {
   DlPaint paint;
   paint.setDrawStyle(DlDrawStyle::kFill);
   paint.setColor(DlColor(SK_ColorRED));
-  builder.DrawRect(
-      SkRect{kRenderLeft, kRenderTop, kRenderCenterX, kRenderCenterY}, paint);
+  builder.DrawRect(DlRect::MakeLTRB(kRenderLeft, kRenderTop,  //
+                                    kRenderCenterX, kRenderCenterY),
+                   paint);
   paint.setColor(DlColor(SK_ColorBLUE));
-  builder.DrawRect(
-      SkRect{kRenderCenterX, kRenderTop, kRenderRight, kRenderCenterY}, paint);
+  builder.DrawRect(DlRect::MakeLTRB(kRenderCenterX, kRenderTop,  //
+                                    kRenderRight, kRenderCenterY),
+                   paint);
   paint.setColor(DlColor(SK_ColorGREEN));
-  builder.DrawRect(
-      SkRect{kRenderLeft, kRenderCenterY, kRenderCenterX, kRenderBottom},
-      paint);
+  builder.DrawRect(DlRect::MakeLTRB(kRenderLeft, kRenderCenterY,  //
+                                    kRenderCenterX, kRenderBottom),
+                   paint);
   paint.setColor(DlColor(SK_ColorYELLOW));
-  builder.DrawRect(
-      SkRect{kRenderCenterX, kRenderCenterY, kRenderRight, kRenderBottom},
-      paint);
+  builder.DrawRect(DlRect::MakeLTRB(kRenderCenterX, kRenderCenterY,  //
+                                    kRenderRight, kRenderBottom),
+                   paint);
   return builder.Build();
 }
 
@@ -3789,8 +3869,8 @@ TEST_F(DisplayListRendering, DrawTextBlob) {
 #ifdef IMPELLER_SUPPORTS_RENDERING
   auto frame = impeller::MakeTextFrameFromTextBlobSkia(blob);
 #endif  // IMPELLER_SUPPORTS_RENDERING
-  SkScalar render_y_1_3 = kRenderTop + kRenderHeight * 0.3;
-  SkScalar render_y_2_3 = kRenderTop + kRenderHeight * 0.6;
+  DlScalar render_y_1_3 = kRenderTop + kRenderHeight * 0.3;
+  DlScalar render_y_2_3 = kRenderTop + kRenderHeight * 0.6;
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {
@@ -3825,23 +3905,21 @@ TEST_F(DisplayListRendering, DrawTextBlob) {
 }
 
 TEST_F(DisplayListRendering, DrawShadow) {
-  SkPath path;
-  path.addRoundRect(
-      {
-          kRenderLeft + 10,
-          kRenderTop,
-          kRenderRight - 10,
-          kRenderBottom - 20,
-      },
-      kRenderCornerRadius, kRenderCornerRadius);
+  DlPathBuilder path_builder;
+  path_builder.AddRoundRect(DlRoundRect::MakeRectXY(
+      DlRect::MakeLTRB(kRenderLeft + 10, kRenderTop,  //
+                       kRenderRight - 10, kRenderBottom - 20),
+      kRenderCornerRadius, kRenderCornerRadius));
+  DlPath path(path_builder);
+
   const DlColor color = DlColor::kDarkGrey();
-  const SkScalar elevation = 7;
+  const DlScalar elevation = 7;
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path, color, elevation,
-                                             false, 1.0);
+            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path.GetSkPath(),
+                                             color, elevation, false, 1.0);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawShadow(path, color, elevation, false, 1.0);
@@ -3851,23 +3929,21 @@ TEST_F(DisplayListRendering, DrawShadow) {
 }
 
 TEST_F(DisplayListRendering, DrawShadowTransparentOccluder) {
-  SkPath path;
-  path.addRoundRect(
-      {
-          kRenderLeft + 10,
-          kRenderTop,
-          kRenderRight - 10,
-          kRenderBottom - 20,
-      },
-      kRenderCornerRadius, kRenderCornerRadius);
+  DlPathBuilder path_builder;
+  path_builder.AddRoundRect(DlRoundRect::MakeRectXY(
+      DlRect::MakeLTRB(kRenderLeft + 10, kRenderTop,  //
+                       kRenderRight - 10, kRenderBottom - 20),
+      kRenderCornerRadius, kRenderCornerRadius));
+  DlPath path(path_builder);
+
   const DlColor color = DlColor::kDarkGrey();
-  const SkScalar elevation = 7;
+  const DlScalar elevation = 7;
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path, color, elevation,
-                                             true, 1.0);
+            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path.GetSkPath(),
+                                             color, elevation, true, 1.0);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawShadow(path, color, elevation, true, 1.0);
@@ -3877,23 +3953,21 @@ TEST_F(DisplayListRendering, DrawShadowTransparentOccluder) {
 }
 
 TEST_F(DisplayListRendering, DrawShadowDpr) {
-  SkPath path;
-  path.addRoundRect(
-      {
-          kRenderLeft + 10,
-          kRenderTop,
-          kRenderRight - 10,
-          kRenderBottom - 20,
-      },
-      kRenderCornerRadius, kRenderCornerRadius);
+  DlPathBuilder path_builder;
+  path_builder.AddRoundRect(DlRoundRect::MakeRectXY(
+      DlRect::MakeLTRB(kRenderLeft + 10, kRenderTop,  //
+                       kRenderRight - 10, kRenderBottom - 20),
+      kRenderCornerRadius, kRenderCornerRadius));
+  DlPath path(path_builder);
+
   const DlColor color = DlColor::kDarkGrey();
-  const SkScalar elevation = 7;
+  const DlScalar elevation = 7;
 
   CanvasCompareTester::RenderAll(  //
       TestParameters(
           [=](const SkRenderContext& ctx) {  //
-            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path, color, elevation,
-                                             false, 1.5);
+            DlSkCanvasDispatcher::DrawShadow(ctx.canvas, path.GetSkPath(),
+                                             color, elevation, false, 1.5);
           },
           [=](const DlRenderContext& ctx) {  //
             ctx.canvas->DrawShadow(path, color, elevation, false, 1.5);
@@ -3904,10 +3978,10 @@ TEST_F(DisplayListRendering, DrawShadowDpr) {
 
 TEST_F(DisplayListRendering, SaveLayerClippedContentStillFilters) {
   // draw rect is just outside of render bounds on the right
-  const SkRect draw_rect = SkRect::MakeLTRB(  //
+  const DlRect draw_rect = DlRect::MakeLTRB(  //
       kRenderRight + 1,                       //
       kRenderTop,                             //
-      kTestBounds2.fRight,                    //
+      kTestBounds2.GetRight(),                //
       kRenderBottom                           //
   );
   TestParameters test_params(
@@ -3917,9 +3991,10 @@ TEST_F(DisplayListRendering, SaveLayerClippedContentStillFilters) {
         SkPaint layer_paint;
         layer_paint.setImageFilter(layer_filter);
         ctx.canvas->save();
-        ctx.canvas->clipRect(kRenderBounds, SkClipOp::kIntersect, false);
-        ctx.canvas->saveLayer(&kTestBounds2, &layer_paint);
-        ctx.canvas->drawRect(draw_rect, ctx.paint);
+        ctx.canvas->clipRect(ToSkRect(kRenderBounds), SkClipOp::kIntersect,
+                             false);
+        ctx.canvas->saveLayer(&ToSkRect(kTestBounds2), &layer_paint);
+        ctx.canvas->drawRect(ToSkRect(draw_rect), ctx.paint);
         ctx.canvas->restore();
         ctx.canvas->restore();
       },
@@ -3930,7 +4005,7 @@ TEST_F(DisplayListRendering, SaveLayerClippedContentStillFilters) {
         layer_paint.setImageFilter(layer_filter);
         ctx.canvas->Save();
         ctx.canvas->ClipRect(kRenderBounds, DlClipOp::kIntersect, false);
-        ctx.canvas->SaveLayer(&kTestBounds2, &layer_paint);
+        ctx.canvas->SaveLayer(kTestBounds2, &layer_paint);
         ctx.canvas->DrawRect(draw_rect, ctx.paint);
         ctx.canvas->Restore();
         ctx.canvas->Restore();
@@ -3972,7 +4047,7 @@ TEST_F(DisplayListRendering, SaveLayerConsolidation) {
   contract_matrix.Scale({0.9f, 0.9f});
   contract_matrix.Translate({kRenderCenterX, kRenderCenterY});
 
-  std::vector<SkScalar> opacities = {
+  std::vector<DlScalar> opacities = {
       0,
       0.5f,
       SK_Scalar1,
@@ -3992,18 +4067,18 @@ TEST_F(DisplayListRendering, SaveLayerConsolidation) {
   };
 
   auto render_content = [](DisplayListBuilder& builder) {
-    builder.DrawRect(
-        SkRect{kRenderLeft, kRenderTop, kRenderCenterX, kRenderCenterY},
-        DlPaint(DlColor::kYellow()));
-    builder.DrawRect(
-        SkRect{kRenderCenterX, kRenderTop, kRenderRight, kRenderCenterY},
-        DlPaint(DlColor::kRed()));
-    builder.DrawRect(
-        SkRect{kRenderLeft, kRenderCenterY, kRenderCenterX, kRenderBottom},
-        DlPaint(DlColor::kBlue()));
-    builder.DrawRect(
-        SkRect{kRenderCenterX, kRenderCenterY, kRenderRight, kRenderBottom},
-        DlPaint(DlColor::kRed().modulateOpacity(0.5f)));
+    builder.DrawRect(DlRect::MakeLTRB(kRenderLeft, kRenderTop,  //
+                                      kRenderCenterX, kRenderCenterY),
+                     DlPaint(DlColor::kYellow()));
+    builder.DrawRect(DlRect::MakeLTRB(kRenderCenterX, kRenderTop,  //
+                                      kRenderRight, kRenderCenterY),
+                     DlPaint(DlColor::kRed()));
+    builder.DrawRect(DlRect::MakeLTRB(kRenderLeft, kRenderCenterY,  //
+                                      kRenderCenterX, kRenderBottom),
+                     DlPaint(DlColor::kBlue()));
+    builder.DrawRect(DlRect::MakeLTRB(kRenderCenterX, kRenderCenterY,  //
+                                      kRenderRight, kRenderBottom),
+                     DlPaint(DlColor::kRed().modulateOpacity(0.5f)));
   };
 
   auto test_attributes_env =
@@ -4012,19 +4087,19 @@ TEST_F(DisplayListRendering, SaveLayerConsolidation) {
                        const std::string& desc1, const std::string& desc2,
                        const RenderEnvironment* env) {
         DisplayListBuilder nested_builder;
-        nested_builder.SaveLayer(&kTestBounds2, &paint1);
-        nested_builder.SaveLayer(&kTestBounds2, &paint2);
+        nested_builder.SaveLayer(kTestBounds2, &paint1);
+        nested_builder.SaveLayer(kTestBounds2, &paint2);
         render_content(nested_builder);
         auto nested_results = env->getResult(nested_builder.Build());
 
         DisplayListBuilder reverse_builder;
-        reverse_builder.SaveLayer(&kTestBounds2, &paint2);
-        reverse_builder.SaveLayer(&kTestBounds2, &paint1);
+        reverse_builder.SaveLayer(kTestBounds2, &paint2);
+        reverse_builder.SaveLayer(kTestBounds2, &paint1);
         render_content(reverse_builder);
         auto reverse_results = env->getResult(reverse_builder.Build());
 
         DisplayListBuilder combined_builder;
-        combined_builder.SaveLayer(&kTestBounds2, &paint_both);
+        combined_builder.SaveLayer(kTestBounds2, &paint_both);
         render_content(combined_builder);
         auto combined_results = env->getResult(combined_builder.Build());
 
@@ -4080,7 +4155,7 @@ TEST_F(DisplayListRendering, SaveLayerConsolidation) {
     DlPaint nested_paint1 = DlPaint().setColorFilter(color_filter);
 
     for (size_t oi = 0; oi < opacities.size(); oi++) {
-      SkScalar opacity = opacities[oi];
+      DlScalar opacity = opacities[oi];
       std::string op_desc = "opacity " + std::to_string(opacity);
       DlPaint nested_paint2 = DlPaint().setOpacity(opacity);
 
@@ -4100,7 +4175,7 @@ TEST_F(DisplayListRendering, SaveLayerConsolidation) {
   // The reverse should also theoretically work for some IFs, but we
   // get some rounding errors that are more than just trivial.
   for (size_t oi = 0; oi < opacities.size(); oi++) {
-    SkScalar opacity = opacities[oi];
+    DlScalar opacity = opacities[oi];
     std::string op_desc = "opacity " + std::to_string(opacity);
     DlPaint nested_paint1 = DlPaint().setOpacity(opacity);
 
@@ -4140,7 +4215,7 @@ TEST_F(DisplayListRendering, SaveLayerConsolidation) {
 }
 
 TEST_F(DisplayListRendering, MatrixColorFilterModifyTransparencyCheck) {
-  auto test_matrix = [](int element, SkScalar value) {
+  auto test_matrix = [](int element, DlScalar value) {
     // clang-format off
     float matrix[] = {
         1, 0, 0, 0, 0,
@@ -4166,17 +4241,17 @@ TEST_F(DisplayListRendering, MatrixColorFilterModifyTransparencyCheck) {
     DlPaint filter_save_paint = DlPaint().setColorFilter(&filter);
 
     DisplayListBuilder builder1;
-    builder1.Translate(kTestCenter.fX, kTestCenter.fY);
+    builder1.Translate(kTestCenter2.x, kTestCenter2.y);
     builder1.Rotate(45);
-    builder1.Translate(-kTestCenter.fX, -kTestCenter.fY);
+    builder1.Translate(-kTestCenter2.x, -kTestCenter2.y);
     builder1.DrawRect(kRenderBounds, paint);
     auto display_list1 = builder1.Build();
 
     DisplayListBuilder builder2;
-    builder2.Translate(kTestCenter.fX, kTestCenter.fY);
+    builder2.Translate(kTestCenter2.x, kTestCenter2.y);
     builder2.Rotate(45);
-    builder2.Translate(-kTestCenter.fX, -kTestCenter.fY);
-    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
+    builder2.Translate(-kTestCenter2.x, -kTestCenter2.y);
+    builder2.SaveLayer(kTestBounds2, &filter_save_paint);
     builder2.DrawRect(kRenderBounds, paint);
     builder2.Restore();
     auto display_list2 = builder2.Build();
@@ -4215,7 +4290,7 @@ TEST_F(DisplayListRendering, MatrixColorFilterModifyTransparencyCheck) {
 }
 
 TEST_F(DisplayListRendering, MatrixColorFilterOpacityCommuteCheck) {
-  auto test_matrix = [](int element, SkScalar value) {
+  auto test_matrix = [](int element, DlScalar value) {
     // clang-format off
     float matrix[] = {
         1, 0, 0, 0, 0,
@@ -4235,8 +4310,8 @@ TEST_F(DisplayListRendering, MatrixColorFilterOpacityCommuteCheck) {
     DlPaint filter_save_paint = DlPaint().setColorFilter(filter);
 
     DisplayListBuilder builder1;
-    builder1.SaveLayer(&kTestBounds2, &opacity_save_paint);
-    builder1.SaveLayer(&kTestBounds2, &filter_save_paint);
+    builder1.SaveLayer(kTestBounds2, &opacity_save_paint);
+    builder1.SaveLayer(kTestBounds2, &filter_save_paint);
     // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
     builder1.DrawRect(kRenderBounds, paint);
     builder1.Restore();
@@ -4244,8 +4319,8 @@ TEST_F(DisplayListRendering, MatrixColorFilterOpacityCommuteCheck) {
     auto display_list1 = builder1.Build();
 
     DisplayListBuilder builder2;
-    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
-    builder2.SaveLayer(&kTestBounds2, &opacity_save_paint);
+    builder2.SaveLayer(kTestBounds2, &filter_save_paint);
+    builder2.SaveLayer(kTestBounds2, &opacity_save_paint);
     // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
     builder2.DrawRect(kRenderBounds, paint);
     builder2.Restore();
@@ -4342,17 +4417,17 @@ TEST_F(DisplayListRendering, BlendColorFilterModifyTransparencyCheck) {
     DlPaint filter_save_paint = DlPaint().setColorFilter(&filter);
 
     DisplayListBuilder builder1;
-    builder1.Translate(kTestCenter.fX, kTestCenter.fY);
+    builder1.Translate(kTestCenter2.x, kTestCenter2.y);
     builder1.Rotate(45);
-    builder1.Translate(-kTestCenter.fX, -kTestCenter.fY);
+    builder1.Translate(-kTestCenter2.x, -kTestCenter2.y);
     builder1.DrawRect(kRenderBounds, paint);
     auto display_list1 = builder1.Build();
 
     DisplayListBuilder builder2;
-    builder2.Translate(kTestCenter.fX, kTestCenter.fY);
+    builder2.Translate(kTestCenter2.x, kTestCenter2.y);
     builder2.Rotate(45);
-    builder2.Translate(-kTestCenter.fX, -kTestCenter.fY);
-    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
+    builder2.Translate(-kTestCenter2.x, -kTestCenter2.y);
+    builder2.SaveLayer(kTestBounds2, &filter_save_paint);
     builder2.DrawRect(kRenderBounds, paint);
     builder2.Restore();
     auto display_list2 = builder2.Build();
@@ -4404,8 +4479,8 @@ TEST_F(DisplayListRendering, BlendColorFilterOpacityCommuteCheck) {
     DlPaint filter_save_paint = DlPaint().setColorFilter(&filter);
 
     DisplayListBuilder builder1;
-    builder1.SaveLayer(&kTestBounds2, &opacity_save_paint);
-    builder1.SaveLayer(&kTestBounds2, &filter_save_paint);
+    builder1.SaveLayer(kTestBounds2, &opacity_save_paint);
+    builder1.SaveLayer(kTestBounds2, &filter_save_paint);
     // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
     builder1.DrawRect(kRenderBounds, paint);
     builder1.Restore();
@@ -4413,8 +4488,8 @@ TEST_F(DisplayListRendering, BlendColorFilterOpacityCommuteCheck) {
     auto display_list1 = builder1.Build();
 
     DisplayListBuilder builder2;
-    builder2.SaveLayer(&kTestBounds2, &filter_save_paint);
-    builder2.SaveLayer(&kTestBounds2, &opacity_save_paint);
+    builder2.SaveLayer(kTestBounds2, &filter_save_paint);
+    builder2.SaveLayer(kTestBounds2, &opacity_save_paint);
     // builder1.DrawRect(kRenderBounds.makeOffset(20, 20), DlPaint());
     builder2.DrawRect(kRenderBounds, paint);
     builder2.Restore();
@@ -4638,7 +4713,7 @@ class DisplayListNopTest : public DisplayListRendering {
     std::string desc = desc_stream.str();
     DisplayListBuilder builder(DlRect::MakeWH(100.0f, 100.0f));
     DlPaint paint = DlPaint(color).setBlendMode(mode);
-    builder.DrawRect(SkRect{0.0f, 0.0f, 10.0f, 10.0f}, paint);
+    builder.DrawRect(DlRect::MakeLTRB(0.0f, 0.0f, 10.0f, 10.0f), paint);
     auto dl = builder.Build();
     if (dl->modifies_transparent_black()) {
       ASSERT_TRUE(dl->op_count() != 0u);
@@ -4670,8 +4745,8 @@ class DisplayListNopTest : public DisplayListRendering {
     desc_stream << "/" << color;
     std::string desc = desc_stream.str();
     auto test_image = test_data->image();
-    SkRect test_bounds =
-        SkRect::MakeWH(test_image->width(), test_image->height());
+    DlRect test_bounds =
+        DlRect::MakeWH(test_image->width(), test_image->height());
     DisplayListBuilder builder(test_bounds);
     DlPaint dl_paint = DlPaint(color).setBlendMode(mode);
     builder.DrawRect(test_bounds, dl_paint);
@@ -4692,7 +4767,7 @@ class DisplayListNopTest : public DisplayListRendering {
       SkCanvas* result_canvas = result_surface->sk_surface()->getCanvas();
       result_canvas->clear(SK_ColorTRANSPARENT);
       result_canvas->drawImage(test_image.get(), 0, 0);
-      result_canvas->drawRect(test_bounds, sk_paint);
+      result_canvas->drawRect(ToSkRect(test_bounds), sk_paint);
       if (GrDirectContext* direct_context = GrAsDirectContext(
               result_surface->sk_surface()->recordingContext())) {
         direct_context->flushAndSubmit();
@@ -4736,7 +4811,7 @@ class DisplayListNopTest : public DisplayListRendering {
                         .setColorFilter(color_filter)  //
                         .setImageFilter(image_filter);
     builder.DrawImage(DlImage::Make(test_image_src_data->image()),
-                      SkPoint{0, 0}, DlImageSampling::kNearestNeighbor, &paint);
+                      DlPoint(0, 0), DlImageSampling::kNearestNeighbor, &paint);
     auto dl = builder.Build();
 
     int w = test_image_src_data->width();
diff --git a/engine/src/flutter/display_list/testing/dl_test_surface_metal.mm b/engine/src/flutter/display_list/testing/dl_test_surface_metal.mm
index d90e5e9f0ae..fd3201cb8d5 100644
--- a/engine/src/flutter/display_list/testing/dl_test_surface_metal.mm
+++ b/engine/src/flutter/display_list/testing/dl_test_surface_metal.mm
@@ -16,13 +16,16 @@ namespace testing {
 class DlMetalSurfaceInstance : public DlSurfaceInstance {
  public:
   explicit DlMetalSurfaceInstance(std::unique_ptr<TestMetalSurface> metal_surface)
-      : metal_surface_(std::move(metal_surface)) {}
+      : metal_surface_(std::move(metal_surface)),
+        adapter_(metal_surface_->GetSurface()->getCanvas()) {}
   ~DlMetalSurfaceInstance() = default;
 
   sk_sp<SkSurface> sk_surface() const override { return metal_surface_->GetSurface(); }
+  DlCanvas* GetCanvas() override { return &adapter_; }
 
  private:
   std::unique_ptr<TestMetalSurface> metal_surface_;
+  DlSkCanvasAdapter adapter_;
 };
 
 bool DlMetalSurfaceProvider::InitializeSurface(size_t width, size_t height, PixelFormat format) {
diff --git a/engine/src/flutter/display_list/testing/dl_test_surface_provider.cc b/engine/src/flutter/display_list/testing/dl_test_surface_provider.cc
index 545b3cfa0de..cb7b8147575 100644
--- a/engine/src/flutter/display_list/testing/dl_test_surface_provider.cc
+++ b/engine/src/flutter/display_list/testing/dl_test_surface_provider.cc
@@ -9,6 +9,7 @@
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/encode/SkPngEncoder.h"
+#include "third_party/skia/include/gpu/ganesh/GrDirectContext.h"
 
 namespace flutter::testing {
 
@@ -73,4 +74,15 @@ std::unique_ptr<DlSurfaceProvider> DlSurfaceProvider::CreateMetal() {
 }
 #endif
 
+void DlSurfaceInstance::FlushSubmitCpuSync() {
+  auto surface = sk_surface();
+  if (!surface) {
+    return;
+  }
+  if (GrDirectContext* dContext =
+          GrAsDirectContext(surface->recordingContext())) {
+    dContext->flushAndSubmit(surface.get(), GrSyncCpu::kYes);
+  }
+}
+
 }  // namespace flutter::testing
diff --git a/engine/src/flutter/display_list/testing/dl_test_surface_provider.h b/engine/src/flutter/display_list/testing/dl_test_surface_provider.h
index 5bfc7105023..14d943bfe2b 100644
--- a/engine/src/flutter/display_list/testing/dl_test_surface_provider.h
+++ b/engine/src/flutter/display_list/testing/dl_test_surface_provider.h
@@ -9,6 +9,7 @@
 
 #include "flutter/display_list/display_list.h"
 #include "flutter/display_list/image/dl_image.h"
+#include "flutter/display_list/skia/dl_sk_canvas.h"
 #include "flutter/fml/mapping.h"
 #include "flutter/testing/testing.h"
 
@@ -32,6 +33,8 @@ class DlSurfaceInstance {
   virtual ~DlSurfaceInstance() = default;
 
   virtual sk_sp<SkSurface> sk_surface() const = 0;
+  virtual DlCanvas* GetCanvas() = 0;
+  void FlushSubmitCpuSync();
 
   int width() const { return sk_surface()->width(); }
   int height() const { return sk_surface()->height(); }
@@ -40,13 +43,15 @@ class DlSurfaceInstance {
 class DlSurfaceInstanceBase : public DlSurfaceInstance {
  public:
   explicit DlSurfaceInstanceBase(sk_sp<SkSurface> surface)
-      : surface_(std::move(surface)) {}
+      : surface_(std::move(surface)), adapter_(surface_->getCanvas()) {}
   ~DlSurfaceInstanceBase() = default;
 
   sk_sp<SkSurface> sk_surface() const override { return surface_; }
+  DlCanvas* GetCanvas() override { return &adapter_; }
 
  private:
   sk_sp<SkSurface> surface_;
+  DlSkCanvasAdapter adapter_;
 };
 
 class DlSurfaceProvider {
diff --git a/engine/src/flutter/impeller/display_list/dl_image_impeller.cc b/engine/src/flutter/impeller/display_list/dl_image_impeller.cc
index 33148f4b027..6b7a198c7f2 100644
--- a/engine/src/flutter/impeller/display_list/dl_image_impeller.cc
+++ b/engine/src/flutter/impeller/display_list/dl_image_impeller.cc
@@ -109,6 +109,13 @@ SkISize DlImageImpeller::dimensions() const {
   return SkISize::Make(size.width, size.height);
 }
 
+// |DlImage|
+flutter::DlISize DlImageImpeller::GetSize() const {
+  // texture |GetSize()| returns a 64-bit size, but we need a 32-bit size,
+  // so we need to convert to DlISize (the 32-bit variant) either way.
+  return texture_ ? flutter::DlISize(texture_->GetSize()) : flutter::DlISize();
+}
+
 // |DlImage|
 size_t DlImageImpeller::GetApproximateByteSize() const {
   auto size = sizeof(*this);
diff --git a/engine/src/flutter/impeller/display_list/dl_image_impeller.h b/engine/src/flutter/impeller/display_list/dl_image_impeller.h
index 0faf2f1491a..8d32e815763 100644
--- a/engine/src/flutter/impeller/display_list/dl_image_impeller.h
+++ b/engine/src/flutter/impeller/display_list/dl_image_impeller.h
@@ -50,6 +50,9 @@ class DlImageImpeller final : public flutter::DlImage {
   // |DlImage|
   SkISize dimensions() const override;
 
+  // |DlImage|
+  flutter::DlISize GetSize() const override;
+
   // |DlImage|
   size_t GetApproximateByteSize() const override;
 
diff --git a/engine/src/flutter/impeller/display_list/skia_conversions.h b/engine/src/flutter/impeller/display_list/skia_conversions.h
index 31530cbbe1f..fccf05beab6 100644
--- a/engine/src/flutter/impeller/display_list/skia_conversions.h
+++ b/engine/src/flutter/impeller/display_list/skia_conversions.h
@@ -16,7 +16,6 @@
 #include "impeller/geometry/point.h"
 #include "impeller/geometry/rect.h"
 #include "third_party/skia/include/core/SkColorType.h"
-#include "third_party/skia/include/core/SkPath.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkRRect.h"
 #include "third_party/skia/include/core/SkTextBlob.h"
diff --git a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
index 1881e7058e3..7f8f773eee1 100644
--- a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
+++ b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.cc
@@ -76,6 +76,11 @@ SkISize DlDeferredImageGPUImpeller::dimensions() const {
   return wrapper_->size();
 }
 
+// |DlImage|
+DlISize DlDeferredImageGPUImpeller::GetSize() const {
+  return wrapper_ ? ToDlISize(wrapper_->size()) : DlISize();
+}
+
 // |DlImage|
 size_t DlDeferredImageGPUImpeller::GetApproximateByteSize() const {
   auto size = sizeof(DlDeferredImageGPUImpeller);
diff --git a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
index e0b79bec8df..9244315739f 100644
--- a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
+++ b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_impeller.h
@@ -50,6 +50,9 @@ class DlDeferredImageGPUImpeller final : public DlImage {
   // |DlImage|
   SkISize dimensions() const override;
 
+  // |DlImage|
+  DlISize GetSize() const override;
+
   // |DlImage|
   size_t GetApproximateByteSize() const override;
 
diff --git a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.cc b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
index 634e44f7f07..2222a666374 100644
--- a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
+++ b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.cc
@@ -89,6 +89,12 @@ SkISize DlDeferredImageGPUSkia::dimensions() const {
                         : SkISize::MakeEmpty();
 }
 
+// |DlImage|
+DlISize DlDeferredImageGPUSkia::GetSize() const {
+  return image_wrapper_ ? ToDlISize(image_wrapper_->image_info().dimensions())
+                        : DlISize();
+}
+
 // |DlImage|
 size_t DlDeferredImageGPUSkia::GetApproximateByteSize() const {
   return sizeof(*this) +
diff --git a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h
index 0951b850a74..6a3d28d16f6 100644
--- a/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h
+++ b/engine/src/flutter/lib/ui/painting/display_list_deferred_image_gpu_skia.h
@@ -64,6 +64,9 @@ class DlDeferredImageGPUSkia final : public DlImage {
   // |DlImage|
   SkISize dimensions() const override;
 
+  // |DlImage|
+  DlISize GetSize() const override;
+
   // |DlImage|
   virtual size_t GetApproximateByteSize() const override;
 
diff --git a/engine/src/flutter/lib/ui/painting/display_list_image_gpu.cc b/engine/src/flutter/lib/ui/painting/display_list_image_gpu.cc
index b4e87090534..00327691219 100644
--- a/engine/src/flutter/lib/ui/painting/display_list_image_gpu.cc
+++ b/engine/src/flutter/lib/ui/painting/display_list_image_gpu.cc
@@ -56,6 +56,12 @@ SkISize DlImageGPU::dimensions() const {
   return image ? image->dimensions() : SkISize::MakeEmpty();
 }
 
+// |DlImage|
+DlISize DlImageGPU::GetSize() const {
+  const auto image = skia_image();
+  return image ? ToDlISize(image->dimensions()) : DlISize();
+}
+
 // |DlImage|
 size_t DlImageGPU::GetApproximateByteSize() const {
   auto size = sizeof(*this);
diff --git a/engine/src/flutter/lib/ui/painting/display_list_image_gpu.h b/engine/src/flutter/lib/ui/painting/display_list_image_gpu.h
index 4290c724c8f..9ce63ef1f98 100644
--- a/engine/src/flutter/lib/ui/painting/display_list_image_gpu.h
+++ b/engine/src/flutter/lib/ui/painting/display_list_image_gpu.h
@@ -36,6 +36,9 @@ class DlImageGPU final : public DlImage {
   // |DlImage|
   SkISize dimensions() const override;
 
+  // |DlImage|
+  DlISize GetSize() const override;
+
   // |DlImage|
   virtual size_t GetApproximateByteSize() const override;
 
diff --git a/engine/src/flutter/lib/ui/painting/image_encoding_unittests.cc b/engine/src/flutter/lib/ui/painting/image_encoding_unittests.cc
index db4afca5f7e..5c9fc173d6b 100644
--- a/engine/src/flutter/lib/ui/painting/image_encoding_unittests.cc
+++ b/engine/src/flutter/lib/ui/painting/image_encoding_unittests.cc
@@ -44,6 +44,7 @@ class MockDlImage : public DlImage {
   MOCK_METHOD(bool, isTextureBacked, (), (const, override));
   MOCK_METHOD(bool, isUIThreadSafe, (), (const, override));
   MOCK_METHOD(SkISize, dimensions, (), (const, override));
+  MOCK_METHOD(DlISize, GetSize, (), (const, override));
   MOCK_METHOD(size_t, GetApproximateByteSize, (), (const, override));
 };