Reland r5861 but leave setMatrixClip virtual on SkDevice (IOW this is a partial revert of r5871 which reverted r5861).

Unreviewed
Review URL: https://codereview.appspot.com/6631062

git-svn-id: http://skia.googlecode.com/svn/trunk@5881 2bbb7eff-a529-9590-31e7-b0007b416f81
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 9a495c9..b168e57 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -30,12 +30,10 @@
     #define CHECK_SHOULD_DRAW(draw)                             \
         do {                                                    \
             if (gShouldDrawProc && !gShouldDrawProc()) return;  \
-            this->prepareRenderTarget(draw);                    \
-            GrAssert(!fNeedClear)                               \
+            this->prepareDraw(draw);                            \
         } while (0)
 #else
-    #define CHECK_SHOULD_DRAW(draw) this->prepareRenderTarget(draw); \
-                                    GrAssert(!fNeedClear)
+    #define CHECK_SHOULD_DRAW(draw) this->prepareDraw(draw)
 #endif
 
 // we use the same texture slot on GrPaint for bitmaps and shaders
@@ -46,7 +44,6 @@
     kColorFilterTextureIdx = 1
 };
 
-
 #define MAX_BLUR_SIGMA 4.0f
 // FIXME:  This value comes from from SkBlurMaskFilter.cpp.
 // Should probably be put in a common header someplace.
@@ -64,11 +61,10 @@
 // a sub region of a larger source image.
 #define COLOR_BLEED_TOLERANCE SkFloatToScalar(0.001f)
 
-#define DO_DEFERRED_CLEAR       \
+#define DO_DEFERRED_CLEAR()     \
     do {                        \
         if (fNeedClear) {       \
             this->clear(0x0);   \
-            fNeedClear = false; \
         }                       \
     } while (false)             \
 
@@ -182,7 +178,6 @@
 void SkGpuDevice::initFromRenderTarget(GrContext* context,
                                        GrRenderTarget* renderTarget,
                                        bool cached) {
-    fNeedPrepareRenderTarget = false;
     fDrawProcs = NULL;
 
     fContext = context;
@@ -214,7 +209,6 @@
                          int height)
     : SkDevice(config, width, height, false /*isOpaque*/) {
 
-    fNeedPrepareRenderTarget = false;
     fDrawProcs = NULL;
 
     fContext = context;
@@ -258,9 +252,11 @@
         delete fDrawProcs;
     }
 
-    // The SkGpuDevice gives the context the render target (e.g., in gainFocus)
-    // This call gives the context a chance to relinquish it
-    fContext->setRenderTarget(NULL);
+    // The GrContext takes a ref on the target. We don't want to cause the render
+    // target to be unnecessarily kept alive.
+    if (fContext->getRenderTarget() == fRenderTarget) {
+        fContext->setRenderTarget(NULL);
+    }
 
     SkSafeUnref(fRenderTarget);
     fContext->unref();
@@ -269,9 +265,8 @@
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::makeRenderTargetCurrent() {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     fContext->setRenderTarget(fRenderTarget);
-    fNeedPrepareRenderTarget = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -308,7 +303,7 @@
 bool SkGpuDevice::onReadPixels(const SkBitmap& bitmap,
                                int x, int y,
                                SkCanvas::Config8888 config8888) {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     SkASSERT(SkBitmap::kARGB_8888_Config == bitmap.config());
     SkASSERT(!bitmap.isNull());
     SkASSERT(SkIRect::MakeWH(this->width(), this->height()).contains(SkIRect::MakeXYWH(x, y, bitmap.width(), bitmap.height())));
@@ -411,64 +406,29 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-static void set_matrix_and_clip(GrContext* context, const SkMatrix& matrix,
-                                GrClipData& clipData,
-                                const SkRegion& clipRegion,
-                                const SkIPoint& origin,
-                                int renderTargetWidth, int renderTargetHeight) {
-    context->setMatrix(matrix);
-
-    clipData.fOrigin = origin;
-
-#ifdef SK_DEBUG
-    check_bounds(clipData, clipRegion,
-                 renderTargetWidth, renderTargetHeight);
-#endif
-
-    context->setClip(&clipData);
-}
-
 // call this every draw call, to ensure that the context reflects our state,
 // and not the state from some other canvas/device
-void SkGpuDevice::prepareRenderTarget(const SkDraw& draw) {
-    GrAssert(NULL != fClipData.fClipStack);
-
-    if (fNeedPrepareRenderTarget ||
-        fContext->getRenderTarget() != fRenderTarget) {
-
-        fContext->setRenderTarget(fRenderTarget);
-        SkASSERT(draw.fClipStack && draw.fClipStack == fClipData.fClipStack);
-
-        set_matrix_and_clip(fContext, *draw.fMatrix,
-                            fClipData, *draw.fClip, this->getOrigin(),
-                            fRenderTarget->width(), fRenderTarget->height());
-        fNeedPrepareRenderTarget = false;
-    }
-}
-
-void SkGpuDevice::setMatrixClip(const SkMatrix& matrix, const SkRegion& clip,
-                                const SkClipStack& clipStack) {
-    this->INHERITED::setMatrixClip(matrix, clip, clipStack);
-    // We don't need to set them now because the context may not reflect this device.
-    fNeedPrepareRenderTarget = true;
-}
-
-void SkGpuDevice::gainFocus(const SkMatrix& matrix, const SkRegion& clip) {
-
+void SkGpuDevice::prepareDraw(const SkDraw& draw) {
     GrAssert(NULL != fClipData.fClipStack);
 
     fContext->setRenderTarget(fRenderTarget);
 
-    this->INHERITED::gainFocus(matrix, clip);
+    SkASSERT(draw.fClipStack && draw.fClipStack == fClipData.fClipStack);
 
-    set_matrix_and_clip(fContext, matrix, fClipData, clip, this->getOrigin(),
-                        fRenderTarget->width(), fRenderTarget->height());
+    fContext->setMatrix(*draw.fMatrix);
+    fClipData.fOrigin = this->getOrigin();
 
-    DO_DEFERRED_CLEAR;
+#ifdef SK_DEBUG
+    check_bounds(fClipData, *draw.fClip, fRenderTarget->width(), fRenderTarget->height());
+#endif
+
+    fContext->setClip(&fClipData);
+
+    DO_DEFERRED_CLEAR();
 }
 
 SkGpuRenderTarget* SkGpuDevice::accessRenderTarget() {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     return (SkGpuRenderTarget*)fRenderTarget;
 }
 
@@ -662,6 +622,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 void SkGpuDevice::clear(SkColor color) {
     fContext->clear(NULL, color, fRenderTarget);
+    fNeedClear = false;
 }
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
@@ -1927,7 +1888,7 @@
 }
 
 void SkGpuDevice::flush() {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     fContext->resolveRenderTarget(fRenderTarget);
 }