Add some more volatile paths.

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 79 matching lines @@
     // of whether it would invoke the GrSoftwarePathRenderer.
     SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
 
     for (GrReducedClip::ElementList::Iter iter(elements.headIter()); iter.get(); iter.next()) {
         const Element* element = iter.get();
         // rects can always be drawn directly w/o using the software path
         // Skip rrects once we're drawing them directly.
         if (Element::kRect_Type != element->getType()) {
             SkPath path;
             element->asPath(&path);
+            path.setIsVolatile(true);

[bsalomon, 2014/10/24 17:29:18]

Is it not already volatile since it comes from the clipstack? Same Q for other
paths in this file.

[jvanverth1, 2014/10/24 17:36:30]

I'm not sure when it would get set as volatile in the clipstack -- wouldn't it
be stored in the heap in that case? And it could also be a rrect.

             if (path_needs_SW_renderer(this->getContext(), fGpu, path, stroke, element->isAA())) {
                 return true;
             }
         }
     }
     return false;
 }
 
 bool GrClipMaskManager::installClipEffects(const GrReducedClip::ElementList& elements,
                                            GrDrawState::AutoRestoreEffects* are,
@@ skipping 329 matching lines @@
     GrDrawState* drawState = fGpu->drawState();
     drawState->setRenderTarget(target->asRenderTarget());
 
     if (Element::kRect_Type == element->getType()) {
         return true;
     } else {
         // We shouldn't get here with an empty clip element.
         SkASSERT(Element::kEmpty_Type != element->getType());
         SkPath path;
         element->asPath(&path);
+        path.setIsVolatile(true);
         if (path.isInverseFillType()) {
             path.toggleInverseFillType();
         }
         SkStrokeRec stroke(SkStrokeRec::kFill_InitStyle);
         GrPathRendererChain::DrawType type = element->isAA() ?
             GrPathRendererChain::kStencilAndColorAntiAlias_DrawType :
             GrPathRendererChain::kStencilAndColor_DrawType;
         *pr = this->getContext()->getPathRenderer(path, stroke, fGpu, false, type);
         return SkToBool(*pr);
     }
@@ skipping 300 matching lines @@
 
             SkRegion::Op op = element->getOp();
 
             GrPathRenderer* pr = NULL;
             SkPath clipPath;
             if (Element::kRect_Type == element->getType()) {
                 stencilSupport = GrPathRenderer::kNoRestriction_StencilSupport;
                 fillInverted = false;
             } else {
                 element->asPath(&clipPath);
+                clipPath.setIsVolatile(true);
                 fillInverted = clipPath.isInverseFillType();
                 if (fillInverted) {
                     clipPath.toggleInverseFillType();
                 }
                 pr = this->getContext()->getPathRenderer(clipPath,
                                                          stroke,
                                                          fGpu,
                                                          false,
                                                          GrPathRendererChain::kStencilOnly_DrawType,
                                                          &stencilSupport);
@@ skipping 294 matching lines @@
             // but leave the pixels inside the geometry alone. For reverse difference we invert all
             // the pixels before clearing the ones outside the geometry.
             if (SkRegion::kReverseDifference_Op == op) {
                 SkRect temp = SkRect::Make(clipSpaceIBounds);
                 // invert the entire scene
                 helper.draw(temp, SkRegion::kXOR_Op, false, 0xFF);
             }
 
             SkPath clipPath;
             element->asPath(&clipPath);
+            clipPath.setIsVolatile(true);
             clipPath.toggleInverseFillType();
             helper.draw(clipPath, stroke, SkRegion::kReplace_Op, element->isAA(), 0x00);
 
             continue;
         }
 
         // The other ops (union, xor, diff) only affect pixels inside
         // the geometry so they can just be drawn normally
         if (Element::kRect_Type == element->getType()) {
             helper.draw(element->getRect(), op, element->isAA(), 0xFF);
         } else {
             SkPath path;
             element->asPath(&path);
+            path.setIsVolatile(true);
             helper.draw(path, stroke, op, element->isAA(), 0xFF);
         }
     }
 
     // Allocate clip mask texture
     result = this->allocMaskTexture(elementsGenID, clipSpaceIBounds, true);
     if (NULL == result) {
         fAACache.reset();
         return NULL;
     }
@@ skipping 30 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);
     }
 }