Merge "Switch DisplayListData to a staging model"
diff --git a/core/java/android/view/GLRenderer.java b/core/java/android/view/GLRenderer.java
index bcdfda6..b589cc2 100644
--- a/core/java/android/view/GLRenderer.java
+++ b/core/java/android/view/GLRenderer.java
@@ -1226,11 +1226,6 @@
}
}
- void setDisplayListData(long displayList, long newData) {
- nSetDisplayListData(displayList, newData);
- }
- private static native void nSetDisplayListData(long displayList, long newData);
-
@Override
void fence() {
// Everything is immediate, so this is a no-op
@@ -1322,7 +1317,7 @@
}
Trace.traceBegin(Trace.TRACE_TAG_VIEW, "drawDisplayList");
- nUpdateRenderNodeProperties(displayList.getNativeDisplayList());
+ nPushStagingChanges(displayList.getNativeDisplayList());
try {
status |= canvas.drawDisplayList(displayList, mRedrawClip,
RenderNode.FLAG_CLIP_CHILDREN);
@@ -1481,7 +1476,7 @@
static native void nDestroyLayer(long layerPtr);
- private static native void nUpdateRenderNodeProperties(long displayListPtr);
+ private static native void nPushStagingChanges(long displayListPtr);
class DrawPerformanceDataProvider extends GraphDataProvider {
private final int mGraphType;
diff --git a/core/java/android/view/HardwareRenderer.java b/core/java/android/view/HardwareRenderer.java
index 7d46cab..56d96e1 100644
--- a/core/java/android/view/HardwareRenderer.java
+++ b/core/java/android/view/HardwareRenderer.java
@@ -580,8 +580,6 @@
mRequested = requested;
}
- abstract void setDisplayListData(long displayList, long newData);
-
/**
* Blocks until all previously queued work has completed.
*/
diff --git a/core/java/android/view/RenderNode.java b/core/java/android/view/RenderNode.java
index 78ddf5b..30e4281 100644
--- a/core/java/android/view/RenderNode.java
+++ b/core/java/android/view/RenderNode.java
@@ -174,12 +174,10 @@
public static final int STATUS_DREW = 0x4;
private boolean mValid;
- private final long mNativeDisplayList;
- private HardwareRenderer mRenderer;
+ private final long mNativeRenderNode;
private RenderNode(String name) {
- mNativeDisplayList = nCreate();
- nSetDisplayListName(mNativeDisplayList, name);
+ mNativeRenderNode = nCreate(name);
}
/**
@@ -202,7 +200,7 @@
* stored in this display list.
*
* Calling this method will mark the render node invalid until
- * {@link #end(HardwareRenderer, HardwareCanvas)} is called.
+ * {@link #end(HardwareCanvas)} is called.
* Only valid render nodes can be replayed.
*
* @param width The width of the recording viewport
@@ -210,7 +208,7 @@
*
* @return A canvas to record drawing operations.
*
- * @see #end(HardwareRenderer, HardwareCanvas)
+ * @see #end(HardwareCanvas)
* @see #isValid()
*/
public HardwareCanvas start(int width, int height) {
@@ -229,21 +227,15 @@
* @see #start(int, int)
* @see #isValid()
*/
- public void end(HardwareRenderer renderer, HardwareCanvas endCanvas) {
+ public void end(HardwareCanvas endCanvas) {
if (!(endCanvas instanceof GLES20RecordingCanvas)) {
throw new IllegalArgumentException("Passed an invalid canvas to end!");
}
GLES20RecordingCanvas canvas = (GLES20RecordingCanvas) endCanvas;
canvas.onPostDraw();
- long displayListData = canvas.finishRecording();
- if (renderer != mRenderer) {
- // If we are changing renderers first destroy with the old
- // renderer, then set with the new one
- destroyDisplayListData();
- }
- mRenderer = renderer;
- setDisplayListData(displayListData);
+ long renderNodeData = canvas.finishRecording();
+ nSetDisplayListData(mNativeRenderNode, renderNodeData);
canvas.recycle();
mValid = true;
}
@@ -258,19 +250,10 @@
public void destroyDisplayListData() {
if (!mValid) return;
- setDisplayListData(0);
- mRenderer = null;
+ nSetDisplayListData(mNativeRenderNode, 0);
mValid = false;
}
- private void setDisplayListData(long newData) {
- if (mRenderer != null) {
- mRenderer.setDisplayListData(mNativeDisplayList, newData);
- } else {
- throw new IllegalStateException("Trying to set data without a renderer! data=" + newData);
- }
- }
-
/**
* Returns whether the RenderNode's display list content is currently usable.
* If this returns false, the display list should be re-recorded prior to replaying it.
@@ -283,7 +266,7 @@
if (!mValid) {
throw new IllegalStateException("The display list is not valid.");
}
- return mNativeDisplayList;
+ return mNativeRenderNode;
}
///////////////////////////////////////////////////////////////////////////
@@ -291,15 +274,15 @@
///////////////////////////////////////////////////////////////////////////
public boolean hasIdentityMatrix() {
- return nHasIdentityMatrix(mNativeDisplayList);
+ return nHasIdentityMatrix(mNativeRenderNode);
}
public void getMatrix(@NonNull Matrix outMatrix) {
- nGetTransformMatrix(mNativeDisplayList, outMatrix.native_instance);
+ nGetTransformMatrix(mNativeRenderNode, outMatrix.native_instance);
}
public void getInverseMatrix(@NonNull Matrix outMatrix) {
- nGetInverseTransformMatrix(mNativeDisplayList, outMatrix.native_instance);
+ nGetInverseTransformMatrix(mNativeRenderNode, outMatrix.native_instance);
}
///////////////////////////////////////////////////////////////////////////
@@ -316,7 +299,7 @@
* @hide
*/
public void setCaching(boolean caching) {
- nSetCaching(mNativeDisplayList, caching);
+ nSetCaching(mNativeRenderNode, caching);
}
/**
@@ -326,7 +309,7 @@
* @param clipToBounds true if the display list should clip to its bounds
*/
public void setClipToBounds(boolean clipToBounds) {
- nSetClipToBounds(mNativeDisplayList, clipToBounds);
+ nSetClipToBounds(mNativeRenderNode, clipToBounds);
}
/**
@@ -337,7 +320,7 @@
* containing volume.
*/
public void setProjectBackwards(boolean shouldProject) {
- nSetProjectBackwards(mNativeDisplayList, shouldProject);
+ nSetProjectBackwards(mNativeRenderNode, shouldProject);
}
/**
@@ -346,7 +329,7 @@
* ProjectBackwards=true directly on top of it. Default value is false.
*/
public void setProjectionReceiver(boolean shouldRecieve) {
- nSetProjectionReceiver(mNativeDisplayList, shouldRecieve);
+ nSetProjectionReceiver(mNativeRenderNode, shouldRecieve);
}
/**
@@ -357,14 +340,14 @@
*/
public void setOutline(Outline outline) {
if (outline == null) {
- nSetOutlineEmpty(mNativeDisplayList);
+ nSetOutlineEmpty(mNativeRenderNode);
} else if (!outline.isValid()) {
throw new IllegalArgumentException("Outline must be valid");
} else if (outline.mRect != null) {
- nSetOutlineRoundRect(mNativeDisplayList, outline.mRect.left, outline.mRect.top,
+ nSetOutlineRoundRect(mNativeRenderNode, outline.mRect.left, outline.mRect.top,
outline.mRect.right, outline.mRect.bottom, outline.mRadius);
} else if (outline.mPath != null) {
- nSetOutlineConvexPath(mNativeDisplayList, outline.mPath.mNativePath);
+ nSetOutlineConvexPath(mNativeRenderNode, outline.mPath.mNativePath);
}
}
@@ -374,7 +357,7 @@
* @param clipToOutline true if clipping to the outline.
*/
public void setClipToOutline(boolean clipToOutline) {
- nSetClipToOutline(mNativeDisplayList, clipToOutline);
+ nSetClipToOutline(mNativeRenderNode, clipToOutline);
}
/**
@@ -382,7 +365,7 @@
*/
public void setRevealClip(boolean shouldClip, boolean inverseClip,
float x, float y, float radius) {
- nSetRevealClip(mNativeDisplayList, shouldClip, inverseClip, x, y, radius);
+ nSetRevealClip(mNativeRenderNode, shouldClip, inverseClip, x, y, radius);
}
/**
@@ -392,7 +375,7 @@
* @param matrix A transform matrix to apply to this display list
*/
public void setStaticMatrix(Matrix matrix) {
- nSetStaticMatrix(mNativeDisplayList, matrix.native_instance);
+ nSetStaticMatrix(mNativeRenderNode, matrix.native_instance);
}
/**
@@ -406,7 +389,7 @@
* @hide
*/
public void setAnimationMatrix(Matrix matrix) {
- nSetAnimationMatrix(mNativeDisplayList,
+ nSetAnimationMatrix(mNativeRenderNode,
(matrix != null) ? matrix.native_instance : 0);
}
@@ -419,7 +402,7 @@
* @see #getAlpha()
*/
public void setAlpha(float alpha) {
- nSetAlpha(mNativeDisplayList, alpha);
+ nSetAlpha(mNativeRenderNode, alpha);
}
/**
@@ -430,7 +413,7 @@
* @see #setAlpha(float)
*/
public float getAlpha() {
- return nGetAlpha(mNativeDisplayList);
+ return nGetAlpha(mNativeRenderNode);
}
/**
@@ -445,7 +428,7 @@
* @see #hasOverlappingRendering()
*/
public void setHasOverlappingRendering(boolean hasOverlappingRendering) {
- nSetHasOverlappingRendering(mNativeDisplayList, hasOverlappingRendering);
+ nSetHasOverlappingRendering(mNativeRenderNode, hasOverlappingRendering);
}
/**
@@ -457,7 +440,7 @@
*/
public boolean hasOverlappingRendering() {
//noinspection SimplifiableIfStatement
- return nHasOverlappingRendering(mNativeDisplayList);
+ return nHasOverlappingRendering(mNativeRenderNode);
}
/**
@@ -469,7 +452,7 @@
* @see #getTranslationX()
*/
public void setTranslationX(float translationX) {
- nSetTranslationX(mNativeDisplayList, translationX);
+ nSetTranslationX(mNativeRenderNode, translationX);
}
/**
@@ -478,7 +461,7 @@
* @see #setTranslationX(float)
*/
public float getTranslationX() {
- return nGetTranslationX(mNativeDisplayList);
+ return nGetTranslationX(mNativeRenderNode);
}
/**
@@ -490,7 +473,7 @@
* @see #getTranslationY()
*/
public void setTranslationY(float translationY) {
- nSetTranslationY(mNativeDisplayList, translationY);
+ nSetTranslationY(mNativeRenderNode, translationY);
}
/**
@@ -499,7 +482,7 @@
* @see #setTranslationY(float)
*/
public float getTranslationY() {
- return nGetTranslationY(mNativeDisplayList);
+ return nGetTranslationY(mNativeRenderNode);
}
/**
@@ -509,7 +492,7 @@
* @see #getTranslationZ()
*/
public void setTranslationZ(float translationZ) {
- nSetTranslationZ(mNativeDisplayList, translationZ);
+ nSetTranslationZ(mNativeRenderNode, translationZ);
}
/**
@@ -518,7 +501,7 @@
* @see #setTranslationZ(float)
*/
public float getTranslationZ() {
- return nGetTranslationZ(mNativeDisplayList);
+ return nGetTranslationZ(mNativeRenderNode);
}
/**
@@ -530,7 +513,7 @@
* @see #getRotation()
*/
public void setRotation(float rotation) {
- nSetRotation(mNativeDisplayList, rotation);
+ nSetRotation(mNativeRenderNode, rotation);
}
/**
@@ -539,7 +522,7 @@
* @see #setRotation(float)
*/
public float getRotation() {
- return nGetRotation(mNativeDisplayList);
+ return nGetRotation(mNativeRenderNode);
}
/**
@@ -551,7 +534,7 @@
* @see #getRotationX()
*/
public void setRotationX(float rotationX) {
- nSetRotationX(mNativeDisplayList, rotationX);
+ nSetRotationX(mNativeRenderNode, rotationX);
}
/**
@@ -560,7 +543,7 @@
* @see #setRotationX(float)
*/
public float getRotationX() {
- return nGetRotationX(mNativeDisplayList);
+ return nGetRotationX(mNativeRenderNode);
}
/**
@@ -572,7 +555,7 @@
* @see #getRotationY()
*/
public void setRotationY(float rotationY) {
- nSetRotationY(mNativeDisplayList, rotationY);
+ nSetRotationY(mNativeRenderNode, rotationY);
}
/**
@@ -581,7 +564,7 @@
* @see #setRotationY(float)
*/
public float getRotationY() {
- return nGetRotationY(mNativeDisplayList);
+ return nGetRotationY(mNativeRenderNode);
}
/**
@@ -593,7 +576,7 @@
* @see #getScaleX()
*/
public void setScaleX(float scaleX) {
- nSetScaleX(mNativeDisplayList, scaleX);
+ nSetScaleX(mNativeRenderNode, scaleX);
}
/**
@@ -602,7 +585,7 @@
* @see #setScaleX(float)
*/
public float getScaleX() {
- return nGetScaleX(mNativeDisplayList);
+ return nGetScaleX(mNativeRenderNode);
}
/**
@@ -614,7 +597,7 @@
* @see #getScaleY()
*/
public void setScaleY(float scaleY) {
- nSetScaleY(mNativeDisplayList, scaleY);
+ nSetScaleY(mNativeRenderNode, scaleY);
}
/**
@@ -623,7 +606,7 @@
* @see #setScaleY(float)
*/
public float getScaleY() {
- return nGetScaleY(mNativeDisplayList);
+ return nGetScaleY(mNativeRenderNode);
}
/**
@@ -635,7 +618,7 @@
* @see #getPivotX()
*/
public void setPivotX(float pivotX) {
- nSetPivotX(mNativeDisplayList, pivotX);
+ nSetPivotX(mNativeRenderNode, pivotX);
}
/**
@@ -644,7 +627,7 @@
* @see #setPivotX(float)
*/
public float getPivotX() {
- return nGetPivotX(mNativeDisplayList);
+ return nGetPivotX(mNativeRenderNode);
}
/**
@@ -656,7 +639,7 @@
* @see #getPivotY()
*/
public void setPivotY(float pivotY) {
- nSetPivotY(mNativeDisplayList, pivotY);
+ nSetPivotY(mNativeRenderNode, pivotY);
}
/**
@@ -665,11 +648,11 @@
* @see #setPivotY(float)
*/
public float getPivotY() {
- return nGetPivotY(mNativeDisplayList);
+ return nGetPivotY(mNativeRenderNode);
}
public boolean isPivotExplicitlySet() {
- return nIsPivotExplicitlySet(mNativeDisplayList);
+ return nIsPivotExplicitlySet(mNativeRenderNode);
}
/**
@@ -683,7 +666,7 @@
* @see #getCameraDistance()
*/
public void setCameraDistance(float distance) {
- nSetCameraDistance(mNativeDisplayList, distance);
+ nSetCameraDistance(mNativeRenderNode, distance);
}
/**
@@ -692,7 +675,7 @@
* @see #setCameraDistance(float)
*/
public float getCameraDistance() {
- return nGetCameraDistance(mNativeDisplayList);
+ return nGetCameraDistance(mNativeRenderNode);
}
/**
@@ -704,7 +687,7 @@
* @see #getLeft()
*/
public void setLeft(int left) {
- nSetLeft(mNativeDisplayList, left);
+ nSetLeft(mNativeRenderNode, left);
}
/**
@@ -713,7 +696,7 @@
* @see #setLeft(int)
*/
public float getLeft() {
- return nGetLeft(mNativeDisplayList);
+ return nGetLeft(mNativeRenderNode);
}
/**
@@ -725,7 +708,7 @@
* @see #getTop()
*/
public void setTop(int top) {
- nSetTop(mNativeDisplayList, top);
+ nSetTop(mNativeRenderNode, top);
}
/**
@@ -734,7 +717,7 @@
* @see #setTop(int)
*/
public float getTop() {
- return nGetTop(mNativeDisplayList);
+ return nGetTop(mNativeRenderNode);
}
/**
@@ -746,7 +729,7 @@
* @see #getRight()
*/
public void setRight(int right) {
- nSetRight(mNativeDisplayList, right);
+ nSetRight(mNativeRenderNode, right);
}
/**
@@ -755,7 +738,7 @@
* @see #setRight(int)
*/
public float getRight() {
- return nGetRight(mNativeDisplayList);
+ return nGetRight(mNativeRenderNode);
}
/**
@@ -767,7 +750,7 @@
* @see #getBottom()
*/
public void setBottom(int bottom) {
- nSetBottom(mNativeDisplayList, bottom);
+ nSetBottom(mNativeRenderNode, bottom);
}
/**
@@ -776,7 +759,7 @@
* @see #setBottom(int)
*/
public float getBottom() {
- return nGetBottom(mNativeDisplayList);
+ return nGetBottom(mNativeRenderNode);
}
/**
@@ -793,7 +776,7 @@
* @see View#setBottom(int)
*/
public void setLeftTopRightBottom(int left, int top, int right, int bottom) {
- nSetLeftTopRightBottom(mNativeDisplayList, left, top, right, bottom);
+ nSetLeftTopRightBottom(mNativeRenderNode, left, top, right, bottom);
}
/**
@@ -805,7 +788,7 @@
* @see View#offsetLeftAndRight(int)
*/
public void offsetLeftAndRight(float offset) {
- nOffsetLeftAndRight(mNativeDisplayList, offset);
+ nOffsetLeftAndRight(mNativeRenderNode, offset);
}
/**
@@ -817,7 +800,7 @@
* @see View#offsetTopAndBottom(int)
*/
public void offsetTopAndBottom(float offset) {
- nOffsetTopAndBottom(mNativeDisplayList, offset);
+ nOffsetTopAndBottom(mNativeRenderNode, offset);
}
/**
@@ -827,80 +810,80 @@
* @hide
*/
public void output() {
- nOutput(mNativeDisplayList);
+ nOutput(mNativeRenderNode);
}
///////////////////////////////////////////////////////////////////////////
// Native methods
///////////////////////////////////////////////////////////////////////////
- private static native long nCreate();
- private static native void nDestroyDisplayList(long displayList);
- private static native void nSetDisplayListName(long displayList, String name);
+ private static native long nCreate(String name);
+ private static native void nDestroyRenderNode(long renderNode);
+ private static native void nSetDisplayListData(long renderNode, long newData);
// Matrix
- private static native void nGetTransformMatrix(long displayList, long nativeMatrix);
- private static native void nGetInverseTransformMatrix(long displayList, long nativeMatrix);
- private static native boolean nHasIdentityMatrix(long displayList);
+ private static native void nGetTransformMatrix(long renderNode, long nativeMatrix);
+ private static native void nGetInverseTransformMatrix(long renderNode, long nativeMatrix);
+ private static native boolean nHasIdentityMatrix(long renderNode);
// Properties
- private static native void nOffsetTopAndBottom(long displayList, float offset);
- private static native void nOffsetLeftAndRight(long displayList, float offset);
- private static native void nSetLeftTopRightBottom(long displayList, int left, int top,
+ private static native void nOffsetTopAndBottom(long renderNode, float offset);
+ private static native void nOffsetLeftAndRight(long renderNode, float offset);
+ private static native void nSetLeftTopRightBottom(long renderNode, int left, int top,
int right, int bottom);
- private static native void nSetBottom(long displayList, int bottom);
- private static native void nSetRight(long displayList, int right);
- private static native void nSetTop(long displayList, int top);
- private static native void nSetLeft(long displayList, int left);
- private static native void nSetCameraDistance(long displayList, float distance);
- private static native void nSetPivotY(long displayList, float pivotY);
- private static native void nSetPivotX(long displayList, float pivotX);
- private static native void nSetCaching(long displayList, boolean caching);
- private static native void nSetClipToBounds(long displayList, boolean clipToBounds);
- private static native void nSetProjectBackwards(long displayList, boolean shouldProject);
- private static native void nSetProjectionReceiver(long displayList, boolean shouldRecieve);
- private static native void nSetOutlineRoundRect(long displayList, int left, int top,
+ private static native void nSetBottom(long renderNode, int bottom);
+ private static native void nSetRight(long renderNode, int right);
+ private static native void nSetTop(long renderNode, int top);
+ private static native void nSetLeft(long renderNode, int left);
+ private static native void nSetCameraDistance(long renderNode, float distance);
+ private static native void nSetPivotY(long renderNode, float pivotY);
+ private static native void nSetPivotX(long renderNode, float pivotX);
+ private static native void nSetCaching(long renderNode, boolean caching);
+ private static native void nSetClipToBounds(long renderNode, boolean clipToBounds);
+ private static native void nSetProjectBackwards(long renderNode, boolean shouldProject);
+ private static native void nSetProjectionReceiver(long renderNode, boolean shouldRecieve);
+ private static native void nSetOutlineRoundRect(long renderNode, int left, int top,
int right, int bottom, float radius);
- private static native void nSetOutlineConvexPath(long displayList, long nativePath);
- private static native void nSetOutlineEmpty(long displayList);
- private static native void nSetClipToOutline(long displayList, boolean clipToOutline);
- private static native void nSetRevealClip(long displayList,
+ private static native void nSetOutlineConvexPath(long renderNode, long nativePath);
+ private static native void nSetOutlineEmpty(long renderNode);
+ private static native void nSetClipToOutline(long renderNode, boolean clipToOutline);
+ private static native void nSetRevealClip(long renderNode,
boolean shouldClip, boolean inverseClip, float x, float y, float radius);
- private static native void nSetAlpha(long displayList, float alpha);
- private static native void nSetHasOverlappingRendering(long displayList,
+ private static native void nSetAlpha(long renderNode, float alpha);
+ private static native void nSetHasOverlappingRendering(long renderNode,
boolean hasOverlappingRendering);
- private static native void nSetTranslationX(long displayList, float translationX);
- private static native void nSetTranslationY(long displayList, float translationY);
- private static native void nSetTranslationZ(long displayList, float translationZ);
- private static native void nSetRotation(long displayList, float rotation);
- private static native void nSetRotationX(long displayList, float rotationX);
- private static native void nSetRotationY(long displayList, float rotationY);
- private static native void nSetScaleX(long displayList, float scaleX);
- private static native void nSetScaleY(long displayList, float scaleY);
- private static native void nSetStaticMatrix(long displayList, long nativeMatrix);
- private static native void nSetAnimationMatrix(long displayList, long animationMatrix);
+ private static native void nSetTranslationX(long renderNode, float translationX);
+ private static native void nSetTranslationY(long renderNode, float translationY);
+ private static native void nSetTranslationZ(long renderNode, float translationZ);
+ private static native void nSetRotation(long renderNode, float rotation);
+ private static native void nSetRotationX(long renderNode, float rotationX);
+ private static native void nSetRotationY(long renderNode, float rotationY);
+ private static native void nSetScaleX(long renderNode, float scaleX);
+ private static native void nSetScaleY(long renderNode, float scaleY);
+ private static native void nSetStaticMatrix(long renderNode, long nativeMatrix);
+ private static native void nSetAnimationMatrix(long renderNode, long animationMatrix);
- private static native boolean nHasOverlappingRendering(long displayList);
- private static native float nGetAlpha(long displayList);
- private static native float nGetLeft(long displayList);
- private static native float nGetTop(long displayList);
- private static native float nGetRight(long displayList);
- private static native float nGetBottom(long displayList);
- private static native float nGetCameraDistance(long displayList);
- private static native float nGetScaleX(long displayList);
- private static native float nGetScaleY(long displayList);
- private static native float nGetTranslationX(long displayList);
- private static native float nGetTranslationY(long displayList);
- private static native float nGetTranslationZ(long displayList);
- private static native float nGetRotation(long displayList);
- private static native float nGetRotationX(long displayList);
- private static native float nGetRotationY(long displayList);
- private static native boolean nIsPivotExplicitlySet(long displayList);
- private static native float nGetPivotX(long displayList);
- private static native float nGetPivotY(long displayList);
- private static native void nOutput(long displayList);
+ private static native boolean nHasOverlappingRendering(long renderNode);
+ private static native float nGetAlpha(long renderNode);
+ private static native float nGetLeft(long renderNode);
+ private static native float nGetTop(long renderNode);
+ private static native float nGetRight(long renderNode);
+ private static native float nGetBottom(long renderNode);
+ private static native float nGetCameraDistance(long renderNode);
+ private static native float nGetScaleX(long renderNode);
+ private static native float nGetScaleY(long renderNode);
+ private static native float nGetTranslationX(long renderNode);
+ private static native float nGetTranslationY(long renderNode);
+ private static native float nGetTranslationZ(long renderNode);
+ private static native float nGetRotation(long renderNode);
+ private static native float nGetRotationX(long renderNode);
+ private static native float nGetRotationY(long renderNode);
+ private static native boolean nIsPivotExplicitlySet(long renderNode);
+ private static native float nGetPivotX(long renderNode);
+ private static native float nGetPivotY(long renderNode);
+ private static native void nOutput(long renderNode);
///////////////////////////////////////////////////////////////////////////
// Finalization
@@ -909,7 +892,7 @@
@Override
protected void finalize() throws Throwable {
try {
- nDestroyDisplayList(mNativeDisplayList);
+ nDestroyRenderNode(mNativeRenderNode);
} finally {
super.finalize();
}
diff --git a/core/java/android/view/ThreadedRenderer.java b/core/java/android/view/ThreadedRenderer.java
index 2e0f509..1ecc3c6 100644
--- a/core/java/android/view/ThreadedRenderer.java
+++ b/core/java/android/view/ThreadedRenderer.java
@@ -166,11 +166,6 @@
}
@Override
- void setDisplayListData(long displayList, long newData) {
- nSetDisplayListData(mNativeProxy, displayList, newData);
- }
-
- @Override
void draw(View view, AttachInfo attachInfo, HardwareDrawCallbacks callbacks, Rect dirty) {
attachInfo.mIgnoreDirtyState = true;
attachInfo.mDrawingTime = SystemClock.uptimeMillis();
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 6c414f6..9761f1a 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -13549,11 +13549,10 @@
* @return A new or reused DisplayList object.
*/
private void updateDisplayListIfDirty(@NonNull RenderNode renderNode, boolean isLayer) {
- final HardwareRenderer renderer = getHardwareRenderer();
if (renderNode == null) {
throw new IllegalArgumentException("RenderNode must not be null");
}
- if (renderer == null || !canHaveDisplayList()) {
+ if (!canHaveDisplayList()) {
// can't populate RenderNode, don't try
return;
}
@@ -13627,21 +13626,13 @@
}
}
} finally {
- renderNode.end(renderer, canvas);
+ renderNode.end(canvas);
renderNode.setCaching(caching);
if (isLayer) {
renderNode.setLeftTopRightBottom(0, 0, width, height);
} else {
setDisplayListProperties(renderNode);
}
-
- if (renderer != getHardwareRenderer()) {
- Log.w(VIEW_LOG_TAG, "View was detached during a draw() call!");
- // TODO: Should this be elevated to a crash?
- // For now have it behaves the same as it previously did, it
- // will result in the DisplayListData being destroyed later
- // than it could be but oh well...
- }
}
} else if (!isLayer) {
mPrivateFlags |= PFLAG_DRAWN | PFLAG_DRAWING_CACHE_VALID;
@@ -14913,7 +14904,7 @@
final int height = bounds.height();
final HardwareCanvas canvas = displayList.start(width, height);
drawable.draw(canvas);
- displayList.end(getHardwareRenderer(), canvas);
+ displayList.end(canvas);
// Set up drawable properties that are view-independent.
displayList.setLeftTopRightBottom(bounds.left, bounds.top, bounds.right, bounds.bottom);
diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java
index 2d503bf..65ac50d 100644
--- a/core/java/android/view/ViewRootImpl.java
+++ b/core/java/android/view/ViewRootImpl.java
@@ -1505,7 +1505,7 @@
com.android.internal.R.integer.config_mediumAnimTime);
layerCanvas.restoreToCount(restoreCount);
- layerRenderNode.end(mAttachInfo.mHardwareRenderer, layerCanvas);
+ layerRenderNode.end(layerCanvas);
layerRenderNode.setCaching(true);
layerRenderNode.setLeftTopRightBottom(0, 0, mWidth, mHeight);
mTempRect.set(0, 0, mWidth, mHeight);
diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java
index 14e7951c..b0a4e24 100644
--- a/core/java/android/widget/Editor.java
+++ b/core/java/android/widget/Editor.java
@@ -1338,7 +1338,6 @@
layout.drawBackground(canvas, highlight, highlightPaint, cursorOffsetVertical,
firstLine, lastLine);
- final HardwareRenderer renderer = mTextView.getHardwareRenderer();
if (layout instanceof DynamicLayout) {
if (mTextDisplayLists == null) {
@@ -1402,7 +1401,7 @@
// No need to untranslate, previous context is popped after
// drawDisplayList
} finally {
- blockDisplayList.end(renderer, hardwareCanvas);
+ blockDisplayList.end(hardwareCanvas);
// Same as drawDisplayList below, handled by our TextView's parent
blockDisplayList.setClipToBounds(false);
}
diff --git a/core/jni/android_view_GLRenderer.cpp b/core/jni/android_view_GLRenderer.cpp
index 180c625..8f59e87 100644
--- a/core/jni/android_view_GLRenderer.cpp
+++ b/core/jni/android_view_GLRenderer.cpp
@@ -142,19 +142,11 @@
LayerRenderer::destroyLayer(layer);
}
-static void android_view_GLRenderer_setDisplayListData(JNIEnv* env, jobject clazz,
- jlong displayListPtr, jlong newDataPtr) {
- using namespace android::uirenderer;
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
- displayList->setData(newData);
-}
-
-static void android_view_GLRenderer_updateRenderNodeProperties(JNIEnv* env, jobject clazz,
+static void android_view_GLRenderer_pushStagingChanges(JNIEnv* env, jobject clazz,
jlong renderNodePtr) {
using namespace android::uirenderer;
RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
- renderNode->updateProperties();
+ renderNode->pushStagingChanges();
}
static void android_view_GLRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
@@ -195,8 +187,7 @@
{ "getSystemTime", "()J", (void*) android_view_GLRenderer_getSystemTime },
{ "nDestroyLayer", "(J)V", (void*) android_view_GLRenderer_destroyLayer },
- { "nSetDisplayListData", "(JJ)V", (void*) android_view_GLRenderer_setDisplayListData },
- { "nUpdateRenderNodeProperties", "(J)V", (void*) android_view_GLRenderer_updateRenderNodeProperties },
+ { "nPushStagingChanges", "(J)V", (void*) android_view_GLRenderer_pushStagingChanges },
{ "nInvokeFunctor", "(JZ)V", (void*) android_view_GLRenderer_invokeFunctor },
#endif
diff --git a/core/jni/android_view_RenderNode.cpp b/core/jni/android_view_RenderNode.cpp
index cf95657..31a1de6 100644
--- a/core/jni/android_view_RenderNode.cpp
+++ b/core/jni/android_view_RenderNode.cpp
@@ -41,32 +41,34 @@
// DisplayList view properties
// ----------------------------------------------------------------------------
-static void android_view_RenderNode_setDisplayListName(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jstring name) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
+static void android_view_RenderNode_output(JNIEnv* env,
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->output();
+}
+
+static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz, jstring name) {
+ RenderNode* renderNode = new RenderNode();
+ renderNode->incStrong(0);
if (name != NULL) {
const char* textArray = env->GetStringUTFChars(name, NULL);
- displayList->setName(textArray);
+ renderNode->setName(textArray);
env->ReleaseStringUTFChars(name, textArray);
}
+ return reinterpret_cast<jlong>(renderNode);
}
-static void android_view_RenderNode_output(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->output();
+static void android_view_RenderNode_destroyRenderNode(JNIEnv* env,
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->decStrong(0);
}
-static jlong android_view_RenderNode_create(JNIEnv* env, jobject clazz) {
- RenderNode* displayList = new RenderNode();
- displayList->incStrong(0);
- return reinterpret_cast<jlong>(displayList);
-}
-
-static void android_view_RenderNode_destroyDisplayList(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->decStrong(0);
+static void android_view_RenderNode_setDisplayListData(JNIEnv* env,
+ jobject clazz, jlong renderNodePtr, jlong newDataPtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
+ renderNode->setStagingDisplayList(newData);
}
// ----------------------------------------------------------------------------
@@ -74,201 +76,201 @@
// ----------------------------------------------------------------------------
static void android_view_RenderNode_setCaching(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean caching) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setCaching(caching);
+ jobject clazz, jlong renderNodePtr, jboolean caching) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setCaching(caching);
}
static void android_view_RenderNode_setStaticMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong matrixPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
+ jobject clazz, jlong renderNodePtr, jlong matrixPtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
- displayList->mutateStagingProperties().setStaticMatrix(matrix);
+ renderNode->mutateStagingProperties().setStaticMatrix(matrix);
}
static void android_view_RenderNode_setAnimationMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong matrixPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
+ jobject clazz, jlong renderNodePtr, jlong matrixPtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixPtr);
- displayList->mutateStagingProperties().setAnimationMatrix(matrix);
+ renderNode->mutateStagingProperties().setAnimationMatrix(matrix);
}
static void android_view_RenderNode_setClipToBounds(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean clipToBounds) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setClipToBounds(clipToBounds);
+ jobject clazz, jlong renderNodePtr, jboolean clipToBounds) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setClipToBounds(clipToBounds);
}
static void android_view_RenderNode_setProjectBackwards(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean shouldProject) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setProjectBackwards(shouldProject);
+ jobject clazz, jlong renderNodePtr, jboolean shouldProject) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setProjectBackwards(shouldProject);
}
static void android_view_RenderNode_setProjectionReceiver(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean shouldRecieve) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setProjectionReceiver(shouldRecieve);
+ jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setProjectionReceiver(shouldRecieve);
}
static void android_view_RenderNode_setOutlineRoundRect(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jint left, jint top,
+ jobject clazz, jlong renderNodePtr, jint left, jint top,
jint right, jint bottom, jfloat radius) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius);
- displayList->mutateStagingProperties().updateClipPath();
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius);
+ renderNode->mutateStagingProperties().updateClipPath();
}
static void android_view_RenderNode_setOutlineConvexPath(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong outlinePathPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
+ jobject clazz, jlong renderNodePtr, jlong outlinePathPtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
SkPath* outlinePath = reinterpret_cast<SkPath*>(outlinePathPtr);
- displayList->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath);
- displayList->mutateStagingProperties().updateClipPath();
+ renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath);
+ renderNode->mutateStagingProperties().updateClipPath();
}
static void android_view_RenderNode_setOutlineEmpty(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().mutableOutline().setEmpty();
- displayList->mutateStagingProperties().updateClipPath();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().mutableOutline().setEmpty();
+ renderNode->mutateStagingProperties().updateClipPath();
}
static void android_view_RenderNode_setClipToOutline(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean clipToOutline) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline);
- displayList->mutateStagingProperties().updateClipPath();
+ jobject clazz, jlong renderNodePtr, jboolean clipToOutline) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline);
+ renderNode->mutateStagingProperties().updateClipPath();
}
static void android_view_RenderNode_setRevealClip(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jboolean shouldClip, jboolean inverseClip,
+ jobject clazz, jlong renderNodePtr, jboolean shouldClip, jboolean inverseClip,
jfloat x, jfloat y, jfloat radius) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().mutableRevealClip().set(
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().mutableRevealClip().set(
shouldClip, inverseClip, x, y, radius);
- displayList->mutateStagingProperties().updateClipPath();
+ renderNode->mutateStagingProperties().updateClipPath();
}
static void android_view_RenderNode_setAlpha(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float alpha) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setAlpha(alpha);
+ jobject clazz, jlong renderNodePtr, float alpha) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setAlpha(alpha);
}
static void android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env,
- jobject clazz, jlong displayListPtr, bool hasOverlappingRendering) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setHasOverlappingRendering(hasOverlappingRendering);
+ jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setHasOverlappingRendering(hasOverlappingRendering);
}
static void android_view_RenderNode_setTranslationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float tx) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setTranslationX(tx);
+ jobject clazz, jlong renderNodePtr, float tx) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setTranslationX(tx);
}
static void android_view_RenderNode_setTranslationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float ty) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setTranslationY(ty);
+ jobject clazz, jlong renderNodePtr, float ty) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setTranslationY(ty);
}
static void android_view_RenderNode_setTranslationZ(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float tz) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setTranslationZ(tz);
+ jobject clazz, jlong renderNodePtr, float tz) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setTranslationZ(tz);
}
static void android_view_RenderNode_setRotation(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float rotation) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setRotation(rotation);
+ jobject clazz, jlong renderNodePtr, float rotation) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setRotation(rotation);
}
static void android_view_RenderNode_setRotationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float rx) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setRotationX(rx);
+ jobject clazz, jlong renderNodePtr, float rx) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setRotationX(rx);
}
static void android_view_RenderNode_setRotationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float ry) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setRotationY(ry);
+ jobject clazz, jlong renderNodePtr, float ry) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setRotationY(ry);
}
static void android_view_RenderNode_setScaleX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float sx) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setScaleX(sx);
+ jobject clazz, jlong renderNodePtr, float sx) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setScaleX(sx);
}
static void android_view_RenderNode_setScaleY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float sy) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setScaleY(sy);
+ jobject clazz, jlong renderNodePtr, float sy) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setScaleY(sy);
}
static void android_view_RenderNode_setPivotX(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float px) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setPivotX(px);
+ jobject clazz, jlong renderNodePtr, float px) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setPivotX(px);
}
static void android_view_RenderNode_setPivotY(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float py) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setPivotY(py);
+ jobject clazz, jlong renderNodePtr, float py) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setPivotY(py);
}
static void android_view_RenderNode_setCameraDistance(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float distance) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setCameraDistance(distance);
+ jobject clazz, jlong renderNodePtr, float distance) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setCameraDistance(distance);
}
static void android_view_RenderNode_setLeft(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int left) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setLeft(left);
+ jobject clazz, jlong renderNodePtr, int left) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setLeft(left);
}
static void android_view_RenderNode_setTop(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int top) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setTop(top);
+ jobject clazz, jlong renderNodePtr, int top) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setTop(top);
}
static void android_view_RenderNode_setRight(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int right) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setRight(right);
+ jobject clazz, jlong renderNodePtr, int right) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setRight(right);
}
static void android_view_RenderNode_setBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int bottom) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setBottom(bottom);
+ jobject clazz, jlong renderNodePtr, int bottom) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setBottom(bottom);
}
static void android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr, int left, int top,
+ jobject clazz, jlong renderNodePtr, int left, int top,
int right, int bottom) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom);
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom);
}
static void android_view_RenderNode_offsetLeftAndRight(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float offset) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().offsetLeftRight(offset);
+ jobject clazz, jlong renderNodePtr, float offset) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().offsetLeftRight(offset);
}
static void android_view_RenderNode_offsetTopAndBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr, float offset) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().offsetTopBottom(offset);
+ jobject clazz, jlong renderNodePtr, float offset) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().offsetTopBottom(offset);
}
// ----------------------------------------------------------------------------
@@ -276,105 +278,105 @@
// ----------------------------------------------------------------------------
static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().hasOverlappingRendering();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().hasOverlappingRendering();
}
static jfloat android_view_RenderNode_getAlpha(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getAlpha();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getAlpha();
}
static jfloat android_view_RenderNode_getLeft(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getLeft();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getLeft();
}
static jfloat android_view_RenderNode_getTop(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getTop();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getTop();
}
static jfloat android_view_RenderNode_getRight(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getRight();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getRight();
}
static jfloat android_view_RenderNode_getBottom(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getBottom();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getBottom();
}
static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getCameraDistance();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getCameraDistance();
}
static jfloat android_view_RenderNode_getScaleX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getScaleX();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getScaleX();
}
static jfloat android_view_RenderNode_getScaleY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getScaleY();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getScaleY();
}
static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getTranslationX();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getTranslationX();
}
static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getTranslationY();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getTranslationY();
}
static jfloat android_view_RenderNode_getTranslationZ(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getTranslationZ();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getTranslationZ();
}
static jfloat android_view_RenderNode_getRotation(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getRotation();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getRotation();
}
static jfloat android_view_RenderNode_getRotationX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getRotationX();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getRotationX();
}
static jfloat android_view_RenderNode_getRotationY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getRotationY();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getRotationY();
}
static jboolean android_view_RenderNode_isPivotExplicitlySet(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().isPivotExplicitlySet();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().isPivotExplicitlySet();
}
static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- return displayList->stagingProperties().getMatrixFlags() == 0;
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ return renderNode->stagingProperties().getMatrixFlags() == 0;
}
// ----------------------------------------------------------------------------
@@ -382,16 +384,16 @@
// ----------------------------------------------------------------------------
static void android_view_RenderNode_getTransformMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong outMatrixPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
+ jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr);
- displayList->mutateStagingProperties().updateMatrix();
- const SkMatrix* transformMatrix = displayList->stagingProperties().getTransformMatrix();
+ renderNode->mutateStagingProperties().updateMatrix();
+ const SkMatrix* transformMatrix = renderNode->stagingProperties().getTransformMatrix();
- if (displayList->stagingProperties().getMatrixFlags() == TRANSLATION) {
- outMatrix->setTranslate(displayList->stagingProperties().getTranslationX(),
- displayList->stagingProperties().getTranslationY());
+ if (renderNode->stagingProperties().getMatrixFlags() == TRANSLATION) {
+ outMatrix->setTranslate(renderNode->stagingProperties().getTranslationX(),
+ renderNode->stagingProperties().getTranslationY());
} else if (transformMatrix) {
*outMatrix = *transformMatrix;
} else {
@@ -400,9 +402,9 @@
}
static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env,
- jobject clazz, jlong displayListPtr, jlong outMatrixPtr) {
+ jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) {
// load transform matrix
- android_view_RenderNode_getTransformMatrix(env, clazz, displayListPtr, outMatrixPtr);
+ android_view_RenderNode_getTransformMatrix(env, clazz, renderNodePtr, outMatrixPtr);
SkMatrix* outMatrix = reinterpret_cast<SkMatrix*>(outMatrixPtr);
// return it inverted
@@ -413,17 +415,17 @@
}
static jfloat android_view_RenderNode_getPivotX(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().updateMatrix();
- return displayList->stagingProperties().getPivotX();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().updateMatrix();
+ return renderNode->stagingProperties().getPivotX();
}
static jfloat android_view_RenderNode_getPivotY(JNIEnv* env,
- jobject clazz, jlong displayListPtr) {
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- displayList->mutateStagingProperties().updateMatrix();
- return displayList->stagingProperties().getPivotY();
+ jobject clazz, jlong renderNodePtr) {
+ RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
+ renderNode->mutateStagingProperties().updateMatrix();
+ return renderNode->stagingProperties().getPivotY();
}
#endif // USE_OPENGL_RENDERER
@@ -436,10 +438,9 @@
static JNINativeMethod gMethods[] = {
#ifdef USE_OPENGL_RENDERER
- { "nCreate", "()J", (void*) android_view_RenderNode_create },
- { "nDestroyDisplayList", "(J)V", (void*) android_view_RenderNode_destroyDisplayList },
- { "nSetDisplayListName", "(JLjava/lang/String;)V",
- (void*) android_view_RenderNode_setDisplayListName },
+ { "nCreate", "(Ljava/lang/String;)J", (void*) android_view_RenderNode_create },
+ { "nDestroyRenderNode", "(J)V", (void*) android_view_RenderNode_destroyRenderNode },
+ { "nSetDisplayListData", "(JJ)V", (void*) android_view_RenderNode_setDisplayListData },
{ "nOutput", "(J)V", (void*) android_view_RenderNode_output },
{ "nSetCaching", "(JZ)V", (void*) android_view_RenderNode_setCaching },
diff --git a/core/jni/android_view_ThreadedRenderer.cpp b/core/jni/android_view_ThreadedRenderer.cpp
index 20a61bf..36c8357 100644
--- a/core/jni/android_view_ThreadedRenderer.cpp
+++ b/core/jni/android_view_ThreadedRenderer.cpp
@@ -113,14 +113,6 @@
proxy->setup(width, height);
}
-static void android_view_ThreadedRenderer_setDisplayListData(JNIEnv* env, jobject clazz,
- jlong proxyPtr, jlong displayListPtr, jlong newDataPtr) {
- RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
- RenderNode* displayList = reinterpret_cast<RenderNode*>(displayListPtr);
- DisplayListData* newData = reinterpret_cast<DisplayListData*>(newDataPtr);
- proxy->setDisplayListData(displayList, newData);
-}
-
static void android_view_ThreadedRenderer_drawDisplayList(JNIEnv* env, jobject clazz,
jlong proxyPtr, jlong displayListPtr, jint dirtyLeft, jint dirtyTop,
jint dirtyRight, jint dirtyBottom) {
@@ -215,7 +207,6 @@
{ "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
{ "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
{ "nSetup", "(JII)V", (void*) android_view_ThreadedRenderer_setup },
- { "nSetDisplayListData", "(JJJ)V", (void*) android_view_ThreadedRenderer_setDisplayListData },
{ "nDrawDisplayList", "(JJIIII)V", (void*) android_view_ThreadedRenderer_drawDisplayList },
{ "nDestroyCanvas", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvas },
{ "nAttachFunctor", "(JJ)V", (void*) android_view_ThreadedRenderer_attachFunctor },
diff --git a/libs/hwui/DeferredLayerUpdater.cpp b/libs/hwui/DeferredLayerUpdater.cpp
index ce711b6..358e1af 100644
--- a/libs/hwui/DeferredLayerUpdater.cpp
+++ b/libs/hwui/DeferredLayerUpdater.cpp
@@ -73,7 +73,7 @@
success = LayerRenderer::resizeLayer(mLayer, mWidth, mHeight);
}
mLayer->setBlend(mBlend);
- mDisplayList->updateProperties();
+ mDisplayList->pushStagingChanges();
mLayer->updateDeferred(mDisplayList.get(),
mDirtyRect.left, mDirtyRect.top, mDirtyRect.right, mDirtyRect.bottom);
mDirtyRect.setEmpty();
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 9dbcd36..f37487f 100644
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -1901,7 +1901,6 @@
// will be performed by the display list itself
if (displayList && displayList->isRenderable()) {
// compute 3d ordering
- displayList->updateProperties();
displayList->computeOrdering();
if (CC_UNLIKELY(mCaches.drawDeferDisabled)) {
status = startFrame();
diff --git a/libs/hwui/RenderNode.cpp b/libs/hwui/RenderNode.cpp
index 5010076..761fb84 100644
--- a/libs/hwui/RenderNode.cpp
+++ b/libs/hwui/RenderNode.cpp
@@ -49,7 +49,12 @@
fflush(file);
}
-RenderNode::RenderNode() : mDestroyed(false), mNeedsPropertiesSync(false), mDisplayListData(0) {
+RenderNode::RenderNode()
+ : mDestroyed(false)
+ , mNeedsPropertiesSync(false)
+ , mNeedsDisplayListDataSync(false)
+ , mDisplayListData(0)
+ , mStagingDisplayListData(0) {
}
RenderNode::~RenderNode() {
@@ -57,13 +62,15 @@
mDestroyed = true;
delete mDisplayListData;
+ delete mStagingDisplayListData;
}
-void RenderNode::setData(DisplayListData* data) {
- delete mDisplayListData;
- mDisplayListData = data;
- if (mDisplayListData) {
- Caches::getInstance().registerFunctors(mDisplayListData->functorCount);
+void RenderNode::setStagingDisplayList(DisplayListData* data) {
+ mNeedsDisplayListDataSync = true;
+ delete mStagingDisplayListData;
+ mStagingDisplayListData = data;
+ if (mStagingDisplayListData) {
+ Caches::getInstance().registerFunctors(mStagingDisplayListData->functorCount);
}
}
@@ -86,16 +93,29 @@
ALOGD("%*sDone (%p, %s)", (level - 1) * 2, "", this, mName.string());
}
-void RenderNode::updateProperties() {
+void RenderNode::pushStagingChanges() {
if (mNeedsPropertiesSync) {
mNeedsPropertiesSync = false;
mProperties = mStagingProperties;
}
+ if (mNeedsDisplayListDataSync) {
+ mNeedsDisplayListDataSync = false;
+ // Do a push pass on the old tree to handle freeing DisplayListData
+ // that are no longer used
+ pushSubTreeStagingChanges(mDisplayListData);
+ delete mDisplayListData;
+ mDisplayListData = mStagingDisplayListData;
+ mStagingDisplayListData = 0;
+ }
- if (mDisplayListData) {
- for (size_t i = 0; i < mDisplayListData->children().size(); i++) {
- RenderNode* childNode = mDisplayListData->children()[i]->mDisplayList;
- childNode->updateProperties();
+ pushSubTreeStagingChanges(mDisplayListData);
+}
+
+void RenderNode::pushSubTreeStagingChanges(DisplayListData* subtree) {
+ if (subtree) {
+ for (size_t i = 0; i < subtree->children().size(); i++) {
+ RenderNode* childNode = subtree->children()[i]->mDisplayList;
+ childNode->pushStagingChanges();
}
}
}
diff --git a/libs/hwui/RenderNode.h b/libs/hwui/RenderNode.h
index fa0fb8a..e5b9d7c 100644
--- a/libs/hwui/RenderNode.h
+++ b/libs/hwui/RenderNode.h
@@ -89,7 +89,7 @@
ANDROID_API static void outputLogBuffer(int fd);
- ANDROID_API void setData(DisplayListData* newData);
+ ANDROID_API void setStagingDisplayList(DisplayListData* newData);
void computeOrdering();
@@ -141,7 +141,7 @@
return properties().getHeight();
}
- ANDROID_API void updateProperties();
+ ANDROID_API void pushStagingChanges();
// Returns true if this RenderNode or any of its children have functors
bool hasFunctors();
@@ -203,6 +203,8 @@
const char* mText;
};
+ static void pushSubTreeStagingChanges(DisplayListData* subtree);
+
String8 mName;
bool mDestroyed; // used for debugging crash, TODO: remove once invalid state crash fixed
@@ -210,7 +212,9 @@
RenderProperties mProperties;
RenderProperties mStagingProperties;
+ bool mNeedsDisplayListDataSync;
DisplayListData* mDisplayListData;
+ DisplayListData* mStagingDisplayListData;
/**
* Draw time state - these properties are only set and used during rendering
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index af35344..014c7d0 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -385,10 +385,6 @@
mCanvas->setViewport(width, height);
}
-void CanvasContext::setDisplayListData(RenderNode* displayList, DisplayListData* newData) {
- displayList->setData(newData);
-}
-
void CanvasContext::processLayerUpdates(const Vector<DeferredLayerUpdater*>* layerUpdaters) {
mGlobalContext->makeCurrent(mEglSurface);
for (size_t i = 0; i < layerUpdaters->size(); i++) {
diff --git a/libs/hwui/renderthread/CanvasContext.h b/libs/hwui/renderthread/CanvasContext.h
index 9f64944..4d830ba 100644
--- a/libs/hwui/renderthread/CanvasContext.h
+++ b/libs/hwui/renderthread/CanvasContext.h
@@ -65,7 +65,6 @@
void updateSurface(EGLNativeWindowType window);
void pauseSurface(EGLNativeWindowType window);
void setup(int width, int height);
- void setDisplayListData(RenderNode* displayList, DisplayListData* newData);
void processLayerUpdates(const Vector<DeferredLayerUpdater*>* layerUpdaters);
void drawDisplayList(RenderNode* displayList, Rect* dirty);
void destroyCanvas();
diff --git a/libs/hwui/renderthread/DrawFrameTask.cpp b/libs/hwui/renderthread/DrawFrameTask.cpp
index 7b509a2..6e7ec9b 100644
--- a/libs/hwui/renderthread/DrawFrameTask.cpp
+++ b/libs/hwui/renderthread/DrawFrameTask.cpp
@@ -30,18 +30,6 @@
namespace uirenderer {
namespace renderthread {
-SetDisplayListData::SetDisplayListData() : mNewData(0) {}
-
-SetDisplayListData::SetDisplayListData(RenderNode* node, DisplayListData* newData)
- : mTargetNode(node), mNewData(newData) {
-}
-
-SetDisplayListData::~SetDisplayListData() {}
-
-void SetDisplayListData::apply() const {
- mTargetNode->setData(mNewData);
-}
-
DrawFrameTask::DrawFrameTask() : mContext(0), mTaskMode(MODE_INVALID), mRenderNode(0) {
}
@@ -52,13 +40,6 @@
mContext = context;
}
-void DrawFrameTask::setDisplayListData(RenderNode* renderNode, DisplayListData* newData) {
- LOG_ALWAYS_FATAL_IF(!mContext, "Lifecycle violation, there's no context to setDisplayListData with!");
-
- SetDisplayListData setter(renderNode, newData);
- mDisplayListDataUpdates.push(setter);
-}
-
void DrawFrameTask::addLayer(DeferredLayerUpdater* layer) {
LOG_ALWAYS_FATAL_IF(!mContext, "Lifecycle violation, there's no context to addLayer with!");
@@ -143,17 +124,11 @@
void DrawFrameTask::syncFrameState() {
ATRACE_CALL();
- for (size_t i = 0; i < mDisplayListDataUpdates.size(); i++) {
- const SetDisplayListData& setter = mDisplayListDataUpdates[i];
- setter.apply();
- }
- mDisplayListDataUpdates.clear();
-
mContext->processLayerUpdates(&mLayers);
// If we don't have an mRenderNode this is a state flush only
if (mRenderNode.get()) {
- mRenderNode->updateProperties();
+ mRenderNode->pushStagingChanges();
}
}
diff --git a/libs/hwui/renderthread/DrawFrameTask.h b/libs/hwui/renderthread/DrawFrameTask.h
index 4e9b244..ddf756b 100644
--- a/libs/hwui/renderthread/DrawFrameTask.h
+++ b/libs/hwui/renderthread/DrawFrameTask.h
@@ -37,18 +37,6 @@
class CanvasContext;
class RenderThread;
-class SetDisplayListData {
-public:
- // This ctor exists for Vector's usage
- SetDisplayListData();
- SetDisplayListData(RenderNode* node, DisplayListData* newData);
- ~SetDisplayListData();
- void apply() const;
-private:
- sp<RenderNode> mTargetNode;
- DisplayListData* mNewData;
-};
-
/*
* This is a special Super Task. It is re-used multiple times by RenderProxy,
* and contains state (such as layer updaters & new DisplayListDatas) that is
@@ -62,7 +50,6 @@
void setContext(CanvasContext* context);
- void setDisplayListData(RenderNode* renderNode, DisplayListData* newData);
void addLayer(DeferredLayerUpdater* layer);
void removeLayer(DeferredLayerUpdater* layer);
@@ -100,7 +87,6 @@
TaskMode mTaskMode;
sp<RenderNode> mRenderNode;
Rect mDirty;
- Vector<SetDisplayListData> mDisplayListDataUpdates;
/*********************************************
* Multi frame data
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index a7c955e..49b9aca 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -136,10 +136,6 @@
post(task);
}
-void RenderProxy::setDisplayListData(RenderNode* renderNode, DisplayListData* newData) {
- mDrawFrameTask.setDisplayListData(renderNode, newData);
-}
-
void RenderProxy::drawDisplayList(RenderNode* displayList,
int dirtyLeft, int dirtyTop, int dirtyRight, int dirtyBottom) {
mDrawFrameTask.setRenderNode(displayList);
diff --git a/libs/hwui/renderthread/RenderProxy.h b/libs/hwui/renderthread/RenderProxy.h
index 489bf20c1..1ad3c85 100644
--- a/libs/hwui/renderthread/RenderProxy.h
+++ b/libs/hwui/renderthread/RenderProxy.h
@@ -63,7 +63,6 @@
ANDROID_API void updateSurface(const sp<ANativeWindow>& window);
ANDROID_API void pauseSurface(const sp<ANativeWindow>& window);
ANDROID_API void setup(int width, int height);
- ANDROID_API void setDisplayListData(RenderNode* renderNode, DisplayListData* newData);
ANDROID_API void drawDisplayList(RenderNode* displayList,
int dirtyLeft, int dirtyTop, int dirtyRight, int dirtyBottom);
ANDROID_API void destroyCanvas();