Switch CanvasClient to lambdas

Change-Id: If5f02fe14e1f47699468bb4295bbb967b0fd7066
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/BitmapFilterTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/BitmapFilterTests.java
index d0820e2..a2f0305 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/BitmapFilterTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/BitmapFilterTests.java
@@ -16,7 +16,6 @@
 package android.uirendering.cts.testclasses;
 
 import android.graphics.Bitmap;
-import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.PaintFlagsDrawFilter;
@@ -112,18 +111,15 @@
         final Paint paint = new Paint(filterEnum.equals(FilterEnum.ADD_FILTER) ?
                 0 : Paint.FILTER_BITMAP_FLAG);
 
-        CanvasClient canvasClient = new CanvasClient() {
-            @Override
-            public void draw(Canvas canvas, int width, int height) {
-                canvas.scale(1.0f * width / gridWidth, 1.0f * height / gridWidth);
-                if (filterEnum.equals(FilterEnum.ADD_FILTER)) {
-                    canvas.setDrawFilter(new PaintFlagsDrawFilter(0, Paint.FILTER_BITMAP_FLAG));
-                } else if (filterEnum.equals(FilterEnum.REMOVE_FILTER)) {
-                    canvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.FILTER_BITMAP_FLAG, 0));
-                }
-                canvas.drawBitmap(scaleUp ? mSmallGridBitmap : mBigGridBitmap, 0, 0, paint);
-                canvas.setDrawFilter(null);
+        CanvasClient canvasClient = (canvas, width, height) -> {
+            canvas.scale(1.0f * width / gridWidth, 1.0f * height / gridWidth);
+            if (filterEnum.equals(FilterEnum.ADD_FILTER)) {
+                canvas.setDrawFilter(new PaintFlagsDrawFilter(0, Paint.FILTER_BITMAP_FLAG));
+            } else if (filterEnum.equals(FilterEnum.REMOVE_FILTER)) {
+                canvas.setDrawFilter(new PaintFlagsDrawFilter(Paint.FILTER_BITMAP_FLAG, 0));
             }
+            canvas.drawBitmap(scaleUp ? mSmallGridBitmap : mBigGridBitmap, 0, 0, paint);
+            canvas.setDrawFilter(null);
         };
         createTest()
                 .addCanvasClient(canvasClient)
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/CanvasStateTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/CanvasStateTests.java
index 38d884d..1e7a832 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/CanvasStateTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/CanvasStateTests.java
@@ -22,7 +22,6 @@
 import android.graphics.Region;
 import android.test.suitebuilder.annotation.MediumTest;
 import android.uirendering.cts.testinfrastructure.ActivityTestBase;
-import android.uirendering.cts.testinfrastructure.CanvasClient;
 import org.junit.Test;
 
 import static org.junit.Assert.assertFalse;
@@ -39,17 +38,14 @@
     @Test
     public void testClipRectReturnValues() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.save();
-                        boolean isNonEmpty = canvas.clipRect(0, 0, 20, 20);
-                        assertTrue("clip state should be non empty", isNonEmpty);
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.save();
+                    boolean isNonEmpty = canvas.clipRect(0, 0, 20, 20);
+                    assertTrue("clip state should be non empty", isNonEmpty);
 
-                        isNonEmpty = canvas.clipRect(0, 40, 20, 60);
-                        assertFalse("clip state should be empty", isNonEmpty);
-                        canvas.restore();
-                    }
+                    isNonEmpty = canvas.clipRect(0, 40, 20, 60);
+                    assertFalse("clip state should be empty", isNonEmpty);
+                    canvas.restore();
                 })
                 .runWithoutVerification();
     }
@@ -57,32 +53,29 @@
     @Test
     public void testClipRegionReturnValues() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.save();
-                        RectF clipRectF = new RectF(0, 0, 20, 20);
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.save();
+                    RectF clipRectF = new RectF(0, 0, 20, 20);
 
