Merge "Remove HardwareCanvas"

16 files changed, 124 insertions, 202 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 51fefe9..031be07 100644
--- a/core/java/android/view/ThreadedRenderer.java
+++ b/core/java/android/view/ThreadedRenderer.java
@@ -276,7 +276,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 d345bed..f5de8e3 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -14216,7 +14216,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 {
@@ -15197,7 +15197,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 {
@@ -15220,7 +15220,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) {
@@ -15494,7 +15494,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;
             }
         }
@@ -15531,7 +15531,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 1473806..e790d4c 100644
--- a/core/java/android/view/ViewRootImpl.java
+++ b/core/java/android/view/ViewRootImpl.java
@@ -2309,12 +2309,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,
diff --git a/core/java/android/webkit/WebViewDelegate.java b/core/java/android/webkit/WebViewDelegate.java
index ac360fa..23af384 100644
--- a/core/java/android/webkit/WebViewDelegate.java
+++ b/core/java/android/webkit/WebViewDelegate.java
@@ -25,7 +25,7 @@ import android.graphics.Canvas;
 import android.os.SystemProperties;
 import android.os.Trace;
 import android.util.SparseArray;
-import android.view.HardwareCanvas;
+import android.view.DisplayListCanvas;
 import android.view.View;
 import android.view.ViewRootImpl;
 
