Track canvas clearing for swap buffers logic.

chethaase · chethaase · commit 44b2fe3fc114 · 2012-06-07T06:25:04.000-07:00
A previous fix made it necessary for a frame to render something to GL
in order to cause a call to eglSwapBuffers(). Besides the calls being
tracked as part of issuing a DisplayList, there is also a potential call
to clear the canvas (via glClear()) on non-opaque surfaces. This call is also
good to track, since a surface that gets cleared without any other drawing operations
is worth flipping to the screen (to erase old contents on that surface).

This fix tracks the status of the pre-draw operations to find out whether
glClear() was called and then sets the drawing status appropriately.

Issue #6606422 QuickContact dismissal is janky again (Tracking)

Change-Id: I5fcaccfdc9293dd46b83f2fc279730a5d2740ebf
diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
@@ -215,16 +215,17 @@ public void setViewport(int width, int height) {
     private static native void nSetViewport(int renderer, int width, int height);
 
     @Override
-    public void onPreDraw(Rect dirty) {
+    public int onPreDraw(Rect dirty) {
         if (dirty != null) {
-            nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom, mOpaque);
+            return nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom,
+                    mOpaque);
         } else {
-            nPrepare(mRenderer, mOpaque);
+            return nPrepare(mRenderer, mOpaque);
         }
     }
 