-                        assertFalse(canvas.quickReject(0, 0, 20, 20, Canvas.EdgeType.BW));
-                        if (!canvas.isHardwareAccelerated()) {
-                            // SW canvas may not be in View space, so we offset the clipping region
-                            // so it will operate within the canvas client's window.
-                            // (Currently, this isn't necessary, since SW layer size == draw area)
-                            canvas.getMatrix().mapRect(clipRectF);
-                        }
-
-                        Region rectRegion = new Region();
-                        rectRegion.set((int) clipRectF.left, (int) clipRectF.top,
-                                (int) clipRectF.right, (int) clipRectF.bottom);
-
-                        boolean isNonEmpty = canvas.clipRegion(rectRegion);
-                        assertTrue("clip state should be non empty", isNonEmpty);
-
-                        // Note: we don't test that non-intersecting clip regions empty the clip,
-                        // For region clipping, the impl is allowed to return true conservatively
-                        // in many cases.
-                        canvas.restore();
+                    assertFalse(canvas.quickReject(0, 0, 20, 20, Canvas.EdgeType.BW));
+                    if (!canvas.isHardwareAccelerated()) {
+                        // SW canvas may not be in View space, so we offset the clipping region
+                        // so it will operate within the canvas client's window.
+                        // (Currently, this isn't necessary, since SW layer size == draw area)
+                        canvas.getMatrix().mapRect(clipRectF);
                     }
+
+                    Region rectRegion = new Region();
+                    rectRegion.set((int) clipRectF.left, (int) clipRectF.top,
+                            (int) clipRectF.right, (int) clipRectF.bottom);
+
+                    boolean isNonEmpty = canvas.clipRegion(rectRegion);
+                    assertTrue("clip state should be non empty", isNonEmpty);
+
+                    // Note: we don't test that non-intersecting clip regions empty the clip,
+                    // For region clipping, the impl is allowed to return true conservatively
+                    // in many cases.
+                    canvas.restore();
                 })
                 .runWithoutVerification();
     }
@@ -90,40 +83,34 @@
     @Test
     public void testClipPathReturnValues() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.save();
-                        Path rectPath = new Path();
-                        rectPath.addRect(0, 0, 20, 20, Path.Direction.CW);
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.save();
+                    Path rectPath = new Path();
+                    rectPath.addRect(0, 0, 20, 20, Path.Direction.CW);
 
-                        boolean isNonEmpty = canvas.clipPath(rectPath);
-                        assertTrue("clip state should be non empty", isNonEmpty);
+                    boolean isNonEmpty = canvas.clipPath(rectPath);
+                    assertTrue("clip state should be non empty", isNonEmpty);
 
-                        rectPath.offset(0, 40);
-                        isNonEmpty = canvas.clipPath(rectPath);
-                        assertFalse("clip state should be empty", isNonEmpty);
-                        canvas.restore();
-                    }
+                    rectPath.offset(0, 40);
+                    isNonEmpty = canvas.clipPath(rectPath);
+                    assertFalse("clip state should be empty", isNonEmpty);
+                    canvas.restore();
                 })
                 .runWithoutVerification();
     }
     @Test
     public void testQuickReject() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.save();
-                        canvas.clipRect(0, 0, 20, 20);
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.save();
+                    canvas.clipRect(0, 0, 20, 20);
 
-                        // not rejected!
-                        assertFalse(canvas.quickReject(0, 0, 20, 20, Canvas.EdgeType.BW));
+                    // not rejected!
+                    assertFalse(canvas.quickReject(0, 0, 20, 20, Canvas.EdgeType.BW));
 
