Remove AutoScratchTexture

src/gpu/GrClipMaskManager.cpp

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipMaskManager.h"
 #include "GrAAConvexPathRenderer.h"
@@ skipping 467 matching lines @@
 
     drawState->addColorProcessor(
         GrTextureDomainEffect::Create(srcMask,
                                       sampleM,
                                       GrTextureDomain::MakeTexelDomain(srcMask, srcBound),
                                       GrTextureDomain::kDecal_Mode,
                                       GrTextureParams::kNone_FilterMode))->unref();
     fGpu->drawSimpleRect(SkRect::Make(dstBound));
 }
 
-// get a texture to act as a temporary buffer for AA clip boolean operations
-// TODO: given the expense of createTexture we may want to just cache this too
-void GrClipMaskManager::getTemp(int width, int height, GrAutoScratchTexture* temp) {
-    if (temp->texture()) {
-        // we've already allocated the temp texture
-        return;
-    }
-
+GrTexture* GrClipMaskManager::createTempMask(int width, int height) {
     GrTextureDesc desc;
     desc.fFlags = kRenderTarget_GrTextureFlagBit|kNoStencil_GrTextureFlagBit;
     desc.fWidth = width;
     desc.fHeight = height;
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
-    temp->set(this->getContext(), desc);
+    return fGpu->getContext()->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Return the texture currently in the cache if it exists. Otherwise, return NULL
 GrTexture* GrClipMaskManager::getCachedMaskTexture(int32_t elementsGenID,
                                                    const SkIRect& clipSpaceIBounds) {
     bool cached = fAACache.canReuse(elementsGenID, clipSpaceIBounds);
     if (!cached) {
         return NULL;
     }
@@ skipping 73 matching lines @@
                 true,
                 result->asRenderTarget());
 
     // When we use the stencil in the below loop it is important to have this clip installed.
     // The second pass that zeros the stencil buffer renders the rect maskSpaceIBounds so the first
     // pass must not set values outside of this bounds or stencil values outside the rect won't be
     // cleared.
     GrDrawTarget::AutoClipRestore acr(fGpu, maskSpaceIBounds);
     drawState->enableState(GrDrawState::kClip_StateBit);
 
-    GrAutoScratchTexture temp;
+    SkAutoTUnref<GrTexture> temp;
     // walk through each clip element and perform its set op
     for (ElementList::Iter iter = elements.headIter(); iter.get(); iter.next()) {
         const Element* element = iter.get();
         SkRegion::Op op = element->getOp();
         bool invert = element->isInverseFilled();
 
         if (invert || SkRegion::kIntersect_Op == op || SkRegion::kReverseDifference_Op == op) {
             GrPathRenderer* pr = NULL;
             bool useTemp = !this->canStencilAndDrawElement(result, element, &pr);
             GrTexture* dst;
             // This is the bounds of the clip element in the space of the alpha-mask. The temporary
             // mask buffer can be substantially larger than the actually clip stack element. We
             // touch the minimum number of pixels necessary and use decal mode to combine it with
             // the accumulator.
             SkIRect maskSpaceElementIBounds;
 
             if (useTemp) {
                 if (invert) {
                     maskSpaceElementIBounds = maskSpaceIBounds;
                 } else {
                     SkRect elementBounds = element->getBounds();
                     elementBounds.offset(clipToMaskOffset);
                     elementBounds.roundOut(&maskSpaceElementIBounds);
                 }
 
-                this->getTemp(maskSpaceIBounds.fRight, maskSpaceIBounds.fBottom, &temp);
-                if (NULL == temp.texture()) {
-                    fAACache.reset();
-                    return NULL;
+                if (!temp) {
+                    temp.reset(this->createTempMask(maskSpaceIBounds.fRight,
+                                                    maskSpaceIBounds.fBottom));
+                    if (!temp) {
+                        fAACache.reset();
+                        return NULL;
+                    }
                 }
-                dst = temp.texture();
+                dst = temp;
                 // clear the temp target and set blend to replace
                 fGpu->clear(&maskSpaceElementIBounds,
                             invert ? 0xffffffff : 0x00000000,
                             true,
                             dst->asRenderTarget());
                 setup_boolean_blendcoeffs(drawState, SkRegion::kReplace_Op);
 
             } else {
                 // draw directly into the result with the stencil set to make the pixels affected
                 // by the clip shape be non-zero.
@@ skipping 13 matching lines @@
 
             if (!this->drawElement(dst, element, pr)) {
                 fAACache.reset();
                 return NULL;
             }
 
             if (useTemp) {
                 // Now draw into the accumulator using the real operation and the temp buffer as a
                 // texture
                 this->mergeMask(result,
-                                temp.texture(),
+                                temp,
                                 op,
                                 maskSpaceIBounds,
                                 maskSpaceElementIBounds);
             } else {
                 // Draw to the exterior pixels (those with a zero stencil value).
                 drawState->setAlpha(invert ? 0xff : 0x00);
                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
                                              kZero_StencilOp,
                                              kZero_StencilOp,
                                              kEqual_StencilFunc,
@@ skipping 468 matching lines @@
 
     // TODO: dynamically attach a stencil buffer
     int stencilBits = 0;
     GrStencilBuffer* stencilBuffer =
         drawState.getRenderTarget()->getStencilBuffer();
     if (stencilBuffer) {
         stencilBits = stencilBuffer->bits();
         this->adjustStencilParams(settings, clipMode, stencilBits);
     }
 }