diff --git a/core/java/android/view/GLES20Canvas.java b/core/java/android/view/GLES20Canvas.java
index 308aa7c..c2ac39f 100644
--- a/core/java/android/view/GLES20Canvas.java
+++ b/core/java/android/view/GLES20Canvas.java
@@ -191,17 +191,17 @@
     private static native void nInsertReorderBarrier(long renderer, boolean enableReorder);
 
     @Override
-    public int onPreDraw(Rect dirty) {
+    public void onPreDraw(Rect dirty) {
         if (dirty != null) {
-            return nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom,
+            nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom,
                     mOpaque);
         } else {
-            return nPrepare(mRenderer, mOpaque);
+            nPrepare(mRenderer, mOpaque);
         }
     }
 
-    private static native int nPrepare(long renderer, boolean opaque);
-    private static native int nPrepareDirty(long renderer, int left, int top, int right, int bottom,
+    private static native void nPrepare(long renderer, boolean opaque);
+    private static native void nPrepareDirty(long renderer, int left, int top, int right, int bottom,
             boolean opaque);
 
     @Override
@@ -216,11 +216,11 @@
     ///////////////////////////////////////////////////////////////////////////
 
     @Override
-    public int callDrawGLFunction(long drawGLFunction) {
-        return nCallDrawGLFunction(mRenderer, drawGLFunction);
+    public void callDrawGLFunction(long drawGLFunction) {
+        nCallDrawGLFunction(mRenderer, drawGLFunction);
     }
 
-    private static native int nCallDrawGLFunction(long renderer, long drawGLFunction);
+    private static native void nCallDrawGLFunction(long renderer, long drawGLFunction);
 
     ///////////////////////////////////////////////////////////////////////////
     // Display list
@@ -229,12 +229,12 @@
     protected static native long nFinishRecording(long renderer);
 
     @Override
-    public int drawRenderNode(RenderNode renderNode, Rect dirty, int flags) {
-        return nDrawRenderNode(mRenderer, renderNode.getNativeDisplayList(), dirty, flags);
+    public void drawRenderNode(RenderNode renderNode, int flags) {
+        nDrawRenderNode(mRenderer, renderNode.getNativeDisplayList(), flags);
     }
 
-    private static native int nDrawRenderNode(long renderer, long renderNode,
-            Rect dirty, int flags);
+    private static native void nDrawRenderNode(long renderer, long renderNode,
+            int flags);
 
     ///////////////////////////////////////////////////////////////////////////
     // Hardware layer
diff --git a/core/java/android/view/HardwareCanvas.java b/core/java/android/view/HardwareCanvas.java
index e3eee71..4e30749 100644
--- a/core/java/android/view/HardwareCanvas.java
+++ b/core/java/android/view/HardwareCanvas.java
@@ -43,12 +43,10 @@
      * Invoked before any drawing operation is performed in this canvas.
      *
      * @param dirty The dirty rectangle to update, can be null.
-     * @return {@link RenderNode#STATUS_DREW} if anything was drawn (such as a call to clear
-     *         the canvas).
      *
      * @hide
      */
-    public abstract int onPreDraw(Rect dirty);
+    public abstract void onPreDraw(Rect dirty);
 
     /**
      * Invoked after all drawing operation have been performed.
@@ -64,7 +62,7 @@
      * @param renderNode The RenderNode to replay.
      */
     public void drawRenderNode(RenderNode renderNode) {
-        drawRenderNode(renderNode, null, RenderNode.FLAG_CLIP_CHILDREN);
+        drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);
     }
 
     /**
@@ -75,12 +73,9 @@
      * @param flags Optional flags about drawing, see {@link RenderNode} for
      *              the possible flags.
      *
-     * @return One of {@link RenderNode#STATUS_DONE} or {@link RenderNode#STATUS_DREW}
-     *         if anything was drawn.
-     *
      * @hide
      */
-    public abstract int drawRenderNode(RenderNode renderNode, Rect dirty, int flags);
+    public abstract void drawRenderNode(RenderNode renderNode, int flags);
 
     /**
      * Draws the specified layer onto this canvas.
@@ -101,13 +96,10 @@
      *
      * @param drawGLFunction A native function pointer
      *
-     * @return {@link RenderNode#STATUS_DONE}
-     *
      * @hide
      */
-    public int callDrawGLFunction(long drawGLFunction) {
+    public void callDrawGLFunction(long drawGLFunction) {
         // Noop - this is done in the display list recorder subclass
-        return RenderNode.STATUS_DONE;
     }
 
     public abstract void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,
diff --git a/core/java/android/view/View.java b/core/java/android/view/View.java
index 1d09696..b16ac75 100644
--- a/core/java/android/view/View.java
+++ b/core/java/android/view/View.java
@@ -15202,7 +15202,7 @@
                     }
                 } else {
                     mPrivateFlags &= ~PFLAG_DIRTY_MASK;
-                    ((HardwareCanvas) canvas).drawRenderNode(renderNode, null, flags);
+                    ((HardwareCanvas) canvas).drawRenderNode(renderNode, flags);
                 }
             }
         } else if (cache != null) {
diff --git a/core/java/android/widget/Editor.java b/core/java/android/widget/Editor.java
index 936da32..d5166f3 100644
--- a/core/java/android/widget/Editor.java
+++ b/core/java/android/widget/Editor.java
@@ -1402,7 +1402,7 @@
                     blockDisplayList.setLeftTopRightBottom(left, top, right, bottom);
                 }
 
-                ((HardwareCanvas) canvas).drawRenderNode(blockDisplayList, null,
+                ((HardwareCanvas) canvas).drawRenderNode(blockDisplayList,
                         0 /* no child clipping, our TextView parent enforces it */);
 
                 endOfPreviousBlock = blockEndLine;
diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp
index 7f9c7db..0505ac6 100644
--- a/core/jni/android_view_GLES20Canvas.cpp
+++ b/core/jni/android_view_GLES20Canvas.cpp
@@ -111,17 +111,17 @@
     renderer->insertReorderBarrier(reorderEnable);
 }
 
-static int android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,
+static void android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,
         jlong rendererPtr, jboolean opaque) {
     DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
-    return renderer->prepare(opaque);
+    renderer->prepare(opaque);
 }
 
-static int android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,
+static void android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,
         jlong rendererPtr, jint left, jint top, jint right, jint bottom,
         jboolean opaque) {
     DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
-    return renderer->prepareDirty(left, top, right, bottom, opaque);
+    renderer->prepareDirty(left, top, right, bottom, opaque);
 }
 
 static void android_view_GLES20Canvas_finish(JNIEnv* env, jobject clazz,
@@ -152,12 +152,12 @@
 // Functor
 // ----------------------------------------------------------------------------
 
-static jint android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz,
+static void android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz,
         jlong rendererPtr, jlong functorPtr) {
     DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
     Functor* functor = reinterpret_cast<Functor*>(functorPtr);
     android::uirenderer::Rect dirty;
-    return renderer->callDrawGLFunction(functor, dirty);
+    renderer->callDrawGLFunction(functor, dirty);
 }
 
 // ----------------------------------------------------------------------------
@@ -802,18 +802,13 @@
     return reinterpret_cast<jlong>(new DisplayListRenderer);
 }
 
-static jint android_view_GLES20Canvas_drawRenderNode(JNIEnv* env,
+static void android_view_GLES20Canvas_drawRenderNode(JNIEnv* env,
         jobject clazz, jlong rendererPtr, jlong renderNodePtr,
-        jobject dirty, jint flags) {
+        jint flags) {
     DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);
     RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
     android::uirenderer::Rect bounds;
-    status_t status = renderer->drawRenderNode(renderNode, bounds, flags);
-    if (status != DrawGlInfo::kStatusDone && dirty != NULL) {
-        env->CallVoidMethod(dirty, gRectClassInfo.set,
-                int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom));
-    }
-    return status;
+    renderer->drawRenderNode(renderNode, bounds, flags);
 }
 
 // ----------------------------------------------------------------------------
@@ -876,13 +871,13 @@
     { "nSetViewport",       "(JII)V",          (void*) android_view_GLES20Canvas_setViewport },
     { "nSetHighContrastText","(JZ)V",          (void*) android_view_GLES20Canvas_setHighContrastText },
     { "nInsertReorderBarrier","(JZ)V",         (void*) android_view_GLES20Canvas_insertReorderBarrier },
-    { "nPrepare",           "(JZ)I",           (void*) android_view_GLES20Canvas_prepare },
-    { "nPrepareDirty",      "(JIIIIZ)I",       (void*) android_view_GLES20Canvas_prepareDirty },
+    { "nPrepare",           "(JZ)V",           (void*) android_view_GLES20Canvas_prepare },
+    { "nPrepareDirty",      "(JIIIIZ)V",       (void*) android_view_GLES20Canvas_prepareDirty },
     { "nFinish",            "(J)V",            (void*) android_view_GLES20Canvas_finish },
     { "nSetProperty",           "(Ljava/lang/String;Ljava/lang/String;)V",
             (void*) android_view_GLES20Canvas_setProperty },
 
-    { "nCallDrawGLFunction", "(JJ)I",          (void*) android_view_GLES20Canvas_callDrawGLFunction },
+    { "nCallDrawGLFunction", "(JJ)V",          (void*) android_view_GLES20Canvas_callDrawGLFunction },
 
     { "nSave",              "(JI)I",           (void*) android_view_GLES20Canvas_save },
     { "nRestore",           "(J)V",            (void*) android_view_GLES20Canvas_restore },
@@ -942,14 +937,14 @@
     { "nDrawTextOnPath",    "(JLjava/lang/String;IIJFFIJJ)V",
             (void*) android_view_GLES20Canvas_drawTextOnPath },
 
-    { "nDrawTextRun",       "(J[CIIIIFFZJJ)V",  (void*) android_view_GLES20Canvas_drawTextRunArray },
+    { "nDrawTextRun",       "(J[CIIIIFFZJJ)V", (void*) android_view_GLES20Canvas_drawTextRunArray },
     { "nDrawTextRun",       "(JLjava/lang/String;IIIIFFZJJ)V",
             (void*) android_view_GLES20Canvas_drawTextRun },
 
     { "nGetClipBounds",     "(JLandroid/graphics/Rect;)Z", (void*) android_view_GLES20Canvas_getClipBounds },
 
-    { "nFinishRecording",   "(J)J",      (void*) android_view_GLES20Canvas_finishRecording },
-    { "nDrawRenderNode",    "(JJLandroid/graphics/Rect;I)I", (void*) android_view_GLES20Canvas_drawRenderNode },
+    { "nFinishRecording",   "(J)J",            (void*) android_view_GLES20Canvas_finishRecording },
+    { "nDrawRenderNode",    "(JJI)V",          (void*) android_view_GLES20Canvas_drawRenderNode },
 
     { "nCreateDisplayListRenderer", "()J",     (void*) android_view_GLES20Canvas_createDisplayListRenderer },
 
