Remove HardwareCanvas

Change-Id: I239646a7f00f09d3f76fe6b6162eed86bc0d6e77

9 files changed, 89 insertions, 167 deletions

diff --git a/core/java/android/view/DisplayListCanvas.java b/core/java/android/view/DisplayListCanvas.java
index 90e1f86..3caf6f0 100644
--- a/core/java/android/view/DisplayListCanvas.java
+++ b/core/java/android/view/DisplayListCanvas.java
@@ -18,6 +18,7 @@ package android.view;
 
 import android.annotation.NonNull;
 import android.graphics.Bitmap;
+import android.graphics.Canvas;
 import android.graphics.CanvasProperty;
 import android.graphics.NinePatch;
 import android.graphics.Paint;
@@ -32,8 +33,10 @@ import android.util.Pools.SynchronizedPool;
  * This is intended for use with a DisplayList. This class keeps a list of all the Paint and
  * Bitmap objects that it draws, preventing the backing memory of Bitmaps from being freed while
  * the DisplayList is still holding a native reference to the memory.
+ *
+ * @hide
  */
-class DisplayListCanvas extends HardwareCanvas {
+public class DisplayListCanvas extends Canvas {
     // The recording canvas pool should be large enough to handle a deeply nested
     // view hierarchy because display lists are generated recursively.
     private static final int POOL_LIMIT = 25;
@@ -85,7 +88,6 @@ class DisplayListCanvas extends HardwareCanvas {
     // Constructors
     ///////////////////////////////////////////////////////////////////////////
 
-
     private DisplayListCanvas() {
         super(nCreateDisplayListRenderer());
     }
@@ -103,6 +105,16 @@ class DisplayListCanvas extends HardwareCanvas {
     ///////////////////////////////////////////////////////////////////////////
 
     @Override
+    public boolean isHardwareAccelerated() {
+        return true;
+    }
+
+    @Override
+    public void setBitmap(Bitmap bitmap) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
     public boolean isOpaque() {
         return false;
     }
@@ -171,7 +183,11 @@ class DisplayListCanvas extends HardwareCanvas {
 
     private static native void nInsertReorderBarrier(long renderer, boolean enableReorder);
 
-    @Override
+    /**
+     * Invoked before any drawing operation is performed in this canvas.
+     *
+     * @param dirty The dirty rectangle to update, can be null.
+     */
     public void onPreDraw(Rect dirty) {
         if (dirty != null) {
             nPrepareDirty(mNativeCanvasWrapper, dirty.left, dirty.top, dirty.right, dirty.bottom);
@@ -183,7 +199,9 @@ class DisplayListCanvas extends HardwareCanvas {
     private static native void nPrepare(long renderer);
     private static native void nPrepareDirty(long renderer, int left, int top, int right, int bottom);
 
-    @Override
+    /**
+     * Invoked after all drawing operation have been performed.
+     */
     public void onPostDraw() {
         nFinish(mNativeCanvasWrapper);
     }
@@ -194,7 +212,13 @@ class DisplayListCanvas extends HardwareCanvas {
     // Functor
     ///////////////////////////////////////////////////////////////////////////
 
-    @Override
+    /**
+     * Calls the function specified with the drawGLFunction function pointer. This is
+     * functionality used by webkit for calling into their renderer from our display lists.
+     * This function may return true if an invalidation is needed after the call.
+     *
+     * @param drawGLFunction A native function pointer
+     */
     public void callDrawGLFunction2(long drawGLFunction) {
         nCallDrawGLFunction(mNativeCanvasWrapper, drawGLFunction);
     }
@@ -207,7 +231,23 @@ class DisplayListCanvas extends HardwareCanvas {
 
     protected static native long nFinishRecording(long renderer);
 
-    @Override
+    /**
+     * Draws the specified display list onto this canvas. The display list can only
+     * be drawn if {@link android.view.RenderNode#isValid()} returns true.
+     *
+     * @param renderNode The RenderNode to replay.
+     */
+    public void drawRenderNode(RenderNode renderNode) {
+        drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);
+    }
+
+    /**
+     * Draws the specified display list onto this canvas.
+     *
+     * @param renderNode The RenderNode to replay.
+     * @param flags Optional flags about drawing, see {@link RenderNode} for
+     *              the possible flags.
+     */
     public void drawRenderNode(RenderNode renderNode, int flags) {
         nDrawRenderNode(mNativeCanvasWrapper, renderNode.getNativeDisplayList(), flags);
     }
@@ -219,6 +259,14 @@ class DisplayListCanvas extends HardwareCanvas {
     // Hardware layer
     ///////////////////////////////////////////////////////////////////////////
 
+    /**
+     * Draws the specified layer onto this canvas.
+     *
+     * @param layer The layer to composite on this canvas
+     * @param x The left coordinate of the layer
+     * @param y The top coordinate of the layer
+     * @param paint The paint used to draw the layer
+     */
     void drawHardwareLayer(HardwareLayer layer, float x, float y, Paint paint) {
         layer.setLayerPaint(paint);
         nDrawLayer(mNativeCanvasWrapper, layer.getLayerHandle(), x, y);
@@ -253,7 +301,6 @@ class DisplayListCanvas extends HardwareCanvas {
     private static native void nDrawPatch(long renderer, long bitmap, long chunk,
             float left, float top, float right, float bottom, long paint);
 
-    @Override
     public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
             CanvasProperty<Float> radius, CanvasProperty<Paint> paint) {
         nDrawCircle(mNativeCanvasWrapper, cx.getNativeContainer(), cy.getNativeContainer(),
@@ -263,7 +310,6 @@ class DisplayListCanvas extends HardwareCanvas {
     private static native void nDrawCircle(long renderer, long propCx,
             long propCy, long propRadius, long propPaint);
 
-    @Override
     public void drawRoundRect(CanvasProperty<Float> left, CanvasProperty<Float> top,
             CanvasProperty<Float> right, CanvasProperty<Float> bottom, CanvasProperty<Float> rx,
             CanvasProperty<Float> ry, CanvasProperty<Paint> paint) {
diff --git a/core/java/android/view/GhostView.java b/core/java/android/view/GhostView.java
index 20baad0..d58e7c0 100644
--- a/core/java/android/view/GhostView.java
+++ b/core/java/android/view/GhostView.java
@@ -46,14 +46,14 @@ public class GhostView extends View {
 
     @Override
     protected void onDraw(Canvas canvas) {
-        if (canvas instanceof HardwareCanvas) {
-            HardwareCanvas hwCanvas = (HardwareCanvas) canvas;
+        if (canvas instanceof DisplayListCanvas) {
+            DisplayListCanvas dlCanvas = (DisplayListCanvas) canvas;
             mView.mRecreateDisplayList = true;
             RenderNode renderNode = mView.getDisplayList();
             if (renderNode.isValid()) {
-                hwCanvas.insertReorderBarrier(); // enable shadow for this rendernode
-                hwCanvas.drawRenderNode(renderNode);
-                hwCanvas.insertInorderBarrier(); // re-disable reordering/shadows
+                dlCanvas.insertReorderBarrier(); // enable shadow for this rendernode
+                dlCanvas.drawRenderNode(renderNode);
+                dlCanvas.insertInorderBarrier(); // re-disable reordering/shadows
             }
         }
     }
diff --git a/core/java/android/view/HardwareCanvas.java b/core/java/android/view/HardwareCanvas.java
deleted file mode 100644
index fc2b55b..0000000
--- a/core/java/android/view/HardwareCanvas.java
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.view;
-
-import android.graphics.Bitmap;
-import android.graphics.Canvas;
-import android.graphics.CanvasProperty;
-import android.graphics.Paint;
-import android.graphics.Rect;
-
-/**
- * Hardware accelerated canvas.
- *
- * @hide
- */
-public abstract class HardwareCanvas extends Canvas {
-
-    /**
-     * Pass a reference to the native renderer to our superclass's
-     * constructor.
-     */
-    protected HardwareCanvas(long renderer) {
-        super(renderer);
-    }
-
-    @Override
-    public boolean isHardwareAccelerated() {
-        return true;
-    }
-
-    @Override
-    public void setBitmap(Bitmap bitmap) {
-        throw new UnsupportedOperationException();
-    }
-
-    /**
-     * Invoked before any drawing operation is performed in this canvas.
-     *
-     * @param dirty The dirty rectangle to update, can be null.
-     *
-     * @hide
-     */
-    public abstract void onPreDraw(Rect dirty);
-
-    /**
-     * Invoked after all drawing operation have been performed.
-     *
-     * @hide
-     */
-    public abstract void onPostDraw();
-
-    /**
-     * Draws the specified display list onto this canvas. The display list can only
-     * be drawn if {@link android.view.RenderNode#isValid()} returns true.
-     *
-     * @param renderNode The RenderNode to replay.
-     */
-    public void drawRenderNode(RenderNode renderNode) {
-        drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);
-    }
-
-    /**
-     * Draws the specified display list onto this canvas.
-     *
-     * @param renderNode The RenderNode to replay.
-     * @param dirty Ignored, can be null.
-     * @param flags Optional flags about drawing, see {@link RenderNode} for
-     *              the possible flags.
-     *
-     * @hide
-     */
-    public abstract void drawRenderNode(RenderNode renderNode, int flags);
-
-    /**
-     * Draws the specified layer onto this canvas.
-     *
-     * @param layer The layer to composite on this canvas
-     * @param x The left coordinate of the layer
-     * @param y The top coordinate of the layer
-     * @param paint The paint used to draw the layer
-     *
-     * @hide
-     */
-    abstract void drawHardwareLayer(HardwareLayer layer, float x, float y, Paint paint);
-
-    /**
-     * Calls the function specified with the drawGLFunction function pointer. This is
-     * functionality used by webkit for calling into their renderer from our display lists.
-     * This function may return true if an invalidation is needed after the call.
-     *
-     * @param drawGLFunction A native function pointer
-     *
-     * @hide
-     */
-    public void callDrawGLFunction2(long drawGLFunction) {
-        // Noop - this is done in the display list recorder subclass
-    }
-
-    public abstract void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
-            CanvasProperty<Float> radius, CanvasProperty<Paint> paint);
-
-    public abstract void drawRoundRect(CanvasProperty<Float> left, CanvasProperty<Float> top,
-            CanvasProperty<Float> right, CanvasProperty<Float> bottom,
-            CanvasProperty<Float> rx, CanvasProperty<Float> ry,
-            CanvasProperty<Paint> paint);
-
-    public static void setProperty(String name, String value) {
-        DisplayListCanvas.setProperty(name, value);
-    }
-}
diff --git a/core/java/android/view/HardwareRenderer.java b/core/java/android/view/HardwareRenderer.java
index afa7f51..6632f39 100644
--- a/core/java/android/view/HardwareRenderer.java
+++ b/core/java/android/view/HardwareRenderer.java
@@ -326,7 +326,7 @@ public abstract class HardwareRenderer {
          *
          * @param canvas The Canvas used to render the view.
          */
-        void onHardwarePreDraw(HardwareCanvas canvas);
+        void onHardwarePreDraw(DisplayListCanvas canvas);
 
         /**
          * Invoked after a view is drawn by a hardware renderer.
@@ -334,7 +334,7 @@ public abstract class HardwareRenderer {
          *
          * @param canvas The Canvas used to render the view.
          */
-        void onHardwarePostDraw(HardwareCanvas canvas);
+        void onHardwarePostDraw(DisplayListCanvas canvas);
     }
 
     /**
diff --git a/core/java/android/view/RenderNode.java b/core/java/android/view/RenderNode.java
index 38867a8..ef98bbc 100644
--- a/core/java/android/view/RenderNode.java
+++ b/core/java/android/view/RenderNode.java
@@ -26,7 +26,7 @@ import android.graphics.Rect;
 /**
  * <p>A display list records a series of graphics related operations and can replay
  * them later. Display lists are usually built by recording operations on a
- * {@link HardwareCanvas}. Replaying the operations from a display list avoids
+ * {@link DisplayListCanvas}. Replaying the operations from a display list avoids
  * executing application code on every frame, and is thus much more efficient.</p>
  *
  * <p>Display lists are used internally for all views by default, and are not
@@ -43,7 +43,7 @@ import android.graphics.Rect;
  * affected paragraph needs to be recorded again.</p>
  *
  * <h3>Hardware acceleration</h3>
- * <p>Display lists can only be replayed using a {@link HardwareCanvas}. They are not
+ * <p>Display lists can only be replayed using a {@link DisplayListCanvas}. They are not
  * supported in software. Always make sure that the {@link android.graphics.Canvas}
  * you are using to render a display list is hardware accelerated using
  * {@link android.graphics.Canvas#isHardwareAccelerated()}.</p>
@@ -53,7 +53,7 @@ import android.graphics.Rect;
  *     HardwareRenderer renderer = myView.getHardwareRenderer();
  *     if (renderer != null) {
  *         DisplayList displayList = renderer.createDisplayList();
- *         HardwareCanvas canvas = displayList.start(width, height);
+ *         DisplayListCanvas canvas = displayList.start(width, height);
  *         try {
  *             // Draw onto the canvas
  *             // For instance: canvas.drawBitmap(...);
@@ -67,8 +67,8 @@ import android.graphics.Rect;
  * <pre class="prettyprint">
  *     protected void onDraw(Canvas canvas) {
  *         if (canvas.isHardwareAccelerated()) {
- *             HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;
- *             hardwareCanvas.drawDisplayList(mDisplayList);
+ *             DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
+ *             displayListCanvas.drawDisplayList(mDisplayList);
  *         }
  *     }
  * </pre>
@@ -92,7 +92,7 @@ import android.graphics.Rect;
  * <pre class="prettyprint">
  *     private void createDisplayList() {
  *         mDisplayList = DisplayList.create("MyDisplayList");
- *         HardwareCanvas canvas = mDisplayList.start(width, height);
+ *         DisplayListCanvas canvas = mDisplayList.start(width, height);
  *         try {
  *             for (Bitmap b : mBitmaps) {
  *                 canvas.drawBitmap(b, 0.0f, 0.0f, null);
@@ -105,8 +105,8 @@ import android.graphics.Rect;
  *
  *     protected void onDraw(Canvas canvas) {
  *         if (canvas.isHardwareAccelerated()) {
- *             HardwareCanvas hardwareCanvas = (HardwareCanvas) canvas;
- *             hardwareCanvas.drawDisplayList(mDisplayList);
+ *             DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
+ *             displayListCanvas.drawDisplayList(mDisplayList);
  *         }
  *     }
  *
@@ -128,7 +128,7 @@ import android.graphics.Rect;
 public class RenderNode {
     /**
      * Flag used when calling
-     * {@link HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)}
+     * {@link DisplayListCanvas#drawRenderNode
      * When this flag is set, draw operations lying outside of the bounds of the
      * display list will be culled early. It is recommeneded to always set this
      * flag.
@@ -140,29 +140,29 @@ public class RenderNode {
     /**
      * Indicates that the display list is done drawing.
      *
-     * @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)
+     * @see DisplayListCanvas#drawRenderNode(RenderNode, int)
      */
     public static final int STATUS_DONE = 0x0;
 
     /**
      * Indicates that the display list needs another drawing pass.
      *
-     * @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)
+     * @see DisplayListCanvas#drawRenderNode(RenderNode, int)
      */
     public static final int STATUS_DRAW = 0x1;
 
     /**
      * Indicates that the display list needs to re-execute its GL functors.
      *
-     * @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)
-     * @see HardwareCanvas#callDrawGLFunction(long)
+     * @see DisplayListCanvas#drawRenderNode(RenderNode, int)
+     * @see DisplayListCanvas#callDrawGLFunction2(long)
      */
     public static final int STATUS_INVOKE = 0x2;
 
     /**
      * Indicates that the display list performed GL drawing operations.
      *
-     * @see HardwareCanvas#drawRenderNode(RenderNode, android.graphics.Rect, int)
+     * @see DisplayListCanvas#drawRenderNode(RenderNode, int)
      */
     public static final int STATUS_DREW = 0x4;
 
@@ -213,7 +213,7 @@ public class RenderNode {
      * stored in this display list.
      *
      * Calling this method will mark the render node invalid until
-     * {@link #end(HardwareCanvas)} is called.
+     * {@link #end(DisplayListCanvas)} is called.
      * Only valid render nodes can be replayed.
      *
      * @param width The width of the recording viewport
@@ -221,11 +221,11 @@ public class RenderNode {
      *
      * @return A canvas to record drawing operations.
      *
-     * @see #end(HardwareCanvas)
+     * @see #end(DisplayListCanvas)
      * @see #isValid()
      */
-    public HardwareCanvas start(int width, int height) {
-        HardwareCanvas canvas = DisplayListCanvas.obtain(this);
+    public DisplayListCanvas start(int width, int height) {
+        DisplayListCanvas canvas = DisplayListCanvas.obtain(this);
         canvas.setViewport(width, height);
         // The dirty rect should always be null for a display list
         canvas.onPreDraw(null);
@@ -240,7 +240,7 @@ public class RenderNode {
      * @see #start(int, int)
      * @see #isValid()
      */
-    public void end(HardwareCanvas endCanvas) {
+    public void end(DisplayListCanvas endCanvas) {
         if (!(endCanvas instanceof DisplayListCanvas)) {
             throw new IllegalArgumentException("Passed an invalid canvas to end!");
         }
diff --git a/core/java/android/view/Surface.java b/core/java/android/view/Surface.java
index 83b8100..6de4d3e 100644
--- a/core/java/android/view/Surface.java
+++ b/core/java/android/view/Surface.java
@@ -572,7 +572,7 @@ public class Surface implements Parcelable {
     private final class HwuiContext {
         private final RenderNode mRenderNode;
         private long mHwuiRenderer;
-        private HardwareCanvas mCanvas;
+        private DisplayListCanvas mCanvas;
 
         HwuiContext() {
             mRenderNode = RenderNode.create("HwuiCanvas", null);
diff --git a/core/java/android/view/ThreadedRenderer.java b/core/java/android/view/ThreadedRenderer.java
index 69b4c47..0ee3b6a 100644
--- a/core/java/android/view/ThreadedRenderer.java
+++ b/core/java/android/view/ThreadedRenderer.java
@@ -282,7 +282,7 @@ public class ThreadedRenderer extends HardwareRenderer {
         updateViewTreeDisplayList(view);
 
         if (mRootNodeNeedsUpdate || !mRootNode.isValid()) {
-            HardwareCanvas canvas = mRootNode.start(mSurfaceWidth, mSurfaceHeight);
+            DisplayListCanvas canvas = mRootNode.start(mSurfaceWidth, mSurfaceHeight);
             try {
                 final int saveCount = canvas.save();
                 canvas.translate(mInsetLeft, mInsetTop);
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 7d49969..9c971ea 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -14179,7 +14179,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
             int height = mBottom - mTop;
             int layerType = getLayerType();
 
-            final HardwareCanvas canvas = renderNode.start(width, height);
+            final DisplayListCanvas canvas = renderNode.start(width, height);
             canvas.setHighContrastText(mAttachInfo.mHighContrastText);
 
             try {
@@ -15160,7 +15160,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
                 if (layer != null && layer.isValid()) {
                     int restoreAlpha = mLayerPaint.getAlpha();
                     mLayerPaint.setAlpha((int) (alpha * 255));
-                    ((HardwareCanvas) canvas).drawHardwareLayer(layer, 0, 0, mLayerPaint);
+                    ((DisplayListCanvas) canvas).drawHardwareLayer(layer, 0, 0, mLayerPaint);
                     mLayerPaint.setAlpha(restoreAlpha);
                     layerRendered = true;
                 } else {
@@ -15183,7 +15183,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
                     }
                 } else {
                     mPrivateFlags &= ~PFLAG_DIRTY_MASK;
-                    ((HardwareCanvas) canvas).drawRenderNode(renderNode, flags);
+                    ((DisplayListCanvas) canvas).drawRenderNode(renderNode, flags);
                 }
             }
         } else if (cache != null) {
@@ -15457,7 +15457,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
             final RenderNode renderNode = mBackgroundRenderNode;
             if (renderNode != null && renderNode.isValid()) {
                 setBackgroundRenderNodeProperties(renderNode);
-                ((HardwareCanvas) canvas).drawRenderNode(renderNode);
+                ((DisplayListCanvas) canvas).drawRenderNode(renderNode);
                 return;
             }
         }
@@ -15494,7 +15494,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
         final Rect bounds = drawable.getBounds();
         final int width = bounds.width();
         final int height = bounds.height();
-        final HardwareCanvas canvas = renderNode.start(width, height);
+        final DisplayListCanvas canvas = renderNode.start(width, height);
 
         // Reverse left/top translation done by drawable canvas, which will
         // instead be applied by rendernode's LTRB bounds below. This way, the
diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java
index 14b867e..ed86dd9 100644
--- a/core/java/android/view/ViewRootImpl.java
+++ b/core/java/android/view/ViewRootImpl.java
@@ -2286,12 +2286,12 @@ public final class ViewRootImpl implements ViewParent,
     final Paint mResizePaint = new Paint();
 
     @Override
-    public void onHardwarePreDraw(HardwareCanvas canvas) {
+    public void onHardwarePreDraw(DisplayListCanvas canvas) {
         canvas.translate(-mHardwareXOffset, -mHardwareYOffset);
     }
 
     @Override
-    public void onHardwarePostDraw(HardwareCanvas canvas) {
+    public void onHardwarePostDraw(DisplayListCanvas canvas) {
         if (mResizeBuffer != null) {
             mResizePaint.setAlpha(mResizeAlpha);
             canvas.drawHardwareLayer(mResizeBuffer, mHardwareXOffset, mHardwareYOffset,