Refugee from Dead Machine 4: MDB Monster

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 "GrDrawingManager.h"
@@ skipping 12 matching lines @@
 #include "effects/GrConvexPolyEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrRRectEffect.h"
 #include "effects/GrTextureDomain.h"
 
 typedef SkClipStack::Element Element;
 
 ////////////////////////////////////////////////////////////////////////////////
 // set up the draw state to enable the aa clipping mask. Besides setting up the
 // stage matrix this also alters the vertex layout
-static const GrFragmentProcessor* create_fp_for_mask(GrTexture* result, const SkIRect &devBound) {
+static const GrFragmentProcessor* create_fp_for_mask(GrTexture* result, const SkIRect &devBound, GrRenderTarget* dst) {
+
     SkMatrix mat;
     // We use device coords to compute the texture coordinates. We set our matrix to be a
     // translation to the devBound, and then a scaling matrix to normalized coords.
     mat.setIDiv(result->width(), result->height());
     mat.preTranslate(SkIntToScalar(-devBound.fLeft),
                      SkIntToScalar(-devBound.fTop));
 
     SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
     return GrTextureDomainEffect::Create(result,
                                          mat,
                                          GrTextureDomain::MakeTexelDomain(result, domainTexels),
                                          GrTextureDomain::kDecal_Mode,
                                          GrTextureParams::kNone_FilterMode,
-                                         kDevice_GrCoordSet);
+                                         kDevice_GrCoordSet, dst);
 }
 
 // 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 GrClipMaskManager::PathNeedsSWRenderer(GrContext* context,
                                             bool isStencilDisabled,
                                             const GrRenderTarget* rt,
                                             const SkMatrix& viewMatrix,
                                             const Element* element,