diff --git a/libs/hwui/DeferredDisplayList.cpp b/libs/hwui/DeferredDisplayList.cpp
index 7b279cb..a5e48e9 100644
--- a/libs/hwui/DeferredDisplayList.cpp
+++ b/libs/hwui/DeferredDisplayList.cpp
@@ -52,7 +52,7 @@
 
 class Batch {
 public:
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) = 0;
+    virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) = 0;
     virtual ~Batch() {}
     virtual bool purelyDrawBatch() { return false; }
     virtual bool coversBounds(const Rect& bounds) { return false; }
@@ -91,11 +91,10 @@
         return false;
     }
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
+    virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("%d  replaying DrawBatch %p, with %d ops (batch id %x, merge id %p)",
                 index, this, mOps.size(), getBatchId(), getMergeId());
 
-        status_t status = DrawGlInfo::kStatusDone;
         DisplayListLogBuffer& logBuffer = DisplayListLogBuffer::getInstance();
         for (unsigned int i = 0; i < mOps.size(); i++) {
             DrawOp* op = mOps[i].op;
@@ -106,7 +105,7 @@
             renderer.eventMark(op->name());
 #endif
             logBuffer.writeCommand(0, op->name());
-            status |= op->applyDraw(renderer, dirty);
+            op->applyDraw(renderer, dirty);
 
 #if DEBUG_MERGE_BEHAVIOR
             const Rect& bounds = state->mBounds;
@@ -118,7 +117,6 @@
                     batchColor);
 #endif
         }
-        return status;
     }
 
     virtual bool purelyDrawBatch() { return true; }
@@ -249,12 +247,13 @@
         if (newClipSideFlags & kClipSide_Bottom) mClipRect.bottom = state->mClip.bottom;
     }
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
+    virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("%d  replaying MergingDrawBatch %p, with %d ops,"
                 " clip flags %x (batch id %x, merge id %p)",
                 index, this, mOps.size(), mClipSideFlags, getBatchId(), getMergeId());
         if (mOps.size() == 1) {
-            return DrawBatch::replay(renderer, dirty, -1);
+            DrawBatch::replay(renderer, dirty, -1);
+            return;
         }
 
         // clipping in the merged case is done ahead of time since all ops share the clip (if any)
@@ -269,13 +268,12 @@
         renderer.eventMark("multiDraw");
         renderer.eventMark(op->name());
 #endif
-        status_t status = op->multiDraw(renderer, dirty, mOps, mBounds);
+        op->multiDraw(renderer, dirty, mOps, mBounds);
 
 #if DEBUG_MERGE_BEHAVIOR
         renderer.drawScreenSpaceColorRect(mBounds.left, mBounds.top, mBounds.right, mBounds.bottom,
                 DEBUG_COLOR_MERGEDBATCH);
 #endif
-        return status;
     }
 
 private:
@@ -293,7 +291,7 @@
     // creates a single operation batch
     StateOpBatch(const StateOp* op, const DeferredDisplayState* state) : mOp(op), mState(state) {}
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
+    virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("replaying state op batch %p", this);
         renderer.restoreDisplayState(*mState);
 
@@ -302,7 +300,6 @@
         // renderer.restoreToCount directly
         int saveCount = -1;
         mOp->applyState(renderer, saveCount);
-        return DrawGlInfo::kStatusDone;
     }
 
 private:
@@ -315,12 +312,11 @@
     RestoreToCountBatch(const StateOp* op, const DeferredDisplayState* state, int restoreCount) :
             mOp(op), mState(state), mRestoreCount(restoreCount) {}
 
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
+    virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         DEFER_LOGD("batch %p restoring to count %d", this, mRestoreCount);
 
         renderer.restoreDisplayState(*mState);
         renderer.restoreToCount(mRestoreCount);
-        return DrawGlInfo::kStatusDone;
     }
 
 private:
@@ -339,9 +335,8 @@
 
 #if DEBUG_MERGE_BEHAVIOR
 class BarrierDebugBatch : public Batch {
-    virtual status_t replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
+    virtual void replay(OpenGLRenderer& renderer, Rect& dirty, int index) {
         renderer.drawScreenSpaceColorRect(0, 0, 10000, 10000, DEBUG_COLOR_BARRIER);
-        return DrawGlInfo::kStatusDrew;
     }
 };
 #endif
@@ -628,26 +623,22 @@
 // Replay / flush
 /////////////////////////////////////////////////////////////////////////////////
 
-static status_t replayBatchList(const Vector<Batch*>& batchList,
+static void replayBatchList(const Vector<Batch*>& batchList,
         OpenGLRenderer& renderer, Rect& dirty) {
-    status_t status = DrawGlInfo::kStatusDone;
 
     for (unsigned int i = 0; i < batchList.size(); i++) {
         if (batchList[i]) {
-            status |= batchList[i]->replay(renderer, dirty, i);
+            batchList[i]->replay(renderer, dirty, i);
         }
     }
     DEFER_LOGD("--flushed, drew %d batches", batchList.size());
-    return status;
 }
 
-status_t DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) {
+void DeferredDisplayList::flush(OpenGLRenderer& renderer, Rect& dirty) {
     ATRACE_NAME("flush drawing commands");
     Caches::getInstance().fontRenderer->endPrecaching();
 
-    status_t status = DrawGlInfo::kStatusDone;
-
-    if (isEmpty()) return status; // nothing to flush
+    if (isEmpty()) return; // nothing to flush
     renderer.restoreToCount(1);
 
     DEFER_LOGD("--flushing");
@@ -665,14 +656,13 @@
 
     // NOTE: depth of the save stack at this point, before playback, should be reflected in
     // FLUSH_SAVE_STACK_DEPTH, so that save/restores match up correctly
-    status |= replayBatchList(mBatches, renderer, dirty);
+    replayBatchList(mBatches, renderer, dirty);
 
     renderer.restoreToCount(1);
     renderer.setDrawModifiers(restoreDrawModifiers);
 
     DEFER_LOGD("--flush complete, returning %x", status);
     clear();
-    return status;
 }
 
 void DeferredDisplayList::discardDrawingBatches(const unsigned int maxIndex) {
diff --git a/libs/hwui/DeferredDisplayList.h b/libs/hwui/DeferredDisplayList.h
index 885b411..9e48d3c 100644
--- a/libs/hwui/DeferredDisplayList.h
+++ b/libs/hwui/DeferredDisplayList.h
@@ -106,7 +106,7 @@
      * Plays back all of the draw ops recorded into batches to the renderer.
      * Adjusts the state of the renderer as necessary, and restores it when complete
      */
-    status_t flush(OpenGLRenderer& renderer, Rect& dirty);
+    void flush(OpenGLRenderer& renderer, Rect& dirty);
 
     void addClip(OpenGLRenderer& renderer, ClipOp* op);
     void addSaveLayer(OpenGLRenderer& renderer, SaveLayerOp* op, int newSaveCount);
diff --git a/libs/hwui/DisplayList.h b/libs/hwui/DisplayList.h
index 7094cc1..85c2367 100644
--- a/libs/hwui/DisplayList.h
+++ b/libs/hwui/DisplayList.h
@@ -105,10 +105,9 @@
 public:
     ReplayStateStruct(OpenGLRenderer& renderer, Rect& dirty, int replayFlags)
             : PlaybackStateStruct(renderer, replayFlags, &mReplayAllocator),
-            mDirty(dirty), mDrawGlStatus(DrawGlInfo::kStatusDone) {}
+            mDirty(dirty) {}
 
     Rect& mDirty;
-    status_t mDrawGlStatus;
     LinearAllocator mReplayAllocator;
 };
 
diff --git a/libs/hwui/DisplayListOp.h b/libs/hwui/DisplayListOp.h
index 26b4540..7627163 100644
--- a/libs/hwui/DisplayListOp.h
+++ b/libs/hwui/DisplayListOp.h
@@ -135,10 +135,10 @@
             return;
         }
 
-        replayStruct.mDrawGlStatus |= applyDraw(replayStruct.mRenderer, replayStruct.mDirty);
+        applyDraw(replayStruct.mRenderer, replayStruct.mDirty);
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) = 0;
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) = 0;
 
     /**
      * Draw multiple instances of an operation, must be overidden for operations that merge
@@ -147,14 +147,12 @@
      * and pure translation transformations. Other guarantees of similarity should be enforced by
      * reducing which operations are tagged as mergeable.
      */
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+    virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty,
             const Vector<OpStatePair>& ops, const Rect& bounds) {
-        status_t status = DrawGlInfo::kStatusDone;
         for (unsigned int i = 0; i < ops.size(); i++) {
             renderer.restoreDisplayState(*(ops[i].state), true);
-            status |= ops[i].op->applyDraw(renderer, dirty);
+            ops[i].op->applyDraw(renderer, dirty);
         }
-        return status;
     }
 
     /**
@@ -621,8 +619,8 @@
         }
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawBitmap(mBitmap, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawBitmap(mBitmap, mPaint);
     }
 
     AssetAtlas::Entry* getAtlasEntry() {
@@ -644,7 +642,7 @@
      * for each bitmap in the batch. This method is also responsible for dirtying
      * the current layer, if any.
      */
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+    virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty,
             const Vector<OpStatePair>& ops, const Rect& bounds) {
         const DeferredDisplayState& firstState = *(ops[0].state);
         renderer.restoreDisplayState(firstState, true); // restore all but the clip
@@ -681,7 +679,7 @@
             }
         }
 
-        return renderer.drawBitmaps(mBitmap, mEntry, ops.size(), &vertices[0],
+        renderer.drawBitmaps(mBitmap, mEntry, ops.size(), &vertices[0],
                 pureTranslate, bounds, mPaint);
     }
 
@@ -724,8 +722,8 @@
             : DrawBoundedOp(dstLeft, dstTop, dstRight, dstBottom, paint),
             mBitmap(bitmap), mSrc(srcLeft, srcTop, srcRight, srcBottom) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawBitmap(mBitmap, mSrc.left, mSrc.top, mSrc.right, mSrc.bottom,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawBitmap(mBitmap, mSrc.left, mSrc.top, mSrc.right, mSrc.bottom,
                 mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom,
                 mPaint);
     }
@@ -752,8 +750,8 @@
     DrawBitmapDataOp(const SkBitmap* bitmap, const SkPaint* paint)
             : DrawBitmapOp(bitmap, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawBitmapData(mBitmap, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawBitmapData(mBitmap, mPaint);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -776,8 +774,8 @@
             mBitmap(bitmap), mMeshWidth(meshWidth), mMeshHeight(meshHeight),
             mVertices(vertices), mColors(colors) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawBitmapMesh(mBitmap, mMeshWidth, mMeshHeight,
                 mVertices, mColors, mPaint);
     }
 
@@ -837,7 +835,7 @@
      * and transforming the vertices of each 9-patch in the batch. This method
      * is also responsible for dirtying the current layer, if any.
      */
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+    virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty,
             const Vector<OpStatePair>& ops, const Rect& bounds) {
         const DeferredDisplayState& firstState = *(ops[0].state);
         renderer.restoreDisplayState(firstState, true); // restore all but the clip
@@ -907,14 +905,14 @@
             indexCount += opMesh->indexCount;
         }
 
-        return renderer.drawPatches(mBitmap, getAtlasEntry(),
+        renderer.drawPatches(mBitmap, getAtlasEntry(),
                 &vertices[0], indexCount, mPaint);
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         // We're not calling the public variant of drawPatch() here
         // This method won't perform the quickReject() since we've already done it at this point
-        return renderer.drawPatch(mBitmap, getMesh(renderer), getAtlasEntry(),
+        renderer.drawPatch(mBitmap, getMesh(renderer), getAtlasEntry(),
                 mLocalBounds.left, mLocalBounds.top, mLocalBounds.right, mLocalBounds.bottom,
                 mPaint);
     }
@@ -951,8 +949,8 @@
     DrawColorOp(int color, SkXfermode::Mode mode)
             : DrawOp(NULL), mColor(color), mMode(mode) {};
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawColor(mColor, mMode);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawColor(mColor, mMode);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -998,8 +996,8 @@
     DrawRectOp(float left, float top, float right, float bottom, const SkPaint* paint)
             : DrawStrokableOp(left, top, right, bottom, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawRect(mLocalBounds.left, mLocalBounds.top,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawRect(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom, mPaint);
     }
 
@@ -1023,8 +1021,8 @@
             : DrawBoundedOp(rects, count, paint),
             mRects(rects), mCount(count) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawRects(mRects, mCount, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawRects(mRects, mCount, mPaint);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1049,8 +1047,8 @@
             float rx, float ry, const SkPaint* paint)
             : DrawStrokableOp(left, top, right, bottom, paint), mRx(rx), mRy(ry) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawRoundRect(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom, mRx, mRy, mPaint);
     }
 
@@ -1081,8 +1079,8 @@
             : DrawOp(paint), mLeft(left), mTop(top), mRight(right), mBottom(bottom),
             mRx(rx), mRy(ry) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawRoundRect(*mLeft, *mTop, *mRight, *mBottom,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawRoundRect(*mLeft, *mTop, *mRight, *mBottom,
                 *mRx, *mRy, mPaint);
     }
 
@@ -1108,8 +1106,8 @@
             : DrawStrokableOp(x - radius, y - radius, x + radius, y + radius, paint),
             mX(x), mY(y), mRadius(radius) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawCircle(mX, mY, mRadius, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawCircle(mX, mY, mRadius, mPaint);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1129,8 +1127,8 @@
     DrawCirclePropsOp(float* x, float* y, float* radius, const SkPaint* paint)
             : DrawOp(paint), mX(x), mY(y), mRadius(radius) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawCircle(*mX, *mY, *mRadius, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawCircle(*mX, *mY, *mRadius, mPaint);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1150,8 +1148,8 @@
     DrawOvalOp(float left, float top, float right, float bottom, const SkPaint* paint)
             : DrawStrokableOp(left, top, right, bottom, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawOval(mLocalBounds.left, mLocalBounds.top,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawOval(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom, mPaint);
     }
 
@@ -1169,8 +1167,8 @@
             : DrawStrokableOp(left, top, right, bottom, paint),
             mStartAngle(startAngle), mSweepAngle(sweepAngle), mUseCenter(useCenter) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawArc(mLocalBounds.left, mLocalBounds.top,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawArc(mLocalBounds.left, mLocalBounds.top,
                 mLocalBounds.right, mLocalBounds.bottom,
                 mStartAngle, mSweepAngle, mUseCenter, mPaint);
     }
@@ -1200,8 +1198,8 @@
         mLocalBounds.set(left, top, left + width, top + height);
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawPath(mPath, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawPath(mPath, mPaint);
     }
 
     virtual void onDefer(OpenGLRenderer& renderer, DeferInfo& deferInfo,
@@ -1229,8 +1227,8 @@
         mLocalBounds.outset(strokeWidthOutset());
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawLines(mPoints, mCount, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawLines(mPoints, mCount, mPaint);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1256,8 +1254,8 @@
     DrawPointsOp(const float* points, int count, const SkPaint* paint)
             : DrawLinesOp(points, count, paint) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawPoints(mPoints, mCount, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawPoints(mPoints, mCount, mPaint);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1305,8 +1303,8 @@
         /* TODO: inherit from DrawBounded and init mLocalBounds */
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath,
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawTextOnPath(mText, mBytesCount, mCount, mPath,
                 mHOffset, mVOffset, mPaint);
     }
 
@@ -1326,8 +1324,8 @@
         /* TODO: inherit from DrawBounded and init mLocalBounds */
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawPosText(mText, mBytesCount, mCount, mPositions, mPaint);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawPosText(mText, mBytesCount, mCount, mPositions, mPaint);
     }
 
     virtual const char* name() { return "DrawPosText"; }
@@ -1369,16 +1367,15 @@
                 && OpenGLRenderer::getXfermodeDirect(mPaint) == SkXfermode::kSrcOver_Mode;
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         Rect bounds;
         getLocalBounds(bounds);
-        return renderer.drawText(mText, mBytesCount, mCount, mX, mY,
+        renderer.drawText(mText, mBytesCount, mCount, mX, mY,
                 mPositions, mPaint, mTotalAdvance, bounds);
     }
 
-    virtual status_t multiDraw(OpenGLRenderer& renderer, Rect& dirty,
+    virtual void multiDraw(OpenGLRenderer& renderer, Rect& dirty,
             const Vector<OpStatePair>& ops, const Rect& bounds) {
-        status_t status = DrawGlInfo::kStatusDone;
         for (unsigned int i = 0; i < ops.size(); i++) {
             const DeferredDisplayState& state = *(ops[i].state);
             DrawOpMode drawOpMode = (i == ops.size() - 1) ? kDrawOpMode_Flush : kDrawOpMode_Defer;
@@ -1387,11 +1384,10 @@
             DrawTextOp& op = *((DrawTextOp*)ops[i].op);
             // quickReject() will not occure in drawText() so we can use mLocalBounds
             // directly, we do not need to account for shadow by calling getLocalBounds()
-            status |= renderer.drawText(op.mText, op.mBytesCount, op.mCount, op.mX, op.mY,
+            renderer.drawText(op.mText, op.mBytesCount, op.mCount, op.mX, op.mY,
                     op.mPositions, op.mPaint, op.mTotalAdvance, op.mLocalBounds,
                     drawOpMode);
         }
-        return status;
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1420,11 +1416,10 @@
     DrawFunctorOp(Functor* functor)
             : DrawOp(NULL), mFunctor(functor) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         renderer.startMark("GL functor");
-        status_t ret = renderer.callDrawGLFunction(mFunctor, dirty);
+        renderer.callDrawGLFunction(mFunctor, dirty);
         renderer.endMark();
-        return ret;
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1459,9 +1454,8 @@
         }
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         LOG_ALWAYS_FATAL("should not be called, because replay() is overridden");
-        return 0;
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1520,7 +1514,7 @@
                 &mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius());
     }
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
         TessellationCache::vertexBuffer_pair_t buffers;
         Matrix4 drawTransform(*(renderer.currentTransform()));
         renderer.getCaches().tessellationCache.getShadowBuffers(&drawTransform,
@@ -1528,7 +1522,7 @@
                 &mTransformXY, &mTransformZ, renderer.getLightCenter(), renderer.getLightRadius(),
                 buffers);
 
-        return renderer.drawShadow(mCasterAlpha, buffers.first, buffers.second);
+        renderer.drawShadow(mCasterAlpha, buffers.first, buffers.second);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
@@ -1551,8 +1545,8 @@
     DrawLayerOp(Layer* layer, float x, float y)
             : DrawOp(NULL), mLayer(layer), mX(x), mY(y) {}
 
-    virtual status_t applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
-        return renderer.drawLayer(mLayer, mX, mY);
+    virtual void applyDraw(OpenGLRenderer& renderer, Rect& dirty) {
+        renderer.drawLayer(mLayer, mX, mY);
     }
 
     virtual void output(int level, uint32_t logFlags) const {
diff --git a/libs/hwui/DisplayListRenderer.cpp b/libs/hwui/DisplayListRenderer.cpp
index 1d6d630..ab9ca1f 100644
--- a/libs/hwui/DisplayListRenderer.cpp
+++ b/libs/hwui/DisplayListRenderer.cpp
@@ -59,7 +59,7 @@
     return data;
 }
 
-status_t DisplayListRenderer::prepareDirty(float left, float top,
+void DisplayListRenderer::prepareDirty(float left, float top,
         float right, float bottom, bool opaque) {
 
     LOG_ALWAYS_FATAL_IF(mDisplayListData,
@@ -71,13 +71,12 @@
     mDeferredBarrierType = kBarrier_InOrder;
     mDirtyClip = opaque;
     mRestoreSaveCount = -1;
-
-    return DrawGlInfo::kStatusDone; // No invalidate needed at record-time
 }
 
-void DisplayListRenderer::finish() {
+bool DisplayListRenderer::finish() {
     flushRestoreToCount();
     flushTranslate();
+    return false;
 }
 
 void DisplayListRenderer::interrupt() {
@@ -86,11 +85,10 @@
 void DisplayListRenderer::resume() {
 }
 
-status_t DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) {
+void DisplayListRenderer::callDrawGLFunction(Functor *functor, Rect& dirty) {
     // Ignore dirty during recording, it matters only when we replay
     addDrawOp(new (alloc()) DrawFunctorOp(functor));
     mDisplayListData->functors.add(functor);
-    return DrawGlInfo::kStatusDone; // No invalidate needed at record-time
 }
 
 int DisplayListRenderer::save(int flags) {
@@ -177,32 +175,28 @@
     return StatefulBaseRenderer::clipRegion(region, op);
 }
 
-status_t DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t flags) {
+void DisplayListRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t flags) {
     LOG_ALWAYS_FATAL_IF(!renderNode, "missing rendernode");
 
     // dirty is an out parameter and should not be recorded,
     // it matters only when replaying the display list
     DrawRenderNodeOp* op = new (alloc()) DrawRenderNodeOp(renderNode, flags, *currentTransform());
     addRenderNodeOp(op);
-
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawLayer(Layer* layer, float x, float y) {
+void DisplayListRenderer::drawLayer(Layer* layer, float x, float y) {
     mDisplayListData->ref(layer);
     addDrawOp(new (alloc()) DrawLayerOp(layer, x, y));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
+void DisplayListRenderer::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
     bitmap = refBitmap(bitmap);
     paint = refPaint(paint);
 
     addDrawOp(new (alloc()) DrawBitmapOp(bitmap, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
+void DisplayListRenderer::drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
         float srcRight, float srcBottom, float dstLeft, float dstTop,
         float dstRight, float dstBottom, const SkPaint* paint) {
     if (srcLeft == 0 && srcTop == 0
@@ -222,18 +216,16 @@
                 srcLeft, srcTop, srcRight, srcBottom,
                 dstLeft, dstTop, dstRight, dstBottom, paint));
     }
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint) {
+void DisplayListRenderer::drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint) {
     bitmap = refBitmapData(bitmap);
     paint = refPaint(paint);
 
     addDrawOp(new (alloc()) DrawBitmapDataOp(bitmap, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
+void DisplayListRenderer::drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
         const float* vertices, const int* colors, const SkPaint* paint) {
     int vertexCount = (meshWidth + 1) * (meshHeight + 1);
     bitmap = refBitmap(bitmap);
@@ -243,39 +235,34 @@
 
     addDrawOp(new (alloc()) DrawBitmapMeshOp(bitmap, meshWidth, meshHeight,
                     vertices, colors, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
+void DisplayListRenderer::drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
         float left, float top, float right, float bottom, const SkPaint* paint) {
     bitmap = refBitmap(bitmap);
     patch = refPatch(patch);
     paint = refPaint(paint);
 
     addDrawOp(new (alloc()) DrawPatchOp(bitmap, patch, left, top, right, bottom, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawColor(int color, SkXfermode::Mode mode) {
+void DisplayListRenderer::drawColor(int color, SkXfermode::Mode mode) {
     addDrawOp(new (alloc()) DrawColorOp(color, mode));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawRect(float left, float top, float right, float bottom,
+void DisplayListRenderer::drawRect(float left, float top, float right, float bottom,
         const SkPaint* paint) {
     paint = refPaint(paint);
     addDrawOp(new (alloc()) DrawRectOp(left, top, right, bottom, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawRoundRect(float left, float top, float right, float bottom,
+void DisplayListRenderer::drawRoundRect(float left, float top, float right, float bottom,
         float rx, float ry, const SkPaint* paint) {
     paint = refPaint(paint);
     addDrawOp(new (alloc()) DrawRoundRectOp(left, top, right, bottom, rx, ry, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawRoundRect(
+void DisplayListRenderer::drawRoundRect(
         CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
         CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
         CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
@@ -289,16 +276,14 @@
     mDisplayListData->ref(paint);
     addDrawOp(new (alloc()) DrawRoundRectPropsOp(&left->value, &top->value,
             &right->value, &bottom->value, &rx->value, &ry->value, &paint->value));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawCircle(float x, float y, float radius, const SkPaint* paint) {
+void DisplayListRenderer::drawCircle(float x, float y, float radius, const SkPaint* paint) {
     paint = refPaint(paint);
     addDrawOp(new (alloc()) DrawCircleOp(x, y, radius, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
+void DisplayListRenderer::drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
         CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) {
     mDisplayListData->ref(x);
     mDisplayListData->ref(y);
@@ -306,55 +291,49 @@
     mDisplayListData->ref(paint);
     addDrawOp(new (alloc()) DrawCirclePropsOp(&x->value, &y->value,
             &radius->value, &paint->value));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawOval(float left, float top, float right, float bottom,
+void DisplayListRenderer::drawOval(float left, float top, float right, float bottom,
         const SkPaint* paint) {
     paint = refPaint(paint);
     addDrawOp(new (alloc()) DrawOvalOp(left, top, right, bottom, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawArc(float left, float top, float right, float bottom,
+void DisplayListRenderer::drawArc(float left, float top, float right, float bottom,
         float startAngle, float sweepAngle, bool useCenter, const SkPaint* paint) {
     if (fabs(sweepAngle) >= 360.0f) {
-        return drawOval(left, top, right, bottom, paint);
+        drawOval(left, top, right, bottom, paint);
+    } else {
+        paint = refPaint(paint);
+        addDrawOp(new (alloc()) DrawArcOp(left, top, right, bottom,
+                        startAngle, sweepAngle, useCenter, paint));
     }
-
-    paint = refPaint(paint);
-    addDrawOp(new (alloc()) DrawArcOp(left, top, right, bottom,
-                    startAngle, sweepAngle, useCenter, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawPath(const SkPath* path, const SkPaint* paint) {
+void DisplayListRenderer::drawPath(const SkPath* path, const SkPaint* paint) {
     path = refPath(path);
     paint = refPaint(paint);
 
     addDrawOp(new (alloc()) DrawPathOp(path, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawLines(const float* points, int count, const SkPaint* paint) {
+void DisplayListRenderer::drawLines(const float* points, int count, const SkPaint* paint) {
     points = refBuffer<float>(points, count);
     paint = refPaint(paint);
 
     addDrawOp(new (alloc()) DrawLinesOp(points, count, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawPoints(const float* points, int count, const SkPaint* paint) {
+void DisplayListRenderer::drawPoints(const float* points, int count, const SkPaint* paint) {
     points = refBuffer<float>(points, count);
     paint = refPaint(paint);
 
     addDrawOp(new (alloc()) DrawPointsOp(points, count, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
+void DisplayListRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
         const SkPath* path, float hOffset, float vOffset, const SkPaint* paint) {
-    if (!text || count <= 0) return DrawGlInfo::kStatusDone;
+    if (!text || count <= 0) return;
 
     text = refText(text, bytesCount);
     path = refPath(path);
@@ -363,12 +342,11 @@
     DrawOp* op = new (alloc()) DrawTextOnPathOp(text, bytesCount, count, path,
             hOffset, vOffset, paint);
     addDrawOp(op);
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawPosText(const char* text, int bytesCount, int count,
+void DisplayListRenderer::drawPosText(const char* text, int bytesCount, int count,
         const float* positions, const SkPaint* paint) {
-    if (!text || count <= 0) return DrawGlInfo::kStatusDone;
+    if (!text || count <= 0) return;
 
     text = refText(text, bytesCount);
     positions = refBuffer<float>(positions, count * 2);
@@ -376,7 +354,6 @@
 
     DrawOp* op = new (alloc()) DrawPosTextOp(text, bytesCount, count, positions, paint);
     addDrawOp(op);
-    return DrawGlInfo::kStatusDone;
 }
 
 static void simplifyPaint(int color, SkPaint* paint) {
@@ -389,11 +366,11 @@
     paint->setLooper(NULL);
 }
 
-status_t DisplayListRenderer::drawText(const char* text, int bytesCount, int count,
+void DisplayListRenderer::drawText(const char* text, int bytesCount, int count,
         float x, float y, const float* positions, const SkPaint* paint,
         float totalAdvance, const Rect& bounds, DrawOpMode drawOpMode) {
 
-    if (!text || count <= 0 || paintWillNotDrawText(*paint)) return DrawGlInfo::kStatusDone;
+    if (!text || count <= 0 || paintWillNotDrawText(*paint)) return;
 
     text = refText(text, bytesCount);
     positions = refBuffer<float>(positions, count * 2);
@@ -425,16 +402,14 @@
                 x, y, positions, paint, totalAdvance, bounds);
         addDrawOp(op);
     }
-    return DrawGlInfo::kStatusDone;
 }
 
-status_t DisplayListRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
-    if (count <= 0) return DrawGlInfo::kStatusDone;
+void DisplayListRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
+    if (count <= 0) return;
 
     rects = refBuffer<float>(rects, count);
     paint = refPaint(paint);
     addDrawOp(new (alloc()) DrawRectsOp(rects, count, paint));
-    return DrawGlInfo::kStatusDone;
 }
 
 void DisplayListRenderer::setDrawFilter(SkDrawFilter* filter) {
diff --git a/libs/hwui/DisplayListRenderer.h b/libs/hwui/DisplayListRenderer.h
index 3301ce4..34b0a1f 100644
--- a/libs/hwui/DisplayListRenderer.h
+++ b/libs/hwui/DisplayListRenderer.h
@@ -69,8 +69,8 @@
 // ----------------------------------------------------------------------------
 // Frame state operations
 // ----------------------------------------------------------------------------
-    virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque);
-    virtual void finish();
+    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
+    virtual bool finish();
     virtual void interrupt();
     virtual void resume();
 
@@ -108,57 +108,57 @@
 // ----------------------------------------------------------------------------
 // Canvas draw operations
 // ----------------------------------------------------------------------------
-    virtual status_t drawColor(int color, SkXfermode::Mode mode);
+    virtual void drawColor(int color, SkXfermode::Mode mode);
 
     // Bitmap-based
-    virtual status_t drawBitmap(const SkBitmap* bitmap, const SkPaint* paint);
-    virtual status_t drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
+    virtual void drawBitmap(const SkBitmap* bitmap, const SkPaint* paint);
+    virtual void drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
             float srcRight, float srcBottom, float dstLeft, float dstTop,
             float dstRight, float dstBottom, const SkPaint* paint);
-    virtual status_t drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint);
-    virtual status_t drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
+    virtual void drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint);
+    virtual void drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
             const float* vertices, const int* colors, const SkPaint* paint);
-    virtual status_t drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
+    virtual void drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
             float left, float top, float right, float bottom, const SkPaint* paint);
 
     // Shapes
-    virtual status_t drawRect(float left, float top, float right, float bottom,
+    virtual void drawRect(float left, float top, float right, float bottom,
             const SkPaint* paint);
-    virtual status_t drawRects(const float* rects, int count, const SkPaint* paint);
-    virtual status_t drawRoundRect(float left, float top, float right, float bottom,
+    virtual void drawRects(const float* rects, int count, const SkPaint* paint);
+    virtual void drawRoundRect(float left, float top, float right, float bottom,
             float rx, float ry, const SkPaint* paint);
-    virtual status_t drawRoundRect(CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
+    virtual void drawRoundRect(CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
                 CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
                 CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
                 CanvasPropertyPaint* paint);
-    virtual status_t drawCircle(float x, float y, float radius, const SkPaint* paint);
-    virtual status_t drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
+    virtual void drawCircle(float x, float y, float radius, const SkPaint* paint);
+    virtual void drawCircle(CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
                 CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint);
-    virtual status_t drawOval(float left, float top, float right, float bottom,
+    virtual void drawOval(float left, float top, float right, float bottom,
             const SkPaint* paint);
-    virtual status_t drawArc(float left, float top, float right, float bottom,
+    virtual void drawArc(float left, float top, float right, float bottom,
             float startAngle, float sweepAngle, bool useCenter, const SkPaint* paint);
-    virtual status_t drawPath(const SkPath* path, const SkPaint* paint);
-    virtual status_t drawLines(const float* points, int count, const SkPaint* paint);
-    virtual status_t drawPoints(const float* points, int count, const SkPaint* paint);
+    virtual void drawPath(const SkPath* path, const SkPaint* paint);
+    virtual void drawLines(const float* points, int count, const SkPaint* paint);
+    virtual void drawPoints(const float* points, int count, const SkPaint* paint);
 
     // Text
-    virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y,
+    virtual void drawText(const char* text, int bytesCount, int count, float x, float y,
             const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds,
             DrawOpMode drawOpMode = kDrawOpMode_Immediate);
-    virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path,
+    virtual void drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path,
             float hOffset, float vOffset, const SkPaint* paint);
-    virtual status_t drawPosText(const char* text, int bytesCount, int count,
+    virtual void drawPosText(const char* text, int bytesCount, int count,
             const float* positions, const SkPaint* paint);
 
 // ----------------------------------------------------------------------------
 // Canvas draw operations - special
 // ----------------------------------------------------------------------------
-    virtual status_t drawLayer(Layer* layer, float x, float y);
-    virtual status_t drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags);
+    virtual void drawLayer(Layer* layer, float x, float y);
+    virtual void drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags);
 
     // TODO: rename for consistency
-    virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty);
+    virtual void callDrawGLFunction(Functor* functor, Rect& dirty);
 
     void setHighContrastText(bool highContrastText) {
         mHighContrastText = highContrastText;
diff --git a/libs/hwui/LayerRenderer.cpp b/libs/hwui/LayerRenderer.cpp
index 394c647..9306f13 100644
--- a/libs/hwui/LayerRenderer.cpp
+++ b/libs/hwui/LayerRenderer.cpp
@@ -43,7 +43,7 @@
 LayerRenderer::~LayerRenderer() {
 }
 
-status_t LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
+void LayerRenderer::prepareDirty(float left, float top, float right, float bottom,
         bool opaque) {
     LAYER_RENDERER_LOGD("Rendering into layer, fbo = %d", mLayer->getFbo());
 
@@ -64,25 +64,23 @@
     }
     mLayer->clipRect.set(dirty);
 
-    return OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
+    OpenGLRenderer::prepareDirty(dirty.left, dirty.top, dirty.right, dirty.bottom, opaque);
 }
 
-status_t LayerRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
+void LayerRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
     if (mLayer->isDirty()) {
         getCaches().disableScissor();
         glClear(GL_COLOR_BUFFER_BIT);
 
         getCaches().resetScissor();
         mLayer->setDirty(false);
-
-        return DrawGlInfo::kStatusDone;
+    } else {
+        OpenGLRenderer::clear(left, top, right, bottom, opaque);
     }
-
-    return OpenGLRenderer::clear(left, top, right, bottom, opaque);
 }
 
-void LayerRenderer::finish() {
-    OpenGLRenderer::finish();
+bool LayerRenderer::finish() {
+    bool retval = OpenGLRenderer::finish();
 
     generateMesh();
 
@@ -90,6 +88,7 @@
 
     // No need to unbind our FBO, this will be taken care of by the caller
     // who will invoke OpenGLRenderer::resume()
+    return retval;
 }
 
 GLuint LayerRenderer::getTargetFbo() const {
diff --git a/libs/hwui/LayerRenderer.h b/libs/hwui/LayerRenderer.h
index 4d8620b..47099bf 100644
--- a/libs/hwui/LayerRenderer.h
+++ b/libs/hwui/LayerRenderer.h
@@ -50,9 +50,9 @@
     virtual ~LayerRenderer();
 
     virtual void onViewportInitialized() { /* do nothing */ }
-    virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque);
-    virtual status_t clear(float left, float top, float right, float bottom, bool opaque);
-    virtual void finish();
+    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
+    virtual void clear(float left, float top, float right, float bottom, bool opaque);
+    virtual bool finish();
 
     static Layer* createTextureLayer(RenderState& renderState);
     static Layer* createRenderLayer(RenderState& renderState, uint32_t width, uint32_t height);
diff --git a/libs/hwui/OpenGLRenderer.cpp b/libs/hwui/OpenGLRenderer.cpp
index 39c420f..1ac9e7b 100755
--- a/libs/hwui/OpenGLRenderer.cpp
+++ b/libs/hwui/OpenGLRenderer.cpp
@@ -154,6 +154,7 @@
         , mScissorOptimizationDisabled(false)
         , mSuppressTiling(false)
         , mFirstFrameAfterResize(true)
+        , mDirty(false)
         , mLightCenter((Vector3){FLT_MIN, FLT_MIN, FLT_MIN})
         , mLightRadius(FLT_MIN)
         , mAmbientShadowAlpha(0)
@@ -209,8 +210,8 @@
     mTilingClip.set(left, top, right, bottom);
 }
 
-status_t OpenGLRenderer::startFrame() {
-    if (mFrameStarted) return DrawGlInfo::kStatusDone;
+void OpenGLRenderer::startFrame() {
+    if (mFrameStarted) return;
     mFrameStarted = true;
 
     mDirtyClip = true;
@@ -230,11 +231,11 @@
 
     debugOverdraw(true, true);
 
-    return clear(mTilingClip.left, mTilingClip.top,
+    clear(mTilingClip.left, mTilingClip.top,
             mTilingClip.right, mTilingClip.bottom, mOpaque);
 }
 
-status_t OpenGLRenderer::prepareDirty(float left, float top,
+void OpenGLRenderer::prepareDirty(float left, float top,
         float right, float bottom, bool opaque) {
 
     setupFrameState(left, top, right, bottom, opaque);
@@ -247,10 +248,8 @@
         syncState();
         updateLayers();
     } else {
-        return startFrame();
+        startFrame();
     }
-
-    return DrawGlInfo::kStatusDone;
 }
 
 void OpenGLRenderer::discardFramebuffer(float left, float top, float right, float bottom) {
@@ -267,16 +266,16 @@
     }
 }
 
-status_t OpenGLRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
+void OpenGLRenderer::clear(float left, float top, float right, float bottom, bool opaque) {
     if (!opaque) {
         mCaches.enableScissor();
         mCaches.setScissor(left, getViewportHeight() - bottom, right - left, bottom - top);
         glClear(GL_COLOR_BUFFER_BIT);
-        return DrawGlInfo::kStatusDrew;
+        mDirty = true;
+        return;
     }
 
     mCaches.resetScissor();
-    return DrawGlInfo::kStatusDone;
 }
 
 void OpenGLRenderer::syncState() {
@@ -324,7 +323,7 @@
     if (!mSuppressTiling) mCaches.endTiling();
 }
 
-void OpenGLRenderer::finish() {
+bool OpenGLRenderer::finish() {
     renderOverdraw();
     endTiling();
 
@@ -350,6 +349,8 @@
     }
 
     mFrameStarted = false;
+
+    return reportAndClearDirty();
 }
 
 void OpenGLRenderer::resumeAfterLayer() {
@@ -361,8 +362,8 @@
     dirtyClip();
 }
 
-status_t OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
-    if (currentSnapshot()->isIgnored()) return DrawGlInfo::kStatusDone;
+void OpenGLRenderer::callDrawGLFunction(Functor* functor, Rect& dirty) {
+    if (currentSnapshot()->isIgnored()) return;
 
     Rect clip(*currentClipRect());
     clip.snapToPixelBoundaries();
@@ -396,7 +397,7 @@
     // Scissor may have been modified, reset dirty clip
     dirtyClip();
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1928,18 +1929,17 @@
 // Drawing
 ///////////////////////////////////////////////////////////////////////////////
 
-status_t OpenGLRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags) {
-    status_t status;
+void OpenGLRenderer::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t replayFlags) {
     // All the usual checks and setup operations (quickReject, setupDraw, etc.)
     // will be performed by the display list itself
     if (renderNode && renderNode->isRenderable()) {
         // compute 3d ordering
         renderNode->computeOrdering();
         if (CC_UNLIKELY(mCaches.drawDeferDisabled)) {
-            status = startFrame();
+            startFrame();
             ReplayStateStruct replayStruct(*this, dirty, replayFlags);
             renderNode->replay(replayStruct, 0);
-            return status | replayStruct.mDrawGlStatus;
+            return;
         }
 
         DeferredDisplayList deferredList(*currentClipRect());
@@ -1947,14 +1947,14 @@
         renderNode->defer(deferStruct, 0);
 
         flushLayers();
-        status = startFrame();
+        startFrame();
 
-        return deferredList.flush(*this, dirty) | status;
+        deferredList.flush(*this, dirty);
+    } else {
+        // Even if there is no drawing command(Ex: invisible),
+        // it still needs startFrame to clear buffer and start tiling.
+        startFrame();
     }
-
-    // Even if there is no drawing command(Ex: invisible),
-    // it still needs startFrame to clear buffer and start tiling.
-    return startFrame();
 }
 
 void OpenGLRenderer::drawAlphaBitmap(Texture* texture, float left, float top, const SkPaint* paint) {
@@ -1988,12 +1988,12 @@
  * will not set the scissor enable or dirty the current layer, if any.
  * The caller is responsible for properly dirtying the current layer.
  */
-status_t OpenGLRenderer::drawBitmaps(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
+void OpenGLRenderer::drawBitmaps(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
         int bitmapCount, TextureVertex* vertices, bool pureTranslate,
         const Rect& bounds, const SkPaint* paint) {
     mCaches.activeTexture(0);
     Texture* texture = entry ? entry->texture : mCaches.textureCache.get(bitmap);
-    if (!texture) return DrawGlInfo::kStatusDone;
+    if (!texture) return;
 
     const AutoTexture autoCleanup(texture);
 
@@ -2014,17 +2014,17 @@
                 kModelViewMode_Translate, false);
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
+void OpenGLRenderer::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
     if (quickRejectSetupScissor(0, 0, bitmap->width(), bitmap->height())) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     mCaches.activeTexture(0);
     Texture* texture = getTexture(bitmap);
-    if (!texture) return DrawGlInfo::kStatusDone;
+    if (!texture) return;
     const AutoTexture autoCleanup(texture);
 
     if (CC_UNLIKELY(bitmap->colorType() == kAlpha_8_SkColorType)) {
@@ -2033,12 +2033,12 @@
         drawTextureRect(0, 0, bitmap->width(), bitmap->height(), texture, paint);
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint) {
+void OpenGLRenderer::drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint) {
     if (quickRejectSetupScissor(0, 0, bitmap->width(), bitmap->height())) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     mCaches.activeTexture(0);
@@ -2051,13 +2051,13 @@
         drawTextureRect(0, 0, bitmap->width(), bitmap->height(), texture, paint);
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
+void OpenGLRenderer::drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
         const float* vertices, const int* colors, const SkPaint* paint) {
     if (!vertices || currentSnapshot()->isIgnored()) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     // TODO: use quickReject on bounds from vertices
@@ -2124,14 +2124,14 @@
 
     if (quickRejectSetupScissor(left, top, right, bottom)) {
         if (cleanupColors) delete[] colors;
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     if (!texture) {
         texture = mCaches.textureCache.get(bitmap);
         if (!texture) {
             if (cleanupColors) delete[] colors;
-            return DrawGlInfo::kStatusDone;
+            return;
         }
     }
     const AutoTexture autoCleanup(texture);
@@ -2171,20 +2171,20 @@
 
     if (cleanupColors) delete[] colors;
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawBitmap(const SkBitmap* bitmap,
+void OpenGLRenderer::drawBitmap(const SkBitmap* bitmap,
          float srcLeft, float srcTop, float srcRight, float srcBottom,
          float dstLeft, float dstTop, float dstRight, float dstBottom,
          const SkPaint* paint) {
     if (quickRejectSetupScissor(dstLeft, dstTop, dstRight, dstBottom)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     mCaches.activeTexture(0);
     Texture* texture = getTexture(bitmap);
-    if (!texture) return DrawGlInfo::kStatusDone;
+    if (!texture) return;
     const AutoTexture autoCleanup(texture);
 
     const float width = texture->width;
@@ -2258,33 +2258,33 @@
 
     resetDrawTextureTexCoords(0.0f, 0.0f, 1.0f, 1.0f);
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
+void OpenGLRenderer::drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
         float left, float top, float right, float bottom, const SkPaint* paint) {
     if (quickRejectSetupScissor(left, top, right, bottom)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     AssetAtlas::Entry* entry = mCaches.assetAtlas.getEntry(bitmap);
     const Patch* mesh = mCaches.patchCache.get(entry, bitmap->width(), bitmap->height(),
             right - left, bottom - top, patch);
 
-    return drawPatch(bitmap, mesh, entry, left, top, right, bottom, paint);
+    drawPatch(bitmap, mesh, entry, left, top, right, bottom, paint);
 }
 
-status_t OpenGLRenderer::drawPatch(const SkBitmap* bitmap, const Patch* mesh,
+void OpenGLRenderer::drawPatch(const SkBitmap* bitmap, const Patch* mesh,
         AssetAtlas::Entry* entry, float left, float top, float right, float bottom,
         const SkPaint* paint) {
     if (quickRejectSetupScissor(left, top, right, bottom)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     if (CC_LIKELY(mesh && mesh->verticesCount > 0)) {
         mCaches.activeTexture(0);
         Texture* texture = entry ? entry->texture : mCaches.textureCache.get(bitmap);
-        if (!texture) return DrawGlInfo::kStatusDone;
+        if (!texture) return;
         const AutoTexture autoCleanup(texture);
 
         texture->setWrap(GL_CLAMP_TO_EDGE, true);
@@ -2326,7 +2326,7 @@
                 mCaches.patchCache.getMeshBuffer(), kModelViewMode_Translate, !mesh->hasEmptyQuads);
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
 /**
@@ -2334,11 +2334,11 @@
  * will not set the scissor enable or dirty the current layer, if any.
  * The caller is responsible for properly dirtying the current layer.
  */
-status_t OpenGLRenderer::drawPatches(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
+void OpenGLRenderer::drawPatches(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
         TextureVertex* vertices, uint32_t indexCount, const SkPaint* paint) {
     mCaches.activeTexture(0);
     Texture* texture = entry ? entry->texture : mCaches.textureCache.get(bitmap);
-    if (!texture) return DrawGlInfo::kStatusDone;
+    if (!texture) return;
     const AutoTexture autoCleanup(texture);
 
     texture->setWrap(GL_CLAMP_TO_EDGE, true);
@@ -2348,15 +2348,15 @@
             texture->blend, &vertices[0].x, &vertices[0].u,
             GL_TRIANGLES, indexCount, false, true, 0, kModelViewMode_Translate, false);
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawVertexBuffer(float translateX, float translateY,
+void OpenGLRenderer::drawVertexBuffer(float translateX, float translateY,
         const VertexBuffer& vertexBuffer, const SkPaint* paint, int displayFlags) {
     // not missing call to quickReject/dirtyLayer, always done at a higher level
     if (!vertexBuffer.getVertexCount()) {
         // no vertices to draw
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     Rect bounds(vertexBuffer.getBounds());
@@ -2414,7 +2414,7 @@
         glDisableVertexAttribArray(alphaSlot);
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
 /**
@@ -2426,11 +2426,11 @@
  *
  * Doesn't yet support joins, caps, or path effects.
  */
-status_t OpenGLRenderer::drawConvexPath(const SkPath& path, const SkPaint* paint) {
+void OpenGLRenderer::drawConvexPath(const SkPath& path, const SkPaint* paint) {
     VertexBuffer vertexBuffer;
     // TODO: try clipping large paths to viewport
     PathTessellator::tessellatePath(path, paint, *currentTransform(), vertexBuffer);
-    return drawVertexBuffer(vertexBuffer, paint);
+    drawVertexBuffer(vertexBuffer, paint);
 }
 
 /**
@@ -2444,8 +2444,8 @@
  * TODO: try using a fixed input buffer for non-capped lines as in text rendering. this may reduce
  * memory transfer by removing need for degenerate vertices.
  */
-status_t OpenGLRenderer::drawLines(const float* points, int count, const SkPaint* paint) {
-    if (currentSnapshot()->isIgnored() || count < 4) return DrawGlInfo::kStatusDone;
+void OpenGLRenderer::drawLines(const float* points, int count, const SkPaint* paint) {
+    if (currentSnapshot()->isIgnored() || count < 4) return;
 
     count &= ~0x3; // round down to nearest four
 
@@ -2454,15 +2454,15 @@
     const Rect& bounds = buffer.getBounds();
 
     if (quickRejectSetupScissor(bounds.left, bounds.top, bounds.right, bounds.bottom)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     int displayFlags = paint->isAntiAlias() ? 0 : kVertexBuffer_Offset;
-    return drawVertexBuffer(buffer, paint, displayFlags);
+    drawVertexBuffer(buffer, paint, displayFlags);
 }
 
-status_t OpenGLRenderer::drawPoints(const float* points, int count, const SkPaint* paint) {
-    if (currentSnapshot()->isIgnored() || count < 2) return DrawGlInfo::kStatusDone;
+void OpenGLRenderer::drawPoints(const float* points, int count, const SkPaint* paint) {
+    if (currentSnapshot()->isIgnored() || count < 2) return;
 
     count &= ~0x1; // round down to nearest two
 
@@ -2471,16 +2471,18 @@
 
     const Rect& bounds = buffer.getBounds();
     if (quickRejectSetupScissor(bounds.left, bounds.top, bounds.right, bounds.bottom)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     int displayFlags = paint->isAntiAlias() ? 0 : kVertexBuffer_Offset;
-    return drawVertexBuffer(buffer, paint, displayFlags);
+    drawVertexBuffer(buffer, paint, displayFlags);
+
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
+void OpenGLRenderer::drawColor(int color, SkXfermode::Mode mode) {
     // No need to check against the clip, we fill the clip region
-    if (currentSnapshot()->isIgnored()) return DrawGlInfo::kStatusDone;
+    if (currentSnapshot()->isIgnored()) return;
 
     Rect clip(*currentClipRect());
     clip.snapToPixelBoundaries();
@@ -2491,12 +2493,12 @@
 
     drawColorRect(clip.left, clip.top, clip.right, clip.bottom, &paint, true);
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawShape(float left, float top, const PathTexture* texture,
+void OpenGLRenderer::drawShape(float left, float top, const PathTexture* texture,
         const SkPaint* paint) {
-    if (!texture) return DrawGlInfo::kStatusDone;
+    if (!texture) return;
     const AutoTexture autoCleanup(texture);
 
     const float x = left + texture->left - texture->offset;
@@ -2504,79 +2506,79 @@
 
     drawPathTexture(texture, x, y, paint);
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawRoundRect(float left, float top, float right, float bottom,
+void OpenGLRenderer::drawRoundRect(float left, float top, float right, float bottom,
         float rx, float ry, const SkPaint* p) {
     if (currentSnapshot()->isIgnored()
             || quickRejectSetupScissor(left, top, right, bottom, p)
             || paintWillNotDraw(*p)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     if (p->getPathEffect() != 0) {
         mCaches.activeTexture(0);
         const PathTexture* texture = mCaches.pathCache.getRoundRect(
                 right - left, bottom - top, rx, ry, p);
-        return drawShape(left, top, texture, p);
+        drawShape(left, top, texture, p);
+    } else {
+        const VertexBuffer* vertexBuffer = mCaches.tessellationCache.getRoundRect(
+                *currentTransform(), *p, right - left, bottom - top, rx, ry);
+        drawVertexBuffer(left, top, *vertexBuffer, p);
     }
-
-    const VertexBuffer* vertexBuffer = mCaches.tessellationCache.getRoundRect(
-            *currentTransform(), *p, right - left, bottom - top, rx, ry);
-    return drawVertexBuffer(left, top, *vertexBuffer, p);
 }
 
-status_t OpenGLRenderer::drawCircle(float x, float y, float radius, const SkPaint* p) {
+void OpenGLRenderer::drawCircle(float x, float y, float radius, const SkPaint* p) {
     if (currentSnapshot()->isIgnored()
             || quickRejectSetupScissor(x - radius, y - radius, x + radius, y + radius, p)
             || paintWillNotDraw(*p)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
     if (p->getPathEffect() != 0) {
         mCaches.activeTexture(0);
         const PathTexture* texture = mCaches.pathCache.getCircle(radius, p);
-        return drawShape(x - radius, y - radius, texture, p);
-    }
-
-    SkPath path;
-    if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
-        path.addCircle(x, y, radius + p->getStrokeWidth() / 2);
+        drawShape(x - radius, y - radius, texture, p);
     } else {
-        path.addCircle(x, y, radius);
+        SkPath path;
+        if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
+            path.addCircle(x, y, radius + p->getStrokeWidth() / 2);
+        } else {
+            path.addCircle(x, y, radius);
+        }
+        drawConvexPath(path, p);
     }
-    return drawConvexPath(path, p);
 }
 
-status_t OpenGLRenderer::drawOval(float left, float top, float right, float bottom,
+void OpenGLRenderer::drawOval(float left, float top, float right, float bottom,
         const SkPaint* p) {
     if (currentSnapshot()->isIgnored()
             || quickRejectSetupScissor(left, top, right, bottom, p)
             || paintWillNotDraw(*p)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     if (p->getPathEffect() != 0) {
         mCaches.activeTexture(0);
         const PathTexture* texture = mCaches.pathCache.getOval(right - left, bottom - top, p);
-        return drawShape(left, top, texture, p);
+        drawShape(left, top, texture, p);
+    } else {
+        SkPath path;
+        SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
+        if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
+            rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
+        }
+        path.addOval(rect);
+        drawConvexPath(path, p);
     }
-
-    SkPath path;
-    SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
-    if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
-        rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
-    }
-    path.addOval(rect);
-    return drawConvexPath(path, p);
 }
 
-status_t OpenGLRenderer::drawArc(float left, float top, float right, float bottom,
+void OpenGLRenderer::drawArc(float left, float top, float right, float bottom,
         float startAngle, float sweepAngle, bool useCenter, const SkPaint* p) {
     if (currentSnapshot()->isIgnored()
             || quickRejectSetupScissor(left, top, right, bottom, p)
             || paintWillNotDraw(*p)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     // TODO: support fills (accounting for concavity if useCenter && sweepAngle > 180)
@@ -2584,9 +2586,9 @@
         mCaches.activeTexture(0);
         const PathTexture* texture = mCaches.pathCache.getArc(right - left, bottom - top,
                 startAngle, sweepAngle, useCenter, p);
-        return drawShape(left, top, texture, p);
+        drawShape(left, top, texture, p);
+        return;
     }
-
     SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
     if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
         rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
@@ -2600,18 +2602,18 @@
     if (useCenter) {
         path.close();
     }
-    return drawConvexPath(path, p);
+    drawConvexPath(path, p);
 }
 
 // See SkPaintDefaults.h
 #define SkPaintDefaults_MiterLimit SkIntToScalar(4)
 
-status_t OpenGLRenderer::drawRect(float left, float top, float right, float bottom,
+void OpenGLRenderer::drawRect(float left, float top, float right, float bottom,
         const SkPaint* p) {
     if (currentSnapshot()->isIgnored()
             || quickRejectSetupScissor(left, top, right, bottom, p)
             || paintWillNotDraw(*p)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     if (p->getStyle() != SkPaint::kFill_Style) {
@@ -2621,25 +2623,26 @@
             mCaches.activeTexture(0);
             const PathTexture* texture =
                     mCaches.pathCache.getRect(right - left, bottom - top, p);
-            return drawShape(left, top, texture, p);
+            drawShape(left, top, texture, p);
+        } else {
+            SkPath path;
+            SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
+            if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
+                rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
+            }
+            path.addRect(rect);
+            drawConvexPath(path, p);
         }
-
-        SkPath path;
-        SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
-        if (p->getStyle() == SkPaint::kStrokeAndFill_Style) {
-            rect.outset(p->getStrokeWidth() / 2, p->getStrokeWidth() / 2);
-        }
-        path.addRect(rect);
-        return drawConvexPath(path, p);
-    }
-
-    if (p->isAntiAlias() && !currentTransform()->isSimple()) {
-        SkPath path;
-        path.addRect(left, top, right, bottom);
-        return drawConvexPath(path, p);
     } else {
-        drawColorRect(left, top, right, bottom, p);
-        return DrawGlInfo::kStatusDrew;
+        if (p->isAntiAlias() && !currentTransform()->isSimple()) {
+            SkPath path;
+            path.addRect(left, top, right, bottom);
+            drawConvexPath(path, p);
+        } else {
+            drawColorRect(left, top, right, bottom, p);
+
+            mDirty = true;
+        }
     }
 }
 
@@ -2694,15 +2697,15 @@
     return alpha == 0.0f && getXfermode(paint->getXfermode()) == SkXfermode::kSrcOver_Mode;
 }
 
-status_t OpenGLRenderer::drawPosText(const char* text, int bytesCount, int count,
+void OpenGLRenderer::drawPosText(const char* text, int bytesCount, int count,
         const float* positions, const SkPaint* paint) {
     if (text == NULL || count == 0 || currentSnapshot()->isIgnored() || canSkipText(paint)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     // NOTE: Skia does not support perspective transform on drawPosText yet
     if (!currentTransform()->isSimple()) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     mCaches.enableScissor();
@@ -2750,7 +2753,7 @@
         }
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
 bool OpenGLRenderer::findBestFontTransform(const mat4& transform, SkMatrix* outMatrix) const {
@@ -2774,7 +2777,7 @@
     return true;
 }
 
-status_t OpenGLRenderer::drawText(const char* text, int bytesCount, int count, float x, float y,
+void OpenGLRenderer::drawText(const char* text, int bytesCount, int count, float x, float y,
         const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds,
         DrawOpMode drawOpMode) {
 
@@ -2783,7 +2786,7 @@
         // drawing as ops from DeferredDisplayList are already filtered for these
         if (text == NULL || count == 0 || currentSnapshot()->isIgnored() || canSkipText(paint) ||
                 quickRejectSetupScissor(bounds)) {
-            return DrawGlInfo::kStatusDone;
+            return;
         }
     }
 
@@ -2858,13 +2861,13 @@
 
     drawTextDecorations(totalAdvance, oldX, oldY, paint);
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
+void OpenGLRenderer::drawTextOnPath(const char* text, int bytesCount, int count,
         const SkPath* path, float hOffset, float vOffset, const SkPaint* paint) {
     if (text == NULL || count == 0 || currentSnapshot()->isIgnored() || canSkipText(paint)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     // TODO: avoid scissor by calculating maximum bounds using path bounds + font metrics
@@ -2892,29 +2895,28 @@
         }
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawPath(const SkPath* path, const SkPaint* paint) {
-    if (currentSnapshot()->isIgnored()) return DrawGlInfo::kStatusDone;
+void OpenGLRenderer::drawPath(const SkPath* path, const SkPaint* paint) {
+    if (currentSnapshot()->isIgnored()) return;
 
     mCaches.activeTexture(0);
 
     const PathTexture* texture = mCaches.pathCache.get(path, paint);
-    if (!texture) return DrawGlInfo::kStatusDone;
+    if (!texture) return;
     const AutoTexture autoCleanup(texture);
 
     const float x = texture->left - texture->offset;
     const float y = texture->top - texture->offset;
 
     drawPathTexture(texture, x, y, paint);
-
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
-status_t OpenGLRenderer::drawLayer(Layer* layer, float x, float y) {
+void OpenGLRenderer::drawLayer(Layer* layer, float x, float y) {
     if (!layer) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     mat4* transform = NULL;
@@ -2934,7 +2936,7 @@
         if (transform && !transform->isIdentity()) {
             restore();
         }
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     EVENT_LOGD("drawLayer," RECT_STRING ", clipRequired %d", x, y,
@@ -3009,7 +3011,7 @@
         restore();
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -3111,12 +3113,12 @@
     }
 }
 
-status_t OpenGLRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
+void OpenGLRenderer::drawRects(const float* rects, int count, const SkPaint* paint) {
     if (currentSnapshot()->isIgnored()) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
-    return drawColorRects(rects, count, paint, false, true, true);
+    drawColorRects(rects, count, paint, false, true, true);
 }
 
 static void mapPointFakeZ(Vector3& point, const mat4& transformXY, const mat4& transformZ) {
@@ -3127,9 +3129,9 @@
     transformXY.mapPoint(point.x, point.y);
 }
 
-status_t OpenGLRenderer::drawShadow(float casterAlpha,
+void OpenGLRenderer::drawShadow(float casterAlpha,
         const VertexBuffer* ambientShadowVertexBuffer, const VertexBuffer* spotShadowVertexBuffer) {
-    if (currentSnapshot()->isIgnored()) return DrawGlInfo::kStatusDone;
+    if (currentSnapshot()->isIgnored()) return;
 
     // TODO: use quickRejectWithScissor. For now, always force enable scissor.
     mCaches.enableScissor();
@@ -3156,13 +3158,13 @@
         drawVertexBuffer(*spotShadowVertexBuffer, &paint, kVertexBuffer_ShadowInterp);
     }
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty=true;
 }
 
-status_t OpenGLRenderer::drawColorRects(const float* rects, int count, const SkPaint* paint,
+void OpenGLRenderer::drawColorRects(const float* rects, int count, const SkPaint* paint,
         bool ignoreTransform, bool dirty, bool clip) {
     if (count == 0) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     int color = paint->getColor();
@@ -3197,7 +3199,7 @@
     }
 
     if (clip && quickRejectSetupScissor(left, top, right, bottom)) {
-        return DrawGlInfo::kStatusDone;
+        return;
     }
 
     setupDraw();
@@ -3220,7 +3222,7 @@
 
     issueIndexedQuadDraw(&mesh[0], count / 4);
 
-    return DrawGlInfo::kStatusDrew;
+    mDirty = true;
 }
 
 void OpenGLRenderer::drawColorRect(float left, float top, float right, float bottom,
diff --git a/libs/hwui/OpenGLRenderer.h b/libs/hwui/OpenGLRenderer.h
index 5e40ec2..65d6deb 100755
--- a/libs/hwui/OpenGLRenderer.h
+++ b/libs/hwui/OpenGLRenderer.h
@@ -126,10 +126,10 @@
             uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha);
 
     virtual void onViewportInitialized();
-    virtual status_t prepareDirty(float left, float top, float right, float bottom, bool opaque);
-    virtual void finish();
+    virtual void prepareDirty(float left, float top, float right, float bottom, bool opaque);
+    virtual bool finish();
 
-    virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty);
+    virtual void callDrawGLFunction(Functor* functor, Rect& dirty);
 
     void pushLayerUpdate(Layer* layer);
     void cancelLayerUpdate(Layer* layer);
@@ -149,46 +149,46 @@
     int saveLayerDeferred(float left, float top, float right, float bottom,
             const SkPaint* paint, int flags);
 
-    virtual status_t drawRenderNode(RenderNode* displayList, Rect& dirty, int32_t replayFlags = 1);
-    virtual status_t drawLayer(Layer* layer, float x, float y);
-    virtual status_t drawBitmap(const SkBitmap* bitmap, const SkPaint* paint);
-    status_t drawBitmaps(const SkBitmap* bitmap, AssetAtlas::Entry* entry, int bitmapCount,
+    virtual void drawRenderNode(RenderNode* displayList, Rect& dirty, int32_t replayFlags = 1);
+    virtual void drawLayer(Layer* layer, float x, float y);
+    virtual void drawBitmap(const SkBitmap* bitmap, const SkPaint* paint);
+    void drawBitmaps(const SkBitmap* bitmap, AssetAtlas::Entry* entry, int bitmapCount,
             TextureVertex* vertices, bool pureTranslate, const Rect& bounds, const SkPaint* paint);
-    virtual status_t drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
+    virtual void drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
             float srcRight, float srcBottom, float dstLeft, float dstTop,
             float dstRight, float dstBottom, const SkPaint* paint);
-    virtual status_t drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint);
-    virtual status_t drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
+    virtual void drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint);
+    virtual void drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
             const float* vertices, const int* colors, const SkPaint* paint);
-    status_t drawPatches(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
+    void drawPatches(const SkBitmap* bitmap, AssetAtlas::Entry* entry,
             TextureVertex* vertices, uint32_t indexCount, const SkPaint* paint);
-    virtual status_t drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
+    virtual void drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
             float left, float top, float right, float bottom, const SkPaint* paint);
-    status_t drawPatch(const SkBitmap* bitmap, const Patch* mesh, AssetAtlas::Entry* entry,
+    void drawPatch(const SkBitmap* bitmap, const Patch* mesh, AssetAtlas::Entry* entry,
             float left, float top, float right, float bottom, const SkPaint* paint);
-    virtual status_t drawColor(int color, SkXfermode::Mode mode);
-    virtual status_t drawRect(float left, float top, float right, float bottom,
+    virtual void drawColor(int color, SkXfermode::Mode mode);
+    virtual void drawRect(float left, float top, float right, float bottom,
             const SkPaint* paint);
-    virtual status_t drawRoundRect(float left, float top, float right, float bottom,
+    virtual void drawRoundRect(float left, float top, float right, float bottom,
             float rx, float ry, const SkPaint* paint);
-    virtual status_t drawCircle(float x, float y, float radius, const SkPaint* paint);
-    virtual status_t drawOval(float left, float top, float right, float bottom,
+    virtual void drawCircle(float x, float y, float radius, const SkPaint* paint);
+    virtual void drawOval(float left, float top, float right, float bottom,
             const SkPaint* paint);
-    virtual status_t drawArc(float left, float top, float right, float bottom,
+    virtual void drawArc(float left, float top, float right, float bottom,
             float startAngle, float sweepAngle, bool useCenter, const SkPaint* paint);
-    virtual status_t drawPath(const SkPath* path, const SkPaint* paint);
-    virtual status_t drawLines(const float* points, int count, const SkPaint* paint);
-    virtual status_t drawPoints(const float* points, int count, const SkPaint* paint);
-    virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path,
+    virtual void drawPath(const SkPath* path, const SkPaint* paint);
+    virtual void drawLines(const float* points, int count, const SkPaint* paint);
+    virtual void drawPoints(const float* points, int count, const SkPaint* paint);
+    virtual void drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path,
             float hOffset, float vOffset, const SkPaint* paint);
-    virtual status_t drawPosText(const char* text, int bytesCount, int count,
+    virtual void drawPosText(const char* text, int bytesCount, int count,
             const float* positions, const SkPaint* paint);
-    virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y,
+    virtual void drawText(const char* text, int bytesCount, int count, float x, float y,
             const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds,
             DrawOpMode drawOpMode = kDrawOpMode_Immediate);
-    virtual status_t drawRects(const float* rects, int count, const SkPaint* paint);
+    virtual void drawRects(const float* rects, int count, const SkPaint* paint);
 
-    status_t drawShadow(float casterAlpha,
+    void drawShadow(float casterAlpha,
             const VertexBuffer* ambientShadowVertexBuffer, const VertexBuffer* spotShadowVertexBuffer);
 
     virtual void setDrawFilter(SkDrawFilter* filter);
@@ -324,6 +324,7 @@
         drawColorRect(left, top, right, bottom, color, SkXfermode::kSrcOver_Mode, true);
 
         if (stencilWasEnabled) mCaches.stencil.enableTest();
+        mDirty = true;
     }
 #endif
 
@@ -343,12 +344,12 @@
      * Indicates the start of rendering. This method will setup the
      * initial OpenGL state (viewport, clearing the buffer, etc.)
      */
-    status_t startFrame();
+    void startFrame();
 
     /**
      * Clears the underlying surface if needed.
      */
-    virtual status_t clear(float left, float top, float right, float bottom, bool opaque);
+    virtual void clear(float left, float top, float right, float bottom, bool opaque);
 
     /**
      * Call this method after updating a layer during a drawing pass.
@@ -613,7 +614,7 @@
      * @param dirty True if calling this method should dirty the current layer
      * @param clip True if the rects should be clipped, false otherwise
      */
-    status_t drawColorRects(const float* rects, int count, const SkPaint* paint,
+    void drawColorRects(const float* rects, int count, const SkPaint* paint,
             bool ignoreTransform = false, bool dirty = true, bool clip = true);
 
     /**
@@ -627,7 +628,7 @@
      * @param texture The texture reprsenting the shape
      * @param paint The paint to draw the shape with
      */
-    status_t drawShape(float left, float top, const PathTexture* texture, const SkPaint* paint);
+    void drawShape(float left, float top, const PathTexture* texture, const SkPaint* paint);
 
     /**
      * Draws the specified texture as an alpha bitmap. Alpha bitmaps obey
@@ -647,15 +648,15 @@
      * @param paint The paint to render with
      * @param flags flags with which to draw
      */
-    status_t drawVertexBuffer(float translateX, float translateY, const VertexBuffer& vertexBuffer,
+    void drawVertexBuffer(float translateX, float translateY, const VertexBuffer& vertexBuffer,
             const SkPaint* paint, int flags = 0);
 
     /**
      * Convenience for translating method
      */
-    status_t drawVertexBuffer(const VertexBuffer& vertexBuffer,
+    void drawVertexBuffer(const VertexBuffer& vertexBuffer,
             const SkPaint* paint, int flags = 0) {
-        return drawVertexBuffer(0.0f, 0.0f, vertexBuffer, paint, flags);
+        drawVertexBuffer(0.0f, 0.0f, vertexBuffer, paint, flags);
     }
 
     /**
@@ -664,7 +665,7 @@
      * @param path The hull of the path to draw
      * @param paint The paint to render with
      */
-    status_t drawConvexPath(const SkPath& path, const SkPaint* paint);
+    void drawConvexPath(const SkPath& path, const SkPaint* paint);
 
     /**
      * Draws a textured rectangle with the specified texture. The specified coordinates
@@ -930,6 +931,8 @@
      */
     Texture* getTexture(const SkBitmap* bitmap);
 
+    bool reportAndClearDirty() { bool ret = mDirty; mDirty = false; return ret; }
+
     /**
      * Model-view matrix used to position/size objects
      *
@@ -998,6 +1001,10 @@
 
     bool mSkipOutlineClip;
 
+    // True if anything has been drawn since the last call to
+    // reportAndClearDirty()
+    bool mDirty;
+
     // Lighting + shadows
     Vector3 mLightCenter;
     float mLightRadius;
diff --git a/libs/hwui/Renderer.h b/libs/hwui/Renderer.h
index 4a36f31..1f10b02 100644
--- a/libs/hwui/Renderer.h
+++ b/libs/hwui/Renderer.h
@@ -112,7 +112,7 @@
      *               and will not be cleared. If false, the target surface
      *               will be cleared
      */
-    virtual status_t prepare(bool opaque) = 0;
+    virtual void prepare(bool opaque) = 0;
 
     /**
      * Prepares the renderer to draw a frame. This method must be invoked
@@ -128,14 +128,16 @@
      *               and will not be cleared. If false, the target surface
      *               will be cleared in the specified dirty rectangle
      */
-    virtual status_t prepareDirty(float left, float top, float right, float bottom,
+    virtual void prepareDirty(float left, float top, float right, float bottom,
             bool opaque) = 0;
 
     /**
      * Indicates the end of a frame. This method must be invoked whenever
      * the caller is done rendering a frame.
+     * Returns true if any drawing was done during the frame (the output
+     * has changed / is "dirty" and should be displayed to the user).
      */
-    virtual void finish() = 0;
+    virtual bool finish() = 0;
 
 // ----------------------------------------------------------------------------
 // Canvas state operations
@@ -180,52 +182,52 @@
 // ----------------------------------------------------------------------------
 // Canvas draw operations
 // ----------------------------------------------------------------------------
-    virtual status_t drawColor(int color, SkXfermode::Mode mode) = 0;
+    virtual void drawColor(int color, SkXfermode::Mode mode) = 0;
 
     // Bitmap-based
-    virtual status_t drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) = 0;
-    virtual status_t drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
+    virtual void drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) = 0;
+    virtual void drawBitmap(const SkBitmap* bitmap, float srcLeft, float srcTop,
             float srcRight, float srcBottom, float dstLeft, float dstTop,
             float dstRight, float dstBottom, const SkPaint* paint) = 0;
-    virtual status_t drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint) = 0;
-    virtual status_t drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
+    virtual void drawBitmapData(const SkBitmap* bitmap, const SkPaint* paint) = 0;
+    virtual void drawBitmapMesh(const SkBitmap* bitmap, int meshWidth, int meshHeight,
             const float* vertices, const int* colors, const SkPaint* paint) = 0;
-    virtual status_t drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
+    virtual void drawPatch(const SkBitmap* bitmap, const Res_png_9patch* patch,
             float left, float top, float right, float bottom, const SkPaint* paint) = 0;
 
     // Shapes
-    virtual status_t drawRect(float left, float top, float right, float bottom,
+    virtual void drawRect(float left, float top, float right, float bottom,
             const SkPaint* paint) = 0;
-    virtual status_t drawRects(const float* rects, int count, const SkPaint* paint) = 0;
-    virtual status_t drawRoundRect(float left, float top, float right, float bottom,
+    virtual void drawRects(const float* rects, int count, const SkPaint* paint) = 0;
+    virtual void drawRoundRect(float left, float top, float right, float bottom,
             float rx, float ry, const SkPaint* paint) = 0;
-    virtual status_t drawCircle(float x, float y, float radius, const SkPaint* paint) = 0;
-    virtual status_t drawOval(float left, float top, float right, float bottom,
+    virtual void drawCircle(float x, float y, float radius, const SkPaint* paint) = 0;
+    virtual void drawOval(float left, float top, float right, float bottom,
             const SkPaint* paint) = 0;
-    virtual status_t drawArc(float left, float top, float right, float bottom,
+    virtual void drawArc(float left, float top, float right, float bottom,
             float startAngle, float sweepAngle, bool useCenter, const SkPaint* paint) = 0;
-    virtual status_t drawPath(const SkPath* path, const SkPaint* paint) = 0;
-    virtual status_t drawLines(const float* points, int count, const SkPaint* paint) = 0;
-    virtual status_t drawPoints(const float* points, int count, const SkPaint* paint) = 0;
+    virtual void drawPath(const SkPath* path, const SkPaint* paint) = 0;
+    virtual void drawLines(const float* points, int count, const SkPaint* paint) = 0;
+    virtual void drawPoints(const float* points, int count, const SkPaint* paint) = 0;
 
     // Text
-    virtual status_t drawText(const char* text, int bytesCount, int count, float x, float y,
+    virtual void drawText(const char* text, int bytesCount, int count, float x, float y,
             const float* positions, const SkPaint* paint, float totalAdvance, const Rect& bounds,
             DrawOpMode drawOpMode = kDrawOpMode_Immediate) = 0;
-    virtual status_t drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path,
+    virtual void drawTextOnPath(const char* text, int bytesCount, int count, const SkPath* path,
             float hOffset, float vOffset, const SkPaint* paint) = 0;
-    virtual status_t drawPosText(const char* text, int bytesCount, int count,
+    virtual void drawPosText(const char* text, int bytesCount, int count,
             const float* positions, const SkPaint* paint) = 0;
 
 // ----------------------------------------------------------------------------
 // Canvas draw operations - special
 // ----------------------------------------------------------------------------
-    virtual status_t drawLayer(Layer* layer, float x, float y) = 0;
-    virtual status_t drawRenderNode(RenderNode* renderNode, Rect& dirty,
+    virtual void drawLayer(Layer* layer, float x, float y) = 0;
+    virtual void drawRenderNode(RenderNode* renderNode, Rect& dirty,
             int32_t replayFlags) = 0;
 
     // TODO: rename for consistency
-    virtual status_t callDrawGLFunction(Functor* functor, Rect& dirty) = 0;
+    virtual void callDrawGLFunction(Functor* functor, Rect& dirty) = 0;
 }; // class Renderer
 
 }; // namespace uirenderer
diff --git a/libs/hwui/StatefulBaseRenderer.h b/libs/hwui/StatefulBaseRenderer.h
index 745e48a..612992f 100644
--- a/libs/hwui/StatefulBaseRenderer.h
+++ b/libs/hwui/StatefulBaseRenderer.h
@@ -43,8 +43,8 @@
 public:
     StatefulBaseRenderer();
 
-    virtual status_t prepare(bool opaque) {
-        return prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);
+    virtual void prepare(bool opaque) {
+        prepareDirty(0.0f, 0.0f, mWidth, mHeight, opaque);
     }
 
     /**
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index b499dd0..958202c 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -217,24 +217,23 @@
         profiler().unionDirty(&dirty);
     }
 
-    status_t status;
     if (!dirty.isEmpty()) {
-        status = mCanvas->prepareDirty(dirty.fLeft, dirty.fTop,
+        mCanvas->prepareDirty(dirty.fLeft, dirty.fTop,
                 dirty.fRight, dirty.fBottom, mOpaque);
     } else {
-        status = mCanvas->prepare(mOpaque);
+        mCanvas->prepare(mOpaque);
     }
 
     Rect outBounds;
-    status |= mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds);
+    mCanvas->drawRenderNode(mRootRenderNode.get(), outBounds);
 
     profiler().draw(mCanvas);
 
-    mCanvas->finish();
+    bool drew = mCanvas->finish();
 
     profiler().markPlaybackEnd();
 
-    if (status & DrawGlInfo::kStatusDrew) {
+    if (drew) {
         swapBuffers();
     } else {
         mEglManager.cancelFrame();