@@ -101,12 +101,12 @@ public final class WebViewDelegate {
      * @throws IllegalArgumentException if the canvas is not hardware accelerated
      */
     public void callDrawGlFunction(Canvas canvas, long nativeDrawGLFunctor) {
-        if (!(canvas instanceof HardwareCanvas)) {
+        if (!(canvas instanceof DisplayListCanvas)) {
             // Canvas#isHardwareAccelerated() is only true for subclasses of HardwareCanvas.
             throw new IllegalArgumentException(canvas.getClass().getName()
-                    + " is not hardware accelerated");
+                    + " is not a DisplayList canvas");
         }
-        ((HardwareCanvas) canvas).callDrawGLFunction2(nativeDrawGLFunctor);
+        ((DisplayListCanvas) canvas).callDrawGLFunction2(nativeDrawGLFunctor);
     }
 
     /**
@@ -153,7 +153,7 @@ public final class WebViewDelegate {
     }
 
     /**
-     * Adds the WebView asset path to {@link AssetManager}.
+     * Adds the WebView asset path to {@link android.content.res.AssetManager}.
      */
     public void addWebViewAssetPath(Context context) {
         context.getAssets().addAssetPath(
diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java
index 8e7e78c..2cb6409 100644
--- a/core/java/android/widget/Editor.java
+++ b/core/java/android/widget/Editor.java
@@ -77,14 +77,14 @@ import android.util.DisplayMetrics;
 import android.util.Log;
 import android.view.ActionMode;
 import android.view.ActionMode.Callback;
-import android.view.RenderNode;
+import android.view.DisplayListCanvas;
 import android.view.DragEvent;
 import android.view.Gravity;
-import android.view.HardwareCanvas;
 import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.MotionEvent;
+import android.view.RenderNode;
 import android.view.View;
 import android.view.View.DragShadowBuilder;
 import android.view.View.OnClickListener;
@@ -1509,18 +1509,18 @@ public class Editor {
 
                     // Rebuild display list if it is invalid
                     if (blockDisplayListIsInvalid) {
-                        final HardwareCanvas hardwareCanvas = blockDisplayList.start(
+                        final DisplayListCanvas displayListCanvas = blockDisplayList.start(
                                 right - left, bottom - top);
                         try {
                             // drawText is always relative to TextView's origin, this translation
                             // brings this range of text back to the top left corner of the viewport
-                            hardwareCanvas.translate(-left, -top);
-                            layout.drawText(hardwareCanvas, blockBeginLine, blockEndLine);
+                            displayListCanvas.translate(-left, -top);
+                            layout.drawText(displayListCanvas, blockBeginLine, blockEndLine);
                             mTextDisplayLists[blockIndex].isDirty = false;
                             // No need to untranslate, previous context is popped after
                             // drawDisplayList
                         } finally {
-                            blockDisplayList.end(hardwareCanvas);
+                            blockDisplayList.end(displayListCanvas);
                             // Same as drawDisplayList below, handled by our TextView's parent
                             blockDisplayList.setClipToBounds(false);
                         }
@@ -1531,7 +1531,7 @@ public class Editor {
                     blockDisplayList.setLeftTopRightBottom(left, top, right, bottom);
                 }
 
-                ((HardwareCanvas) canvas).drawRenderNode(blockDisplayList,
+                ((DisplayListCanvas) canvas).drawRenderNode(blockDisplayList,
                         0 /* no child clipping, our TextView parent enforces it */);
 
                 endOfPreviousBlock = blockEndLine;
diff --git a/graphics/java/android/graphics/drawable/RippleBackground.java b/graphics/java/android/graphics/drawable/RippleBackground.java
index 6d1b1fe..1c14e2f 100644
--- a/graphics/java/android/graphics/drawable/RippleBackground.java
+++ b/graphics/java/android/graphics/drawable/RippleBackground.java
@@ -25,7 +25,7 @@ import android.graphics.CanvasProperty;
 import android.graphics.Paint;
 import android.graphics.Rect;
 import android.util.FloatProperty;
-import android.view.HardwareCanvas;
+import android.view.DisplayListCanvas;
 import android.view.RenderNodeAnimator;
 import android.view.animation.LinearInterpolator;
 
@@ -73,7 +73,7 @@ class RippleBackground extends RippleComponent {
     }
 
     @Override
-    protected boolean drawHardware(HardwareCanvas c) {
+    protected boolean drawHardware(DisplayListCanvas c) {
         c.drawCircle(mPropX, mPropY, mPropRadius, mPropPaint);
         return true;
     }
diff --git a/graphics/java/android/graphics/drawable/RippleComponent.java b/graphics/java/android/graphics/drawable/RippleComponent.java
index 79407f7..7976e82 100644
--- a/graphics/java/android/graphics/drawable/RippleComponent.java
+++ b/graphics/java/android/graphics/drawable/RippleComponent.java
@@ -20,7 +20,7 @@ import android.animation.Animator;
 import android.graphics.Canvas;
 import android.graphics.Paint;
 import android.graphics.Rect;
-import android.view.HardwareCanvas;
+import android.view.DisplayListCanvas;
 import android.view.RenderNodeAnimator;
 
 import java.util.ArrayList;
@@ -36,7 +36,7 @@ abstract class RippleComponent {
     protected final Rect mBounds;
 
     /** Whether we can use hardware acceleration for the exit animation. */
-    private boolean mHasHardwareCanvas;
+    private boolean mHasDisplayListCanvas;
 
     private boolean mHasPendingHardwareAnimator;
     private RenderNodeAnimatorSet mHardwareAnimator;
@@ -93,7 +93,7 @@ abstract class RippleComponent {
     public final void exit() {
         cancel();
 
-        if (mHasHardwareCanvas) {
+        if (mHasDisplayListCanvas) {
             // We don't have access to a canvas here, but we expect one on the
             // next frame. We'll start the render thread animation then.
             mHasPendingHardwareAnimator = true;
@@ -132,19 +132,19 @@ abstract class RippleComponent {
      * @return {@code true} if something was drawn, {@code false} otherwise
      */
     public boolean draw(Canvas c, Paint p) {
-        final boolean hasHardwareCanvas = c.isHardwareAccelerated()
-                && c instanceof HardwareCanvas;
-        if (mHasHardwareCanvas != hasHardwareCanvas) {
-            mHasHardwareCanvas = hasHardwareCanvas;
+        final boolean hasDisplayListCanvas = c.isHardwareAccelerated()
+                && c instanceof DisplayListCanvas;
+        if (mHasDisplayListCanvas != hasDisplayListCanvas) {
+            mHasDisplayListCanvas = hasDisplayListCanvas;
 
-            if (!hasHardwareCanvas) {
+            if (!hasDisplayListCanvas) {
                 // We've switched from hardware to non-hardware mode. Panic.
                 endHardwareAnimations();
             }
         }
 
-        if (hasHardwareCanvas) {
-            final HardwareCanvas hw = (HardwareCanvas) c;
+        if (hasDisplayListCanvas) {
+            final DisplayListCanvas hw = (DisplayListCanvas) c;
             startPendingAnimation(hw, p);
 
             if (mHardwareAnimator != null) {
@@ -173,7 +173,7 @@ abstract class RippleComponent {
      * @param hw hardware canvas on which the animation should draw
      * @param p paint whose properties the hardware canvas should use
      */
-    private void startPendingAnimation(HardwareCanvas hw, Paint p) {
+    private void startPendingAnimation(DisplayListCanvas hw, Paint p) {
         if (mHasPendingHardwareAnimator) {
             mHasPendingHardwareAnimator = false;
 
@@ -258,7 +258,7 @@ abstract class RippleComponent {
 
     protected abstract RenderNodeAnimatorSet createHardwareExit(Paint p);
 
-    protected abstract boolean drawHardware(HardwareCanvas c);
+    protected abstract boolean drawHardware(DisplayListCanvas c);
 
     protected abstract boolean drawSoftware(Canvas c, Paint p);
 
@@ -279,7 +279,7 @@ abstract class RippleComponent {
             mAnimators.clear();
         }
 
-        public void start(HardwareCanvas target) {
+        public void start(DisplayListCanvas target) {
             if (target == null) {
                 throw new IllegalArgumentException("Hardware canvas must be non-null");
             }
diff --git a/graphics/java/android/graphics/drawable/RippleForeground.java b/graphics/java/android/graphics/drawable/RippleForeground.java
index 334122d..4853b04 100644
--- a/graphics/java/android/graphics/drawable/RippleForeground.java
+++ b/graphics/java/android/graphics/drawable/RippleForeground.java
@@ -27,7 +27,7 @@ import android.graphics.Paint;
 import android.graphics.Rect;
 import android.util.FloatProperty;
 import android.util.MathUtils;
-import android.view.HardwareCanvas;
+import android.view.DisplayListCanvas;
 import android.view.RenderNodeAnimator;
 import android.view.animation.LinearInterpolator;
 
@@ -127,7 +127,7 @@ class RippleForeground extends RippleComponent {
     }
 
     @Override
-    protected boolean drawHardware(HardwareCanvas c) {
+    protected boolean drawHardware(DisplayListCanvas c) {
         c.drawCircle(mPropX, mPropY, mPropRadius, mPropPaint);
         return true;
     }
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/policy/KeyButtonRipple.java b/packages/SystemUI/src/com/android/systemui/statusbar/policy/KeyButtonRipple.java
index a3ebb09..3f63b5f 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/policy/KeyButtonRipple.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/policy/KeyButtonRipple.java
@@ -26,7 +26,7 @@ import android.graphics.ColorFilter;
 import android.graphics.Paint;
 import android.graphics.PixelFormat;
 import android.graphics.drawable.Drawable;
-import android.view.HardwareCanvas;
+import android.view.DisplayListCanvas;
 import android.view.RenderNodeAnimator;
 import android.view.View;
 import android.view.animation.Interpolator;
@@ -106,7 +106,7 @@ public class KeyButtonRipple extends Drawable {
     public void draw(Canvas canvas) {
         mSupportHardware = canvas.isHardwareAccelerated();
         if (mSupportHardware) {
-            drawHardware((HardwareCanvas) canvas);
+            drawHardware((DisplayListCanvas) canvas);
         } else {
             drawSoftware(canvas);
         }
@@ -131,7 +131,7 @@ public class KeyButtonRipple extends Drawable {
         return getBounds().width() > getBounds().height();
     }
 
-    private void drawHardware(HardwareCanvas c) {
+    private void drawHardware(DisplayListCanvas c) {
         if (mDrawingHardwareGlow) {
             c.drawRoundRect(mLeftProp, mTopProp, mRightProp, mBottomProp, mRxProp, mRyProp,
                     mPaintProp);
diff --git a/tests/HwAccelerationTest/src/com/android/test/hwui/CirclePropActivity.java b/tests/HwAccelerationTest/src/com/android/test/hwui/CirclePropActivity.java
index afd6a8d..5bc8934 100644
--- a/tests/HwAccelerationTest/src/com/android/test/hwui/CirclePropActivity.java
+++ b/tests/HwAccelerationTest/src/com/android/test/hwui/CirclePropActivity.java
@@ -24,7 +24,7 @@ import android.graphics.Paint;
 import android.graphics.Paint.Style;
 import android.os.Bundle;
 import android.os.Trace;
-import android.view.HardwareCanvas;
+import android.view.DisplayListCanvas;
 import android.view.RenderNodeAnimator;
 import android.view.View;
 import android.widget.LinearLayout;
@@ -88,8 +88,8 @@ public class CirclePropActivity extends Activity {
             super.onDraw(canvas);
 
             if (canvas.isHardwareAccelerated()) {
-                HardwareCanvas hwcanvas = (HardwareCanvas) canvas;
-                hwcanvas.drawCircle(mX, mY, mRadius, mPaint);
+                DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
+                displayListCanvas.drawCircle(mX, mY, mRadius, mPaint);
             }
         }