-    private static native void nPrepare(int renderer, boolean opaque);
-    private static native void nPrepareDirty(int renderer, int left, int top, int right, int bottom,
+    private static native int nPrepare(int renderer, boolean opaque);
+    private static native int nPrepareDirty(int renderer, int left, int top, int right, int bottom,
             boolean opaque);
 
     @Override
diff --git a/core/java/android/view/HardwareCanvas.java b/core/java/android/view/HardwareCanvas.java
@@ -41,8 +41,10 @@ public void setBitmap(Bitmap bitmap) {
      * Invoked before any drawing operation is performed in this canvas.
      * 
      * @param dirty The dirty rectangle to update, can be null.
+     * @return {@link DisplayList#STATUS_DREW} if anything was drawn (such as a call to clear
+     * the canvas).
      */
-    public abstract void onPreDraw(Rect dirty);
+    public abstract int onPreDraw(Rect dirty);
 
     /**
      * Invoked after all drawing operation have been performed.
@@ -58,8 +60,9 @@ public void setBitmap(Bitmap bitmap) {
      * @param flags Optional flags about drawing, see {@link DisplayList} for
      *              the possible flags.
      *
-     * @return One of {@link DisplayList#STATUS_DONE}, {@link DisplayList#STATUS_DRAW} or
-     *         {@link DisplayList#STATUS_INVOKE}
+     * @return One of {@link DisplayList#STATUS_DONE}, {@link DisplayList#STATUS_DRAW}, or
+     *         {@link DisplayList#STATUS_INVOKE}, or'd with {@link DisplayList#STATUS_DREW}
+     *         if anything was drawn.
      */
     public abstract int drawDisplayList(DisplayList displayList, Rect dirty, int flags);
 
diff --git a/core/java/android/view/HardwareRenderer.java b/core/java/android/view/HardwareRenderer.java
@@ -1042,8 +1042,8 @@ boolean canDraw() {
             return mGl != null && mCanvas != null;
         }        
         
-        void onPreDraw(Rect dirty) {
-            
+        int onPreDraw(Rect dirty) {
+            return DisplayList.STATUS_DONE;
         }
 
         void onPostDraw() {
@@ -1102,9 +1102,7 @@ boolean draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callba
                         }
                     }
 
-                    onPreDraw(dirty);
-
-                    int status = DisplayList.STATUS_DONE;
+                    int status = onPreDraw(dirty);
                     int saveCount = canvas.save();
                     callbacks.onHardwarePreDraw(canvas);
 
@@ -1138,7 +1136,7 @@ boolean draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callba
                                 drawDisplayListStartTime = System.nanoTime();
                             }
 
-                            status = canvas.drawDisplayList(displayList, mRedrawClip,
+                            status |= canvas.drawDisplayList(displayList, mRedrawClip,
                                     DisplayList.FLAG_CLIP_CHILDREN);
 
                             if (mProfileEnabled) {
@@ -1372,8 +1370,8 @@ boolean canDraw() {
         }                
 
         @Override
-        void onPreDraw(Rect dirty) {
-            mGlCanvas.onPreDraw(dirty);
+        int onPreDraw(Rect dirty) {
+            return mGlCanvas.onPreDraw(dirty);
         }
 
         @Override
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
@@ -133,15 +133,15 @@ static void android_view_GLES20Canvas_setViewport(JNIEnv* env, jobject clazz,
     renderer->setViewport(width, height);
 }
 
-static void android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,
+static int android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,
         OpenGLRenderer* renderer, jboolean opaque) {
-    renderer->prepare(opaque);
+    return renderer->prepare(opaque);
 }
 
-static void android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,
+static int android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,
         OpenGLRenderer* renderer, jint left, jint top, jint right, jint bottom,
         jboolean opaque) {
-    renderer->prepareDirty(left, top, right, bottom, opaque);
+    return renderer->prepareDirty(left, top, right, bottom, opaque);
 }
 
 static void android_view_GLES20Canvas_finish(JNIEnv* env, jobject clazz,
@@ -868,8 +868,8 @@ static JNINativeMethod gMethods[] = {
     { "nCreateRenderer",    "()I",             (void*) android_view_GLES20Canvas_createRenderer },
     { "nDestroyRenderer",   "(I)V",            (void*) android_view_GLES20Canvas_destroyRenderer },
     { "nSetViewport",       "(III)V",          (void*) android_view_GLES20Canvas_setViewport },
-    { "nPrepare",           "(IZ)V",           (void*) android_view_GLES20Canvas_prepare },
-    { "nPrepareDirty",      "(IIIIIZ)V",       (void*) android_view_GLES20Canvas_prepareDirty },
+    { "nPrepare",           "(IZ)I",           (void*) android_view_GLES20Canvas_prepare },
+    { "nPrepareDirty",      "(IIIIIZ)I",       (void*) android_view_GLES20Canvas_prepareDirty },
     { "nFinish",            "(I)V",            (void*) android_view_GLES20Canvas_finish },
 
     { "nGetStencilSize",    "()I",             (void*) android_view_GLES20Canvas_getStencilSize },
diff --git a/libs/hwui/DisplayListRenderer.cpp b/libs/hwui/DisplayListRenderer.cpp
@@ -1368,13 +1368,14 @@ void DisplayListRenderer::setViewport(int width, int height) {
     mHeight = height;
 }
 
-void DisplayListRenderer::prepareDirty(float left, float top,
+int DisplayListRenderer::prepareDirty(float left, float top,
         float right, float bottom, bool opaque) {
     mSnapshot = new Snapshot(mFirstSnapshot,
             SkCanvas::kMatrix_SaveFlag | SkCanvas::kClip_SaveFlag);
     mSaveCount = 1;
     mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight);
     mRestoreSaveCount = -1;
+    return DrawGlInfo::kStatusDone; // No invalidate needed at record-time
 }
 
 void DisplayListRenderer::finish() {
diff --git a/libs/hwui/DisplayListRenderer.h b/libs/hwui/DisplayListRenderer.h
@@ -547,7 +547,7 @@ class DisplayListRenderer: public OpenGLRenderer {
     virtual bool isDeferred();
 
     virtual void setViewport(int width, int height);
-    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
+    virtual int prepareDirty(float left, float top, float right, float bottom, bool opaque);
     virtual void finish();
 
     virtual status_t callDrawGLFunction(Functor *functor, Rect& dirty);
diff --git a/libs/hwui/LayerRenderer.cpp b/libs/hwui/LayerRenderer.cpp
@@ -37,7 +37,7 @@ LayerRenderer::LayerRenderer(Layer* layer): mLayer(layer) {
 LayerRenderer::~LayerRenderer() {
 }
 
-void LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {
+int LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {
     LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());
 
     glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo());
@@ -57,9 +57,9 @@ void LayerRenderer::prepareDirty(float left, float top, float right, float botto
         mLayer->region.subtractSelf(r);
     }
 
-    OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
+    return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
 #else
-    OpenGLRenderer::prepareDirty(0.0f, 0.0f, width, height, opaque);
+    return OpenGLRenderer::prepareDirty(0.0f, 0.0f, width, height, opaque);
 #endif
 }
 
diff --git a/libs/hwui/LayerRenderer.h b/libs/hwui/LayerRenderer.h
@@ -47,7 +47,7 @@ class LayerRenderer: public OpenGLRenderer {
     ANDROID_API LayerRenderer(Layer* layer);
     virtual ~LayerRenderer();
 
-    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
+    virtual int prepareDirty(float left, float top, float right, float bottom, bool opaque);
     virtual void finish();
 
     virtual bool hasLayer();
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
@@ -164,11 +164,11 @@ void OpenGLRenderer::setViewport(int width, int height) {
     glEnableVertexAttribArray(Program::kBindingPosition);
 }
 
-void OpenGLRenderer::prepare(bool opaque) {
-    prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);
+int OpenGLRenderer::prepare(bool opaque) {
+    return prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);
 }
 
-void OpenGLRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {
+int OpenGLRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {
     mCaches.clearGarbage();
 
     mSnapshot = new Snapshot(mFirstSnapshot,
@@ -184,9 +184,12 @@ void OpenGLRenderer::prepareDirty(float left, float top, float right, float bott
     if (!opaque) {
         mCaches.setScissor(left, mSnapshot->height - bottom, right - left, bottom - top);
         glClear(GL_COLOR_BUFFER_BIT);
+        return DrawGlInfo::kStatusDrew;
     } else {
         mCaches.resetScissor();
     }
+
+    return DrawGlInfo::kStatusDone;
 }
 
 void OpenGLRenderer::syncState() {
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
@@ -67,8 +67,8 @@ class OpenGLRenderer {
 
     virtual void setViewport(int width, int height);
 
-    ANDROID_API void prepare(bool opaque);
-    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
+    ANDROID_API int prepare(bool opaque);
+    virtual int prepareDirty(float left, float top, float right, float bottom, bool opaque);
     virtual void finish();
 
     // These two calls must not be recorded in display lists

Original file line number	Diff line number	Diff line change
`@@ -1042,8 +1042,8 @@ boolean canDraw() {`
`1042`	`1042`	`return mGl != null && mCanvas != null;`
`1043`	`1043`	`}`
`1044`	`1044`
`1045`		`- void onPreDraw(Rect dirty) {`
`1046`		`-`
	`1045`	`+ int onPreDraw(Rect dirty) {`
	`1046`	`+ return DisplayList.STATUS_DONE;`
`1047`	`1047`	`}`
`1048`	`1048`
`1049`	`1049`	`void onPostDraw() {`
`@@ -1102,9 +1102,7 @@ boolean draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callba`
`1102`	`1102`	`}`
`1103`	`1103`	`}`
`1104`	`1104`
`1105`		`- onPreDraw(dirty);`
`1106`		`-`
`1107`		`- int status = DisplayList.STATUS_DONE;`
	`1105`	`+ int status = onPreDraw(dirty);`
`1108`	`1106`	`int saveCount = canvas.save();`
`1109`	`1107`	`callbacks.onHardwarePreDraw(canvas);`
`1110`	`1108`
`@@ -1138,7 +1136,7 @@ boolean draw(View view, View.AttachInfo attachInfo, HardwareDrawCallbacks callba`
`1138`	`1136`	`drawDisplayListStartTime = System.nanoTime();`
`1139`	`1137`	`}`
`1140`	`1138`
`1141`		`- status = canvas.drawDisplayList(displayList, mRedrawClip,`
	`1139`	`+ status \|= canvas.drawDisplayList(displayList, mRedrawClip,`
`1142`	`1140`	`DisplayList.FLAG_CLIP_CHILDREN);`
`1143`	`1141`
`1144`	`1142`	`if (mProfileEnabled) {`
`@@ -1372,8 +1370,8 @@ boolean canDraw() {`
`1372`	`1370`	`}`
`1373`	`1371`
`1374`	`1372`	`@Override`
`1375`		`- void onPreDraw(Rect dirty) {`
`1376`		`- mGlCanvas.onPreDraw(dirty);`
	`1373`	`+ int onPreDraw(Rect dirty) {`
	`1374`	`+ return mGlCanvas.onPreDraw(dirty);`
`1377`	`1375`	`}`
`1378`	`1376`
`1379`	`1377`	`@Override`
Original file line number	Diff line number	Diff line change
`@@ -1368,13 +1368,14 @@ void DisplayListRenderer::setViewport(int width, int height) {`
`1368`	`1368`	`mHeight = height;`
`1369`	`1369`	`}`
`1370`	`1370`
`1371`		`-void DisplayListRenderer::prepareDirty(float left, float top,`
	`1371`	`+int DisplayListRenderer::prepareDirty(float left, float top,`
`1372`	`1372`	`float right, float bottom, bool opaque) {`
`1373`	`1373`	`mSnapshot = new Snapshot(mFirstSnapshot,`
`1374`	`1374`	`SkCanvas::kMatrix_SaveFlag \| SkCanvas::kClip_SaveFlag);`
`1375`	`1375`	`mSaveCount = 1;`
`1376`	`1376`	`mSnapshot->setClip(0.0f, 0.0f, mWidth, mHeight);`
`1377`	`1377`	`mRestoreSaveCount = -1;`
	`1378`	`+ return DrawGlInfo::kStatusDone; // No invalidate needed at record-time`
`1378`	`1379`	`}`
`1379`	`1380`
`1380`	`1381`	`void DisplayListRenderer::finish() {`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ LayerRenderer::LayerRenderer(Layer* layer): mLayer(layer) {`
`37`	`37`	`LayerRenderer::~LayerRenderer() {`
`38`	`38`	`}`
`39`	`39`
`40`		`-void LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {`
	`40`	`+int LayerRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {`
`41`	`41`	`LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());`
`42`	`42`
`43`	`43`	`glBindFramebuffer(GL_FRAMEBUFFER, mLayer->getFbo());`
`@@ -57,9 +57,9 @@ void LayerRenderer::prepareDirty(float left, float top, float right, float botto`
`57`	`57`	`mLayer->region.subtractSelf(r);`
`58`	`58`	`}`
`59`	`59`
`60`		`- OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);`
	`60`	`+ return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);`
`61`	`61`	`#else`
`62`		`- OpenGLRenderer::prepareDirty(0.0f, 0.0f, width, height, opaque);`
	`62`	`+ return OpenGLRenderer::prepareDirty(0.0f, 0.0f, width, height, opaque);`
`63`	`63`	`#endif`
`64`	`64`	`}`
`65`	`65`
Original file line number	Diff line number	Diff line change
`@@ -164,11 +164,11 @@ void OpenGLRenderer::setViewport(int width, int height) {`
`164`	`164`	`glEnableVertexAttribArray(Program::kBindingPosition);`
`165`	`165`	`}`
`166`	`166`
`167`		`-void OpenGLRenderer::prepare(bool opaque) {`
`168`		`- prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);`
	`167`	`+int OpenGLRenderer::prepare(bool opaque) {`
	`168`	`+ return prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);`
`169`	`169`	`}`
`170`	`170`
`171`		`-void OpenGLRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {`
	`171`	`+int OpenGLRenderer::prepareDirty(float left, float top, float right, float bottom, bool opaque) {`
`172`	`172`	`mCaches.clearGarbage();`
`173`	`173`
`174`	`174`	`mSnapshot = new Snapshot(mFirstSnapshot,`
`@@ -184,9 +184,12 @@ void OpenGLRenderer::prepareDirty(float left, float top, float right, float bott`
`184`	`184`	`if (!opaque) {`
`185`	`185`	`mCaches.setScissor(left, mSnapshot->height - bottom, right - left, bottom - top);`
`186`	`186`	`glClear(GL_COLOR_BUFFER_BIT);`
	`187`	`+ return DrawGlInfo::kStatusDrew;`
`187`	`188`	`} else {`
`188`	`189`	`mCaches.resetScissor();`
`189`	`190`	`}`
	`191`	`+`
	`192`	`+ return DrawGlInfo::kStatusDone;`
`190`	`193`	`}`
`191`	`194`
`192`	`195`	`void OpenGLRenderer::syncState() {`