-                        // rejected!
-                        assertTrue(canvas.quickReject(0, 40, 20, 60, Canvas.EdgeType.BW));
-                        canvas.restore();
-                    }
+                    // rejected!
+                    assertTrue(canvas.quickReject(0, 40, 20, 60, Canvas.EdgeType.BW));
+                    canvas.restore();
                 })
                 .runWithoutVerification();
     }
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/ExactCanvasTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/ExactCanvasTests.java
index bf68f3e..2a2599b 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/ExactCanvasTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/ExactCanvasTests.java
@@ -16,7 +16,6 @@
 
 package android.uirendering.cts.testclasses;
 
-import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Paint;
 import android.graphics.PorterDuff;
@@ -28,7 +27,6 @@
 import android.uirendering.cts.bitmapverifiers.BitmapVerifier;
 import android.uirendering.cts.bitmapverifiers.RectVerifier;
 import android.uirendering.cts.testinfrastructure.ActivityTestBase;
-import android.uirendering.cts.testinfrastructure.CanvasClient;
 import android.uirendering.cts.R;
 import org.junit.Test;
 
@@ -40,14 +38,11 @@
     public void testBlueRect() {
         final Rect rect = new Rect(10, 10, 80, 80);
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint p = new Paint();
-                        p.setAntiAlias(false);
-                        p.setColor(Color.BLUE);
-                        canvas.drawRect(rect, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint p = new Paint();
+                    p.setAntiAlias(false);
+                    p.setColor(Color.BLUE);
+                    canvas.drawRect(rect, p);
                 })
                 .runWithVerifier(new RectVerifier(Color.WHITE, Color.BLUE, rect));
     }
@@ -55,16 +50,13 @@
     @Test
     public void testPoints() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint p = new Paint();
-                        p.setAntiAlias(false);
-                        p.setStrokeWidth(1f);
-                        p.setColor(Color.BLACK);
-                        for (int i = 0; i < 10; i++) {
-                            canvas.drawPoint(i * 10, i * 10, p);
-                        }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint p = new Paint();
+                    p.setAntiAlias(false);
+                    p.setStrokeWidth(1f);
+                    p.setColor(Color.BLACK);
+                    for (int i = 0; i < 10; i++) {
+                        canvas.drawPoint(i * 10, i * 10, p);
                     }
                 })
                 .runWithComparer(mExactComparer);
@@ -73,17 +65,14 @@
     @Test
     public void testBlackRectWithStroke() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint p = new Paint();
-                        p.setColor(Color.RED);
-                        canvas.drawRect(0, 0, ActivityTestBase.TEST_WIDTH,
-                                ActivityTestBase.TEST_HEIGHT, p);
-                        p.setColor(Color.BLACK);
-                        p.setStrokeWidth(5);
-                        canvas.drawRect(10, 10, 80, 80, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint p = new Paint();
+                    p.setColor(Color.RED);
+                    canvas.drawRect(0, 0, ActivityTestBase.TEST_WIDTH,
+                            ActivityTestBase.TEST_HEIGHT, p);
+                    p.setColor(Color.BLACK);
+                    p.setStrokeWidth(5);
+                    canvas.drawRect(10, 10, 80, 80, p);
                 })
                 .runWithComparer(mExactComparer);
     }
@@ -91,15 +80,12 @@
     @Test
     public void testBlackLineOnGreenBack() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.drawColor(Color.GREEN);
-                        Paint p = new Paint();
-                        p.setColor(Color.BLACK);
-                        p.setStrokeWidth(10);
-                        canvas.drawLine(0, 0, 50, 0, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.drawColor(Color.GREEN);
+                    Paint p = new Paint();
+                    p.setColor(Color.BLACK);
+                    p.setStrokeWidth(10);
+                    canvas.drawLine(0, 0, 50, 0, p);
                 })
                 .runWithComparer(mExactComparer);
     }
@@ -107,14 +93,11 @@
     @Test
     public void testDrawRedRectOnBlueBack() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.drawColor(Color.BLUE);