@@ skipping 213 matching lines @@
     }
     return !failed;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
 bool GrClipMaskManager::setupClipping(const GrPipelineBuilder& pipelineBuilder,
                                       GrPipelineBuilder::AutoRestoreStencil* ars,
                                       const SkRect* devBounds,
-                                      GrAppliedClip* out) {
+                                      GrAppliedClip* out,
+                                      GrRenderTarget* dst) {
     if (kRespectClip_StencilClipMode == fClipMode) {
         fClipMode = kIgnoreClip_StencilClipMode;
     }
 
     GrReducedClip::ElementList elements(16);
     int32_t genID = 0;
     GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
     SkIRect clipSpaceIBounds;
     bool requiresAA = false;
     GrRenderTarget* rt = pipelineBuilder.getRenderTarget();
@@ skipping 71 matching lines @@
                 out->fScissorState.set(scissorSpaceIBounds);
             }
             this->setPipelineBuilderStencil(pipelineBuilder, ars);
             out->fClipCoverageFP.reset(clipFP);
             return true;
         }
     }
 
     // If MSAA is enabled we can do everything in the stencil buffer.
     if (0 == rt->numStencilSamples() && requiresAA) {
+        SkAutoTUnref<GrDrawContext> dc;
         SkAutoTUnref<GrTexture> result;
 
         // The top-left of the mask corresponds to the top-left corner of the bounds.
         SkVector clipToMaskOffset = {
             SkIntToScalar(-clipSpaceIBounds.fLeft),
             SkIntToScalar(-clipSpaceIBounds.fTop)
         };
 
         if (this->useSWOnlyPath(pipelineBuilder, rt, clipToMaskOffset, elements)) {
             // The clip geometry is complex enough that it will be more efficient to create it
             // entirely in software
             result.reset(this->createSoftwareClipMask(genID,
                                                       initialState,
                                                       elements,
                                                       clipToMaskOffset,
                                                       clipSpaceIBounds));
         } else {
             result.reset(this->createAlphaClipMask(genID,
                                                    initialState,
                                                    elements,
                                                    clipToMaskOffset,
-                                                   clipSpaceIBounds));
+                                                   clipSpaceIBounds, &dc));
             // If createAlphaClipMask fails it means useSWOnlyPath has a bug
             SkASSERT(result);
         }
 
         if (result) {
             // The mask's top left coord should be pinned to the rounded-out top left corner of
             // clipSpace bounds. We determine the mask's position WRT to the render target here.
             SkIRect rtSpaceMaskBounds = clipSpaceIBounds;
             rtSpaceMaskBounds.offset(-clip.origin());
-            out->fClipCoverageFP.reset(create_fp_for_mask(result, rtSpaceMaskBounds));
+            out->fClipCoverageFP.reset(create_fp_for_mask(result, rtSpaceMaskBounds, dst));
             this->setPipelineBuilderStencil(pipelineBuilder, ars);
             return true;
         }
         // if alpha clip mask creation fails fall through to the non-AA code paths
     }
 
     // use the stencil clip if we can't represent the clip as a rectangle.
     SkIPoint clipSpaceToStencilSpaceOffset = -clip.origin();
     this->createStencilClipMask(rt,
                                 genID,
@@ skipping 29 matching lines @@
                                     const SkClipStack::Element* element,
                                     GrPathRenderer* pr) {
 
     GrRenderTarget* rt = target->asRenderTarget();
     pipelineBuilder->setRenderTarget(rt);
 
     // The color we use to draw does not matter since we will always be using a GrCoverageSetOpXP
     // which ignores color.
     GrColor color = GrColor_WHITE;
 
+    GrPaint paint;
+    paint.setAntiAlias(element->isAA());
+    GrClip clip;
+
     // TODO: Draw rrects directly here.
     switch (element->getType()) {
         case Element::kEmpty_Type:
             SkDEBUGFAIL("Should never get here with an empty element.");
             break;
-        case Element::kRect_Type:
+        case Element::kRect_Type: {
             // TODO: Do rects directly to the accumulator using a aa-rect GrProcessor that covers
             // the entire mask bounds and writes 0 outside the rect.
             if (element->isAA()) {
                 SkRect devRect = element->getRect();
                 viewMatrix.mapRect(&devRect);
 
                 fDrawTarget->drawAARect(*pipelineBuilder, color, viewMatrix,
                                         element->getRect(), devRect);
             } else {
                 fDrawTarget->drawNonAARect(*pipelineBuilder, color, viewMatrix,
                                            element->getRect());
             }
             return true;
+        }
         default: {
             SkPath path;
             element->asPath(&path);
             if (path.isInverseFillType()) {
                 path.toggleInverseFillType();
             }
             GrStrokeInfo stroke(SkStrokeRec::kFill_InitStyle);
+
             if (nullptr == pr) {
                 GrPathRendererChain::DrawType type;
                 type = element->isAA() ? GrPathRendererChain::kColorAntiAlias_DrawType :
                                          GrPathRendererChain::kColor_DrawType;
 
                 GrPathRenderer::CanDrawPathArgs canDrawArgs;
                 canDrawArgs.fShaderCaps = this->getContext()->caps()->shaderCaps();
                 canDrawArgs.fViewMatrix = &viewMatrix;
                 canDrawArgs.fPath = &path;
                 canDrawArgs.fStroke = &stroke;
@@ skipping 50 matching lines @@
         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) {
+                                                  const SkIRect& clipSpaceIBounds,
+                                                  SkAutoTUnref<GrDrawContext>* destDC) {
     GrResourceProvider* resourceProvider = this->resourceProvider();
     GrUniqueKey key;
     GetClipMaskKey(elementsGenID, clipSpaceIBounds, &key);
     if (GrTexture* texture = resourceProvider->findAndRefTextureByUniqueKey(key)) {
         return texture;
     }
 
     // There's no texture in the cache. Let's try to allocate it then.
     SkAutoTUnref<GrTexture> texture(this->createCachedMask(
         clipSpaceIBounds.width(), clipSpaceIBounds.height(), key, true));
     if (!texture) {
         return nullptr;
     }
 
+    destDC->reset(this->getContext()->drawContext(texture->asRenderTarget()));
+    if (!*destDC) {
+        texture->unref();
+        return NULL;
+    }
+
     // Set the matrix so that rendered clip elements are transformed to mask space from clip
     // space.
     const SkMatrix translate = SkMatrix::MakeTrans(clipToMaskOffset.fX, clipToMaskOffset.fY);
 
     // 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.
+#if 1
+    (*destDC)->clear(&maskSpaceIBounds,
+                     GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
+                     true);
+#else
     fDrawTarget->clear(&maskSpaceIBounds,
                        GrReducedClip::kAllIn_InitialState == initialState ? 0xffffffff : 0x00000000,
                        true,
                        texture->asRenderTarget());
+#endif
 
     // 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.
     const GrClip clip(maskSpaceIBounds);
 
     // 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) {
-
             GrPathRenderer* pr = GetPathRenderer(this->getContext(),
                                                  texture, translate, element);
             if (Element::kRect_Type != element->getType() && !pr) {
                 // useSWOnlyPath should now filter out all cases where gpu-side mask merging would
                 // be performed (i.e., pr would be NULL for a non-rect path). See https://bug.skia.org/4519
                 // for rationale and details.
                 SkASSERT(0);
                 continue;
             }
 
@@ skipping 30 matching lines @@
                 // 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);
 
+#if 0
                 // The color passed in here does not matter since the coverageSetOpXP won't read it.
                 fDrawTarget->drawNonAARect(backgroundPipelineBuilder, GrColor_WHITE, translate,
                                            clipSpaceIBounds);
+#else
+                GrClip clip;
+                GrPaint paint;
+                (*destDC)->drawRect(clip, paint, SkMatrix::I(), SkRect::Make(clipSpaceIBounds), NULL);
+#endif
             }
         } 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, texture, element);
         }
     }
 
+    // This was written to but will have a unique key
+    texture->fException2 = true;
+
     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,
@@ skipping 429 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }