Remove gainFocus() and setMatrixClip() virtuals from SkDevice.

R=reed@google.com,robertphillips@google.com
Review URL: https://codereview.appspot.com/6636050

git-svn-id: http://skia.googlecode.com/svn/trunk@5861 2bbb7eff-a529-9590-31e7-b0007b416f81

4 files changed, 23 insertions, 89 deletions

diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
index 5e476c6c9e..b6d8c293cf 100644
--- a/src/core/SkCanvas.cpp
+++ b/src/core/SkCanvas.cpp
@@ -124,8 +124,6 @@ struct DeviceCM {
                            SkRegion::kDifference_Op);
         }
 
-        fDevice->setMatrixClip(*fMatrix, fClip.forceGetBW(), clipStack);
-
 #ifdef SK_DEBUG
         if (!fClip.isEmpty()) {
             SkIRect deviceR;
@@ -244,7 +242,6 @@ public:
             }
             // fCurrLayer may be NULL now
 
-            fCanvas->prepareForDeviceDraw(fDevice, *fMatrix, *fClip);
             return true;
         }
         return false;
@@ -441,7 +438,6 @@ SkDevice* SkCanvas::init(SkDevice* device) {
     fBounder = NULL;
     fLocalBoundsCompareType.setEmpty();
     fLocalBoundsCompareTypeDirty = true;
-    fLastDeviceToGainFocus = NULL;
     fDeviceCMDirty = false;
     fSaveLayerCount = 0;
     fMetaData = NULL;
@@ -664,15 +660,6 @@ void SkCanvas::updateDeviceCMCache() {
     }
 }
 
-void SkCanvas::prepareForDeviceDraw(SkDevice* device, const SkMatrix& matrix,
-                                    const SkRegion& clip) {
-    SkASSERT(device);
-    if (fLastDeviceToGainFocus != device) {
-        device->gainFocus(matrix, clip);
-        fLastDeviceToGainFocus = device;
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////////
 
 int SkCanvas::internalSave(SaveFlags flags) {
@@ -859,13 +846,6 @@ void SkCanvas::internalRestore() {
 
     fDeviceCMDirty = true;
     fLocalBoundsCompareTypeDirty = true;
-    // Dirty this pointer to handle the case of a new device created at the same address as the
-    // device we are restoring from. E.g.:
-    // saveLayer (creates a device)
-    // drawSomething
-    // restore (deletes the device)
-    // saveLayer (oops new device at the same address)
-    fLastDeviceToGainFocus = NULL;
 
     fClipStack.restore();
     // reserve our layer (if any)
diff --git a/src/core/SkDevice.cpp b/src/core/SkDevice.cpp
index 7da9a6b442..6d8958d804 100644
--- a/src/core/SkDevice.cpp
+++ b/src/core/SkDevice.cpp
@@ -122,10 +122,6 @@ void SkDevice::clear(SkColor color) {
 
 const SkBitmap& SkDevice::onAccessBitmap(SkBitmap* bitmap) {return *bitmap;}
 
-void SkDevice::setMatrixClip(const SkMatrix& matrix, const SkRegion& region,
-                             const SkClipStack& clipStack) {
-}
-
 bool SkDevice::canHandleImageFilter(SkImageFilter*) {
     return false;
 }
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index 9a495c9703..b168e57e63 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 @@ enum {
     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 @@ enum {
 // 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 @@ SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget)
 void SkGpuDevice::initFromRenderTarget(GrContext* context,
                                        GrRenderTarget* renderTarget,
                                        bool cached) {
-    fNeedPrepareRenderTarget = false;
     fDrawProcs = NULL;
 
     fContext = context;
@@ -214,7 +209,6 @@ SkGpuDevice::SkGpuDevice(GrContext* context,
                          int height)
     : SkDevice(config, width, height, false /*isOpaque*/) {
 
-    fNeedPrepareRenderTarget = false;
     fDrawProcs = NULL;
 
     fContext = context;
@@ -258,9 +252,11 @@ SkGpuDevice::~SkGpuDevice() {
         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 @@ SkGpuDevice::~SkGpuDevice() {
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::makeRenderTargetCurrent() {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     fContext->setRenderTarget(fRenderTarget);
-    fNeedPrepareRenderTarget = true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -308,7 +303,7 @@ GrPixelConfig config8888_to_grconfig_and_flags(SkCanvas::Config8888 config8888,
 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 check_bounds(const GrClipData& clipData,
 
 ///////////////////////////////////////////////////////////////////////////////
 
-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) {
+void SkGpuDevice::prepareDraw(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;
-}
+    fContext->setRenderTarget(fRenderTarget);
 
-void SkGpuDevice::gainFocus(const SkMatrix& matrix, const SkRegion& clip) {
+    SkASSERT(draw.fClipStack && draw.fClipStack == fClipData.fClipStack);
 
-    GrAssert(NULL != fClipData.fClipStack);
+    fContext->setMatrix(*draw.fMatrix);
+    fClipData.fOrigin = this->getOrigin();
 
-    fContext->setRenderTarget(fRenderTarget);
-
-    this->INHERITED::gainFocus(matrix, clip);
+#ifdef SK_DEBUG
+    check_bounds(fClipData, *draw.fClip, fRenderTarget->width(), fRenderTarget->height());
+#endif
 
-    set_matrix_and_clip(fContext, matrix, fClipData, clip, this->getOrigin(),
-                        fRenderTarget->width(), fRenderTarget->height());
+    fContext->setClip(&fClipData);
 
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
 }
 
 SkGpuRenderTarget* SkGpuDevice::accessRenderTarget() {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     return (SkGpuRenderTarget*)fRenderTarget;
 }
 
@@ -662,6 +622,7 @@ inline bool skPaint2GrPaintShader(SkGpuDevice* dev,
 ///////////////////////////////////////////////////////////////////////////////
 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 @@ bool SkGpuDevice::filterTextFlags(const SkPaint& paint, TextFlags* flags) {
 }
 
 void SkGpuDevice::flush() {
-    DO_DEFERRED_CLEAR;
+    DO_DEFERRED_CLEAR();
     fContext->resolveRenderTarget(fRenderTarget);
 }
 
diff --git a/src/utils/SkDeferredCanvas.cpp b/src/utils/SkDeferredCanvas.cpp
index eaba50342e..c3de393290 100644
--- a/src/utils/SkDeferredCanvas.cpp
+++ b/src/utils/SkDeferredCanvas.cpp
@@ -268,9 +268,6 @@ protected:
     virtual bool filterTextFlags(const SkPaint& paint, TextFlags*)
         SK_OVERRIDE
         {return false;}
-    virtual void setMatrixClip(const SkMatrix&, const SkRegion&,
-                                const SkClipStack&) SK_OVERRIDE
-        {}
 
     // None of the following drawing methods should ever get called on the
     // deferred device