Remove separate cache for clip mask textures

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 "GrCaps.h"
 #include "GrDrawContext.h"
 #include "GrDrawTarget.h"
+#include "GrGpuResourcePriv.h"
 #include "GrPaint.h"
 #include "GrPathRenderer.h"
 #include "GrRenderTarget.h"
 #include "GrRenderTargetPriv.h"
+#include "GrResourceProvider.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
 #include "SkRasterClip.h"
 #include "SkTLazy.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef SkClipStack::Element Element;
@@ skipping 45 matching lines @@
                                          GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
 
     return nullptr == context->getPathRenderer(gpu, &pipelineBuilder, viewMatrix, *path, stroke,
                                             false, type);
 }
 }
 
 GrClipMaskManager::GrClipMaskManager(GrDrawTarget* drawTarget)
     : fCurrClipMaskType(kNone_ClipMaskType)
-    , fAACache(drawTarget->cmmAccess().resourceProvider())
     , fDrawTarget(drawTarget)
     , fClipMode(kIgnoreClip_StencilClipMode) {
 }
 
 GrContext* GrClipMaskManager::getContext() { return fDrawTarget->cmmAccess().context(); }
 
 /*
  * This method traverses the clip stack to see if the GrSoftwarePathRenderer
  * will be used on any element. If so, it returns true to indicate that the
  * entire clip should be rendered in SW and then uploaded en masse to the gpu.
@@ skipping 245 matching lines @@
             // clipSpace bounds. We determine the mask's position WRT to the render target here.
             SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
             rtSpaceMaskBounds.offset(-clip.origin());
             setup_drawstate_aaclip(pipelineBuilder, result, arfps, rtSpaceMaskBounds);
             this->setPipelineBuilderStencil(pipelineBuilder, ars);
             return true;
         }
         // if alpha clip mask creation fails fall through to the non-AA code paths
     }
 
-    // Either a hard (stencil buffer) clip was explicitly requested or an anti-aliased clip couldn't
-    // be created. In either case, free up the texture in the anti-aliased mask cache.
-    // TODO: this may require more investigation. Ganesh performs a lot of utility draws (e.g.,
-    // clears, GrBufferedDrawTarget playbacks) that hit the stencil buffer path. These may be
-    // "incorrectly" clearing the AA cache.
-    fAACache.reset();
-
     // use the stencil clip if we can't represent the clip as a rectangle.
     SkIPoint clipSpaceToStencilSpaceOffset = -clip.origin();
     this->createStencilClipMask(rt,
                                 genID,
                                 initialState,
                                 elements,
                                 clipSpaceIBounds,
                                 clipSpaceToStencilSpaceOffset);
 
     // This must occur after createStencilClipMask. That function may change the scissor. Also, it
@@ skipping 145 matching lines @@
     if (this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
         desc.fConfig = kAlpha_8_GrPixelConfig;
     } else {
         desc.fConfig = kRGBA_8888_GrPixelConfig;
     }
 
     return this->getContext()->textureProvider()->createApproxTexture(desc);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// Return the texture currently in the cache if it exists. Otherwise, return nullptr
-GrTexture* GrClipMaskManager::getCachedMaskTexture(int32_t elementsGenID,
-                                                   const SkIRect& clipSpaceIBounds) {
-    bool cached = fAACache.canReuse(elementsGenID, clipSpaceIBounds);
-    if (!cached) {
-        return nullptr;
-    }
-
-    return fAACache.getLastMask();
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Allocate a texture in the texture cache. This function returns the texture
-// allocated (or nullptr on error).
-GrTexture* GrClipMaskManager::allocMaskTexture(int32_t elementsGenID,
-                                               const SkIRect& clipSpaceIBounds,
-                                               bool willUpload) {
-    // Since we are setting up the cache we should free up the
-    // currently cached mask so it can be reused.
-    fAACache.reset();
-
-    GrSurfaceDesc desc;
-    desc.fFlags = willUpload ? kNone_GrSurfaceFlags : kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = clipSpaceIBounds.width();
-    desc.fHeight = clipSpaceIBounds.height();
-    desc.fConfig = kRGBA_8888_GrPixelConfig;
-    if (willUpload ||
-        this->getContext()->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
-        // We would always like A8 but it isn't supported on all platforms
-        desc.fConfig = kAlpha_8_GrPixelConfig;
-    }
-
-    fAACache.acquireMask(elementsGenID, desc, clipSpaceIBounds);
-    return fAACache.getLastMask();
-}
-
-////////////////////////////////////////////////////////////////////////////////
 // Create a 8-bit clip mask in alpha
+
+static void GetClipMaskKey(int32_t clipGenID, const SkIRect& bounds, GrUniqueKey* key) {
+    static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
+    GrUniqueKey::Builder builder(key, kDomain, 3);
+    builder[0] = clipGenID;
+    builder[1] = SkToU16(bounds.fLeft) | (SkToU16(bounds.fRight) << 16);
+    builder[2] = SkToU16(bounds.fTop) | (SkToU16(bounds.fBottom) << 16);
+}
+
+GrTexture* GrClipMaskManager::createCachedMask(int width, int height, const GrUniqueKey& key,
+                                               bool renderTarget) {
+    GrSurfaceDesc desc;
+    desc.fConfig = kAlpha_8_GrPixelConfig;
+    desc.fWidth = width;
+    desc.fHeight = height;
+    desc.fFlags = renderTarget ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;

[robertphillips, 2015/09/30 12:33:05]

Since we set fConfig to A8 by default, reverse the sense of this test, set
fConfig to 8888 and eliminate the else ?

[bsalomon, 2015/09/30 19:59:39]

Removed the default setting (meant to do that the first time).

+    if (!renderTarget || fDrawTarget->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
+        desc.fConfig = kAlpha_8_GrPixelConfig;
+    } else {
+        desc.fConfig = kRGBA_8888_GrPixelConfig;
+    }
+
+    GrTexture* texture = fDrawTarget->cmmAccess().resourceProvider()->createApproxTexture(desc, 0);
+    if (!texture) {
+        return nullptr;
+    }
+    texture->resourcePriv().setUniqueKey(key);
+    return texture;
+}
+
 GrTexture* GrClipMaskManager::createAlphaClipMask(int32_t elementsGenID,
                                                   GrReducedClip::InitialState initialState,
                                                   const GrReducedClip::ElementList& elements,
                                                   const SkVector& clipToMaskOffset,
                                                   const SkIRect& clipSpaceIBounds) {
     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
-
-    // First, check for cached texture
-    GrTexture* result = this->getCachedMaskTexture(elementsGenID, clipSpaceIBounds);
-    if (result) {
+    GrResourceProvider* resourceProvider = fDrawTarget->cmmAccess().resourceProvider();
+    GrUniqueKey key;
+    GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
+    if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
         fCurrClipMaskType = kAlpha_ClipMaskType;
-        return result;
+        return texture;
     }
 
+    SkAutoTUnref<GrTexture> texture(this->createCachedMask(
+        clipSpaceIBounds.width(), clipSpaceIBounds.height(), key, true));
+
     // There's no texture in the cache. Let's try to allocate it then.
-    result = this->allocMaskTexture(elementsGenID, clipSpaceIBounds, false);
-    if (nullptr == result) {
-        fAACache.reset();
+    if (!texture) {
         return nullptr;
     }
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     SkMatrix translate;
     translate.setTranslate(clipToMaskOffset);
 
     // The texture may be larger than necessary, this rect represents the part of the texture
     // we populate with a rasterization of the clip.
     SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
 
     // The scratch texture that we are drawing into can be substantially larger than the mask. Only
     // clear the part that we care about.
     fDrawTarget->clear(&maskSpaceIBounds,
                        GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
                        true,
-                       result->asRenderTarget());
+                       texture->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.
     GrClip clip(maskSpaceIBounds);
     SkAutoTUnref<GrTexture> temp;
 
     // walk through each clip element and perform its set op
     for (GrReducedClip::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) {
             GrPipelineBuilder pipelineBuilder;
 
             pipelineBuilder.setClip(clip);
             GrPathRenderer* pr = nullptr;
-            bool useTemp = !this->canStencilAndDrawElement(&pipelineBuilder, result, &pr, element);
+            bool useTemp = !this->canStencilAndDrawElement(&pipelineBuilder, texture, &pr, element);
             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);
                 }
 
                 if (!temp) {
                     temp.reset(this->createTempMask(maskSpaceIBounds.fRight,
                                                     maskSpaceIBounds.fBottom));
                     if (!temp) {
-                        fAACache.reset();
+                        texture->resourcePriv().removeUniqueKey();
                         return nullptr;
                     }
                 }
                 dst = temp;
                 // clear the temp target and set blend to replace
                 fDrawTarget->clear(&maskSpaceElementIBounds,
                                    invert ? 0xffffffff : 0x00000000,
                                    true,
                                    dst->asRenderTarget());
                 set_coverage_drawing_xpf(SkRegion::kReplace_Op, invert, &pipelineBuilder);
             } else {
                 // draw directly into the result with the stencil set to make the pixels affected
                 // by the clip shape be non-zero.
-                dst = result;
+                dst = texture;
                 GR_STATIC_CONST_SAME_STENCIL(kStencilInElement,
                                              kReplace_StencilOp,
                                              kReplace_StencilOp,
                                              kAlways_StencilFunc,
                                              0xffff,
                                              0xffff,
                                              0xffff);
                 pipelineBuilder.setStencil(kStencilInElement);
                 set_coverage_drawing_xpf(op, invert, &pipelineBuilder);
             }
 
             if (!this->drawElement(&pipelineBuilder, translate, dst, element, pr)) {
-                fAACache.reset();
+                texture->resourcePriv().removeUniqueKey();
                 return nullptr;
             }
 
             if (useTemp) {
                 GrPipelineBuilder backgroundPipelineBuilder;
-                backgroundPipelineBuilder.setRenderTarget(result->asRenderTarget());
+                backgroundPipelineBuilder.setRenderTarget(texture->asRenderTarget());
 
                 // Now draw into the accumulator using the real operation and the temp buffer as a
                 // texture
                 this->mergeMask(&backgroundPipelineBuilder,
-                                result,
+                                texture,
                                 temp,
                                 op,
                                 maskSpaceIBounds,
                                 maskSpaceElementIBounds);
             } else {
                 GrPipelineBuilder backgroundPipelineBuilder;
-                backgroundPipelineBuilder.setRenderTarget(result->asRenderTarget());
+                backgroundPipelineBuilder.setRenderTarget(texture->asRenderTarget());
 
                 set_coverage_drawing_xpf(op, !invert, &backgroundPipelineBuilder);
                 // Draw to the exterior pixels (those with a zero stencil value).
                 GR_STATIC_CONST_SAME_STENCIL(kDrawOutsideElement,
                                              kZero_StencilOp,
                                              kZero_StencilOp,
                                              kEqual_StencilFunc,
                                              0xffff,
                                              0x0000,
                                              0xffff);
                 backgroundPipelineBuilder.setStencil(kDrawOutsideElement);
 
                 // The color passed in here does not matter since the coverageSetOpXP won't read it.
                 fDrawTarget->drawNonAARect(backgroundPipelineBuilder, GrColor_WHITE, translate,
                                            clipSpaceIBounds);
             }
         } else {
             GrPipelineBuilder pipelineBuilder;
 
             // all the remaining ops can just be directly draw into the accumulation buffer
             set_coverage_drawing_xpf(op, false, &pipelineBuilder);
             // The color passed in here does not matter since the coverageSetOpXP won't read it.
-            this->drawElement(&pipelineBuilder, translate, result, element);
+            this->drawElement(&pipelineBuilder, translate, texture, element);
         }
     }
 
     fCurrClipMaskType = kAlpha_ClipMaskType;
-    return result;
+    return texture.detach();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Create a 1-bit clip mask in the stencil buffer. 'devClipBounds' are in device
 // (as opposed to canvas) coordinates
 bool GrClipMaskManager::createStencilClipMask(GrRenderTarget* rt,
                                               int32_t elementsGenID,
                                               GrReducedClip::InitialState initialState,
                                               const GrReducedClip::ElementList& elements,
                                               const SkIRect& clipSpaceIBounds,
@@ skipping 356 matching lines @@
     }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrTexture* GrClipMaskManager::createSoftwareClipMask(int32_t elementsGenID,
                                                      GrReducedClip::InitialState initialState,
                                                      const GrReducedClip::ElementList& elements,
                                                      const SkVector& clipToMaskOffset,
                                                      const SkIRect& clipSpaceIBounds) {
     SkASSERT(kNone_ClipMaskType == fCurrClipMaskType);
-
-    GrTexture* result = this->getCachedMaskTexture(elementsGenID, clipSpaceIBounds);
-    if (result) {
-        return result;
+    GrUniqueKey key;
+    GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
+    GrResourceProvider* resourceProvider = fDrawTarget->cmmAccess().resourceProvider();
+    if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
+        return texture;
     }
 
     // The mask texture may be larger than necessary. We round out the clip space bounds and pin
     // the top left corner of the resulting rect to the top left of the texture.
     SkIRect maskSpaceIBounds = SkIRect::MakeWH(clipSpaceIBounds.width(), clipSpaceIBounds.height());
 
     GrSWMaskHelper helper(this->getContext());
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
@@ skipping 30 matching lines @@
         if (Element::kRect_Type == element->getType()) {
             helper.draw(element->getRect(), op, element->isAA(), 0xFF);
         } else {
             SkPath path;
             element->asPath(&path);
             helper.draw(path, stroke, op, element->isAA(), 0xFF);
         }
     }
 
     // Allocate clip mask texture
-    result = this->allocMaskTexture(elementsGenID, clipSpaceIBounds, true);
+    GrTexture* result = this->createCachedMask(clipSpaceIBounds.width(), clipSpaceIBounds.height(),
+                                               key, false);
     if (nullptr == result) {
-        fAACache.reset();
         return nullptr;
     }
     helper.toTexture(result);
 
     fCurrClipMaskType = kAlpha_ClipMaskType;
     return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-void GrClipMaskManager::purgeResources() {
-    fAACache.purgeResources();
-}
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }