Start using RenderTargetProxy (omnibus)

src/gpu/GrClipStackClip.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrClipStackClip.h"
 
 #include "GrAppliedClip.h"
 #include "GrContextPriv.h"
 #include "GrDrawingManager.h"
 #include "GrRenderTargetContextPriv.h"
 #include "GrFixedClip.h"
 #include "GrGpuResourcePriv.h"
 #include "GrRenderTargetPriv.h"
 #include "GrStencilAttachment.h"
 #include "GrSWMaskHelper.h"
+#include "GrTextureProxy.h"
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef SkClipStack::Element Element;
 typedef GrReducedClip::InitialState InitialState;
 typedef GrReducedClip::ElementList ElementList;
 
 static const int kMaxAnalyticElements = 4;
 
@@ skipping 44 matching lines @@
         return;
     }
     SkRect devBounds;
     fStack->getConservativeBounds(-fOrigin.x(), -fOrigin.y(), width, height, &devBounds,
                                   isIntersectionOfRects);
     devBounds.roundOut(devResult);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // set up the draw state to enable the aa clipping mask.
-static sk_sp<GrFragmentProcessor> create_fp_for_mask(GrTexture* result,
+static sk_sp<GrFragmentProcessor> create_fp_for_mask(GrTextureProxy* result,
                                                      const SkIRect &devBound) {
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     return GrDeviceSpaceTextureDecalFragmentProcessor::Make(result, domainTexels,
                                                             {devBound.fLeft, devBound.fTop});
 }
 
 // Does the path in 'element' require SW rendering? If so, return true (and,
 // optionally, set 'prOut' to NULL. If not, return false (and, optionally, set
 // 'prOut' to the non-SW path renderer that will do the job).
 bool GrClipStackClip::PathNeedsSWRenderer(GrContext* context,
@@ skipping 234 matching lines @@
         if (reducedClip.requiresAA() &&
             get_analytic_clip_processor(reducedClip.elements(), disallowAnalyticAA,
                                         {-clipX, -clipY}, devBounds, &clipFP)) {
             out->addCoverageFP(std::move(clipFP));
             return true;
         }
     }
 
     // If the stencil buffer is multisampled we can use it to do everything.
     if (!renderTargetContext->isStencilBufferMultisampled() && reducedClip.requiresAA()) {
-        sk_sp<GrTexture> result;
+        sk_sp<GrTextureProxy> result;
         if (UseSWOnlyPath(context, hasUserStencilSettings, renderTargetContext, reducedClip)) {
             // The clip geometry is complex enough that it will be more efficient to create it
             // entirely in software
             result = CreateSoftwareClipMask(context->textureProvider(), reducedClip);
         } else {
             result = CreateAlphaClipMask(context, reducedClip);
             // If createAlphaClipMask fails it means UseSWOnlyPath has a bug
             SkASSERT(result);
         }
 
@@ skipping 33 matching lines @@
 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;
     // SkToS16 because image filters outset layers to a size indicated by the filter, which can
     // sometimes result in negative coordinates from clip space.
     builder[1] = SkToS16(bounds.fLeft) | (SkToS16(bounds.fRight) << 16);
     builder[2] = SkToS16(bounds.fTop) | (SkToS16(bounds.fBottom) << 16);
 }
 
-sk_sp<GrTexture> GrClipStackClip::CreateAlphaClipMask(GrContext* context,
-                                                      const GrReducedClip& reducedClip) {
+sk_sp<GrTextureProxy> GrClipStackClip::CreateAlphaClipMask(GrContext* context,
+                                                           const GrReducedClip& reducedClip) {
     GrResourceProvider* resourceProvider = context->resourceProvider();
     GrUniqueKey key;
     GetClipMaskKey(reducedClip.elementsGenID(), reducedClip.ibounds(), &key);
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
-        return sk_sp<GrTexture>(texture);
+        return GrTextureProxy::Make(sk_sp<GrTexture>(texture));
     }
 
     sk_sp<GrRenderTargetContext> rtc(context->makeRenderTargetContextWithFallback(
                                                                              SkBackingFit::kApprox,
                                                                              reducedClip.width(),
                                                                              reducedClip.height(),
                                                                              kAlpha_8_GrPixelConfig,
                                                                              nullptr));
     if (!rtc) {
         return nullptr;
     }
 
     if (!reducedClip.drawAlphaClipMask(rtc.get())) {
         return nullptr;
     }
 
-    sk_sp<GrTexture> texture(rtc->asTexture());
+    sk_sp<GrTextureProxy> texture(rtc->asDeferredTexture());
     SkASSERT(texture);
-    texture->resourcePriv().setUniqueKey(key);
+    //texture->resourcePriv().setUniqueKey(key);
     return texture;
 }
 
-sk_sp<GrTexture> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texProvider,
-                                                         const GrReducedClip& reducedClip) {
+////////////////////////////////////////////////////////////////////////////////
+sk_sp<GrTextureProxy> GrClipStackClip::CreateSoftwareClipMask(GrTextureProvider* texProvider,
+                                                              const GrReducedClip& reducedClip) {
     GrUniqueKey key;
     GetClipMaskKey(reducedClip.elementsGenID(), reducedClip.ibounds(), &key);
     if (GrTexture* texture = texProvider->findAndRefTextureByUniqueKey(key)) {
-        return sk_sp<GrTexture>(texture);
+        return GrTextureProxy::Make(sk_ref_sp(texture)); // sub-optimal!!
     }
 
     // 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(reducedClip.width(), reducedClip.height());
 
     GrSWMaskHelper helper(texProvider);
 
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
@@ skipping 46 matching lines @@
     desc.fConfig = kAlpha_8_GrPixelConfig;
 
     sk_sp<GrTexture> result(texProvider->createApproxTexture(desc));
     if (!result) {
         return nullptr;
     }
     result->resourcePriv().setUniqueKey(key);
 
     helper.toTexture(result.get());
 
-    return result;
+    return GrTextureProxy::Make(result);
 }