-                        Paint p = new Paint();
-                        p.setColor(Color.RED);
-                        canvas.drawRect(10, 10, 40, 40, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.drawColor(Color.BLUE);
+                    Paint p = new Paint();
+                    p.setColor(Color.RED);
+                    canvas.drawRect(10, 10, 40, 40, p);
                 })
                 .runWithComparer(mExactComparer);
     }
@@ -122,17 +105,14 @@
     @Test
     public void testDrawLine() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint p = new Paint();
-                        canvas.drawColor(Color.WHITE);
-                        p.setColor(Color.BLACK);
-                        float[] pts = {
-                                0, 0, 80, 80, 80, 0, 0, 80, 40, 50, 60, 50
-                        };
-                        canvas.drawLines(pts, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint p = new Paint();
+                    canvas.drawColor(Color.WHITE);
+                    p.setColor(Color.BLACK);
+                    float[] pts = {
+                            0, 0, 80, 80, 80, 0, 0, 80, 40, 50, 60, 50
+                    };
+                    canvas.drawLines(pts, p);
                 })
                 .runWithComparer(mExactComparer);
     }
@@ -140,12 +120,7 @@
     @Test
     public void testDrawWhiteScreen() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.drawColor(Color.WHITE);
-                    }
-                })
+                .addCanvasClient((canvas, width, height) -> canvas.drawColor(Color.WHITE))
                 .runWithComparer(mExactComparer);
     }
 
@@ -153,15 +128,12 @@
     public void testBasicText() {
         final String testString = "THIS IS A TEST";
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint p = new Paint();
-                        canvas.drawColor(Color.BLACK);
-                        p.setColor(Color.WHITE);
-                        p.setStrokeWidth(5);
-                        canvas.drawText(testString, 30, 50, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint p = new Paint();
+                    canvas.drawColor(Color.BLACK);
+                    p.setColor(Color.WHITE);
+                    p.setStrokeWidth(5);
+                    canvas.drawText(testString, 30, 50, p);
                 })
                 .runWithComparer(mExactComparer);
     }
@@ -169,12 +141,9 @@
     @Test
     public void testBasicColorXfermode() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.drawColor(Color.GRAY);
-                        canvas.drawColor(Color.BLUE, PorterDuff.Mode.MULTIPLY);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.drawColor(Color.GRAY);
+                    canvas.drawColor(Color.BLUE, PorterDuff.Mode.MULTIPLY);
                 })
                 .runWithComparer(mExactComparer);
     }
@@ -189,21 +158,13 @@
                 new Rect(10, 10, 80, 80));
 
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.drawColor(Color.WHITE);
-                        Paint p = new Paint();
-                        p.setColor(Color.BLUE);
-                        canvas.drawRect(10, 10, 80, 80, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.drawColor(Color.WHITE);
+                    Paint p = new Paint();
+                    p.setColor(Color.BLUE);
+                    canvas.drawRect(10, 10, 80, 80, p);
                 })
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        ninePatchDrawable.draw(canvas);
-                    }
-                })
+                .addCanvasClient((canvas, width, height) -> ninePatchDrawable.draw(canvas))
                 .addLayout(R.layout.blue_padded_square, null)
                 .runWithVerifier(verifier);
     }
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/FontRenderingTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/FontRenderingTests.java
index 738dcfb..73779d6 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/FontRenderingTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/FontRenderingTests.java
@@ -53,18 +53,15 @@
 
         final Typeface typeface = Typeface.create(family, style);
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint p = new Paint();
-                        p.setAntiAlias(true);
-                        p.setColor(Color.BLACK);
-                        p.setTextSize(26);
-                        p.setTypeface(typeface);
-                        canvas.drawText(sTestString1, 1, 20, p);
-                        canvas.drawText(sTestString2, 1, 50, p);
-                        canvas.drawText(sTestString3, 1, 80, p);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint p = new Paint();
+                    p.setAntiAlias(true);
+                    p.setColor(Color.BLACK);
+                    p.setTextSize(26);
+                    p.setTypeface(typeface);
+                    canvas.drawText(sTestString1, 1, 20, p);
+                    canvas.drawText(sTestString2, 1, 50, p);
+                    canvas.drawText(sTestString3, 1, 80, p);
                 })
                 .runWithVerifier(new GoldenImageVerifier(goldenBitmap, comparer));
     }
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/InfrastructureTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/InfrastructureTests.java
index c070b96..3159cc3 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/InfrastructureTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/InfrastructureTests.java
@@ -19,7 +19,6 @@
 import android.test.suitebuilder.annotation.MediumTest;
 import android.uirendering.cts.R;
 
-import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Rect;
 import android.uirendering.cts.bitmapcomparers.BitmapComparer;
@@ -49,11 +48,8 @@
      */
     @Test
     public void testRenderSpecIsolation() {
-        CanvasClient canvasClient = new CanvasClient() {
-            @Override
-            public void draw(Canvas canvas, int width, int height) {
-                canvas.drawColor(canvas.isHardwareAccelerated() ? Color.BLACK : Color.WHITE);
-            }
+        CanvasClient canvasClient = (canvas, width, height) -> {
+            canvas.drawColor(canvas.isHardwareAccelerated() ? Color.BLACK : Color.WHITE);
         };
         BitmapComparer inverseComparer = new BitmapComparer() {
             @Override
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PathClippingTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PathClippingTests.java
index 03f5e89..4e6dbe0 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PathClippingTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PathClippingTests.java
@@ -40,57 +40,41 @@
 @MediumTest
 public class PathClippingTests extends ActivityTestBase {
     // draw circle with hole in it, with stroked circle
-    static final CanvasClient sTorusDrawCanvasClient = new CanvasClient() {
-        @Override
-        public String getDebugString() {
-            return "TorusDraw";
-        }
-
-        @Override
-        public void draw(Canvas canvas, int width, int height) {
-            Paint paint = new Paint();
-            paint.setAntiAlias(false);
-            paint.setColor(Color.BLUE);
-            paint.setStyle(Paint.Style.STROKE);
-            paint.setStrokeWidth(20);
-            canvas.drawCircle(30, 30, 40, paint);
-        }
+    static final CanvasClient sTorusDrawCanvasClient = (canvas, width, height) -> {
+        Paint paint = new Paint();
+        paint.setAntiAlias(false);
+        paint.setColor(Color.BLUE);
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setStrokeWidth(20);
+        canvas.drawCircle(30, 30, 40, paint);
     };
 
     // draw circle with hole in it, by path operations + path clipping
-    static final CanvasClient sTorusClipCanvasClient = new CanvasClient() {
-        @Override
-        public String getDebugString() {
-            return "TorusClipDraw";
-        }
+    static final CanvasClient sTorusClipCanvasClient = (canvas, width, height) -> {
+        canvas.save();
 
-        @Override
-        public void draw(Canvas canvas, int width, int height) {
-            canvas.save();
+        Path path = new Path();
+        path.addCircle(30, 30, 50, Path.Direction.CW);
+        path.addCircle(30, 30, 30, Path.Direction.CCW);
 
-            Path path = new Path();
-            path.addCircle(30, 30, 50, Path.Direction.CW);
-            path.addCircle(30, 30, 30, Path.Direction.CCW);
+        canvas.clipPath(path);
+        canvas.drawColor(Color.BLUE);
 
-            canvas.clipPath(path);
-            canvas.drawColor(Color.BLUE);
-
-            canvas.restore();
-        }
+        canvas.restore();
     };
 
     @Test
     public void testCircleWithCircle() {
         createTest()
-                .addCanvasClient(sTorusDrawCanvasClient, false)
-                .addCanvasClient(sTorusClipCanvasClient)
+                .addCanvasClient("TorusDraw", sTorusDrawCanvasClient, false)
+                .addCanvasClient("TorusClip", sTorusClipCanvasClient)
                 .runWithComparer(new MSSIMComparer(0.90));
     }
 
     @Test
     public void testCircleWithPoints() {
         createTest()
-                .addCanvasClient(sTorusClipCanvasClient)
+                .addCanvasClient("TorusClip", sTorusClipCanvasClient)
                 .runWithVerifier(new SamplePointVerifier(
                         new Point[] {
                                 // inside of circle
@@ -144,24 +128,21 @@
     @Test
     public void testTextClip() {
         createTest()
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        canvas.save();
+                .addCanvasClient((canvas, width, height) -> {
+                    canvas.save();
 
-                        Path path = new Path();
-                        path.addCircle(0, 45, 45, Path.Direction.CW);
-                        path.addCircle(90, 45, 45, Path.Direction.CW);
-                        canvas.clipPath(path);
+                    Path path = new Path();
+                    path.addCircle(0, 45, 45, Path.Direction.CW);
+                    path.addCircle(90, 45, 45, Path.Direction.CW);
+                    canvas.clipPath(path);
 
-                        Paint paint = new Paint();
-                        paint.setAntiAlias(true);
-                        paint.setTextSize(90);
-                        paint.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));
-                        canvas.drawText("STRING", 0, 90, paint);
+                    Paint paint = new Paint();
+                    paint.setAntiAlias(true);
+                    paint.setTextSize(90);
+                    paint.setTypeface(Typeface.defaultFromStyle(Typeface.BOLD));
+                    canvas.drawText("STRING", 0, 90, paint);
 
-                        canvas.restore();
-                    }
+                    canvas.restore();
                 })
                 .runWithComparer(new MSSIMComparer(0.90));
     }
@@ -173,14 +154,11 @@
         }
         createTest()
                 // golden client - draw a simple non-AA circle
-                .addCanvasClient(new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
-                        Paint paint = new Paint();
-                        paint.setAntiAlias(false);
-                        paint.setColor(Color.BLUE);
-                        canvas.drawOval(0, 0, width, height, paint);
-                    }
+                .addCanvasClient((canvas, width, height) -> {
+                    Paint paint = new Paint();
+                    paint.setAntiAlias(false);
+                    paint.setColor(Color.BLUE);
+                    canvas.drawOval(0, 0, width, height, paint);
                 }, false)
                 // verify against solid color webview, clipped to its parent oval
                 .addLayout(R.layout.circle_clipped_webview, new ViewInitializer() {
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PictureTest.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PictureTest.java
index 9c8f9ba..a2f3730 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PictureTest.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/PictureTest.java
@@ -25,7 +25,6 @@
 import android.uirendering.cts.bitmapverifiers.ColorVerifier;
 import android.uirendering.cts.bitmapverifiers.RectVerifier;
 import android.uirendering.cts.testinfrastructure.ActivityTestBase;
-import android.uirendering.cts.testinfrastructure.CanvasClient;
 import org.junit.Test;
 
 @MediumTest
@@ -38,8 +37,8 @@
         Paint pt = new Paint();
         pt.setColor(Color.GREEN);
         Picture pic = new Picture();
-        Canvas subcanvas = pic.beginRecording(ActivityTestBase.TEST_WIDTH,
-                                              ActivityTestBase.TEST_HEIGHT);
+        Canvas subcanvas = pic.beginRecording(
+                ActivityTestBase.TEST_WIDTH, ActivityTestBase.TEST_HEIGHT);
         subcanvas.drawRect(sRect, pt);
         pic.endRecording();
 
@@ -50,14 +49,11 @@
     public void testPictureRespectsClip() throws Exception {
         createTest()
             .addCanvasClient(
-                new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
+                    (canvas, width, height) -> {
                         Picture pic = greenSquare();
                         canvas.clipRect(sOffsetRect);
                         pic.draw(canvas);  // should be clipped out
                     }
-                }
             ).runWithVerifier(new ColorVerifier(Color.WHITE));
     }
 
@@ -65,14 +61,11 @@
     public void testPictureRespectsTranslate() throws Exception {
         createTest()
             .addCanvasClient(
-                new CanvasClient() {
-                    @Override
-                    public void draw(Canvas canvas, int width, int height) {
+                    (canvas, width, height) -> {
                         Picture pic = greenSquare();
                         canvas.translate(40, 0);
                         pic.draw(canvas);  // should be offset
                     }
-                }
             ).runWithVerifier(
                 new RectVerifier(Color.WHITE, Color.GREEN, sOffsetRect));
     }
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/SweepTests.java b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/SweepTests.java
index f5f59b3..3f51bbe 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testclasses/SweepTests.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testclasses/SweepTests.java
@@ -108,23 +108,21 @@
         ResourceModifier.init(getActivity().getResources());
         // For each modification combination, we will get the CanvasClient associated with it and
         // from there execute a normal canvas test with that.
-        CanvasClient canvasClient = new CanvasClient() {
-            @Override
-            public void draw(Canvas canvas, int width, int height) {
-                Paint paint = new Paint();
-                modifierAccessor.modifyDrawing(canvas, paint);
-                if (drawOp != null) {
-                    drawOp.modifyDrawing(paint, canvas);
-                }
+        CanvasClient canvasClient = (canvas, width, height) -> {
+            Paint paint = new Paint();
+            modifierAccessor.modifyDrawing(canvas, paint);
+            if (drawOp != null) {
+                drawOp.modifyDrawing(paint, canvas);
             }
         };
 
         int index = 0;
         // Create the test cases with each combination
         do {
-            canvasClient.setDebugString(modifierAccessor.getDebugString());
             int arrIndex = Math.min(index, bitmapComparers.length - 1);
-            createTest().addCanvasClient(canvasClient).runWithComparer(bitmapComparers[arrIndex]);
+            createTest()
+                    .addCanvasClient(modifierAccessor.getDebugString(), canvasClient)
+                    .runWithComparer(bitmapComparers[arrIndex]);
             index++;
         } while (modifierAccessor.step());
     }
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/ActivityTestBase.java b/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/ActivityTestBase.java
index f82bb40..e634528 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/ActivityTestBase.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/ActivityTestBase.java
@@ -145,7 +145,7 @@
     protected Bitmap captureRenderSpec(TestCase testCase) {
         Point testOffset = getActivity().enqueueRenderSpecAndWait(
                 testCase.layoutID, testCase.canvasClient,
-                testCase.webViewUrl, testCase.viewInitializer, testCase.useHardware);
+                null, testCase.viewInitializer, testCase.useHardware);
         testCase.wasTestRan = true;
         return takeScreenshot(testOffset);
     }
@@ -260,36 +260,33 @@
             });
         }
 
-        public TestCaseBuilder addWebView(String webViewUrl,
-                @Nullable ViewInitializer viewInitializer) {
-            return addWebView(webViewUrl, viewInitializer, false)
-                    .addWebView(webViewUrl, viewInitializer, true);
-        }
-
         public TestCaseBuilder addLayout(int layoutId, @Nullable ViewInitializer viewInitializer) {
             return addLayout(layoutId, viewInitializer, false)
                     .addLayout(layoutId, viewInitializer, true);
         }
 
-        public TestCaseBuilder addCanvasClient(CanvasClient canvasClient) {
-            return addCanvasClient(canvasClient, false)
-                    .addCanvasClient(canvasClient, true);
-        }
-
-        public TestCaseBuilder addWebView(String webViewUrl,
-                @Nullable ViewInitializer viewInitializer, boolean useHardware) {
-            mTestCases.add(new TestCase(null, 0, webViewUrl, viewInitializer, useHardware));
-            return this;
-        }
-
         public TestCaseBuilder addLayout(int layoutId, @Nullable ViewInitializer viewInitializer,
-                boolean useHardware) {
-            mTestCases.add(new TestCase(null, layoutId, null, viewInitializer, useHardware));
+                                         boolean useHardware) {
+            mTestCases.add(new TestCase(layoutId, viewInitializer, useHardware));
             return this;
         }
 
+        public TestCaseBuilder addCanvasClient(CanvasClient canvasClient) {
+            return addCanvasClient(null, canvasClient);
+        }
+
         public TestCaseBuilder addCanvasClient(CanvasClient canvasClient, boolean useHardware) {
-            mTestCases.add(new TestCase(canvasClient, 0, null, null, useHardware));
+            return addCanvasClient(null, canvasClient, useHardware);
+        }
+
+        public TestCaseBuilder addCanvasClient(String debugString, CanvasClient canvasClient) {
+            return addCanvasClient(debugString, canvasClient, false)
+                    .addCanvasClient(debugString, canvasClient, true);
+        }
+
+        public TestCaseBuilder addCanvasClient(String debugString,
+                    CanvasClient canvasClient, boolean useHardware) {
+            mTestCases.add(new TestCase(canvasClient, debugString, useHardware));
             return this;
         }
 
@@ -300,39 +297,35 @@
 
     private class TestCase {
         public int layoutID;
-        public CanvasClient canvasClient;
-        public String webViewUrl;
         public ViewInitializer viewInitializer;
-        public boolean useHardware;
-        public boolean wasTestRan;
 
-        public TestCase(CanvasClient client, int id, String viewUrl,
-                ViewInitializer viewInitializer, boolean useHardware) {
-            int count = 0;
-            count += (client == null ? 0 : 1);
-            count += (viewUrl == null ? 0 : 1);
-            count += (id == 0 ? 0 : 1);
-            assert(count == 1);
-            assert(client == null || viewInitializer == null);
-            this.layoutID = id;
-            this.canvasClient = client;
-            this.webViewUrl = viewUrl;
+        public CanvasClient canvasClient;
+        public String canvasClientDebugString;
+
+        public boolean useHardware;
+        public boolean wasTestRan = false;
+
+        public TestCase(int layoutId, ViewInitializer viewInitializer, boolean useHardware) {
+            this.layoutID = layoutId;
             this.viewInitializer = viewInitializer;
             this.useHardware = useHardware;
-            this.wasTestRan = false;
+        }
+
+        public TestCase(CanvasClient client, String debugString, boolean useHardware) {
+            this.canvasClient = client;
+            this.canvasClientDebugString = debugString;
+            this.useHardware = useHardware;
         }
 
         public String getDebugString() {
             String debug = "";
             if (canvasClient != null) {
                 debug += "CanvasClient : ";
-                if (canvasClient.getDebugString() != null) {
-                    debug += canvasClient.getDebugString();
+                if (canvasClientDebugString != null) {
+                    debug += canvasClientDebugString;
                 } else {
                     debug += "no debug string given";
                 }
-            } else if (webViewUrl != null) {
-                debug += "WebView URL : " + webViewUrl;
             } else {
                 debug += "Layout resource : " +
                         getActivity().getResources().getResourceName(layoutID);
diff --git a/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/CanvasClient.java b/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/CanvasClient.java
index a99c576..99f6cc7 100644
--- a/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/CanvasClient.java
+++ b/tests/tests/uirendering/src/android/uirendering/cts/testinfrastructure/CanvasClient.java
@@ -20,16 +20,6 @@
 /**
  * A class that the tester will implement and create a set of drawing calls the tests would use
  */
-public abstract class CanvasClient {
-    private String mDebugString;
-
-    public abstract void draw(Canvas canvas, int width, int height);
-
-    public String getDebugString() {
-        return mDebugString;
-    }
-
-    public void setDebugString(String debugString) {
-        mDebugString = debugString;
-    }
+public interface CanvasClient {
+    void draw(Canvas canvas, int width, int height);
 }