Mark SkPaths created by GrContext fallback draw logic as volatile

src/gpu/GrContext.cpp

 
 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 
@@ skipping 562 matching lines @@
 
 void GrContext::drawRect(GrRenderTarget* rt,
                          const GrClip& clip,
                          const GrPaint& paint,
                          const SkMatrix& viewMatrix,
                          const SkRect& rect,
                          const GrStrokeInfo* strokeInfo) {
     RETURN_IF_ABANDONED
     if (strokeInfo && strokeInfo->isDashed()) {
         SkPath path;
+        path.setIsVolatile(true);
         path.addRect(rect);
         this->drawPath(rt, clip, paint, viewMatrix, path, *strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
@@ skipping 437 matching lines @@
                           const SkMatrix& viewMatrix,
                           const SkRRect& rrect,
                           const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
     if (rrect.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
+        path.setIsVolatile(true);
         path.addRRect(rrect);
         this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawRRect", target);
 
     GrColor color = paint.getColor();
     if (!fOvalRenderer->drawRRect(target,
                                   &pipelineBuilder,
                                   color,
                                   viewMatrix,
                                   paint.isAntiAlias(),
                                   rrect,
                                   strokeInfo)) {
         SkPath path;
+        path.setIsVolatile(true);
         path.addRRect(rrect);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawDRRect(GrRenderTarget* rt,
                            const GrClip& clip,
@@ skipping 14 matching lines @@
 
     GrColor color = paint.getColor();
     if (!fOvalRenderer->drawDRRect(target,
                                    &pipelineBuilder,
                                    color,
                                    viewMatrix,
                                    paint.isAntiAlias(),
                                    outer,
                                    inner)) {
         SkPath path;
+        path.setIsVolatile(true);
         path.addRRect(inner);
         path.addRRect(outer);
         path.setFillType(SkPath::kEvenOdd_FillType);
-
         GrStrokeInfo fillRec(SkStrokeRec::kFill_InitStyle);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, fillRec);
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrContext::drawOval(GrRenderTarget* rt,
                          const GrClip& clip,
                          const GrPaint& paint,
                          const SkMatrix& viewMatrix,
                          const SkRect& oval,
                          const GrStrokeInfo& strokeInfo) {
     RETURN_IF_ABANDONED
     if (oval.isEmpty()) {
        return;
     }
 
     if (strokeInfo.isDashed()) {
         SkPath path;
+        path.setIsVolatile(true);
         path.addOval(oval);
         this->drawPath(rt, clip, paint, viewMatrix, path, strokeInfo);
         return;
     }
 
     AutoCheckFlush acf(this);
     GrPipelineBuilder pipelineBuilder;
     GrDrawTarget* target = this->prepareToDraw(&pipelineBuilder, rt, clip, &paint, &acf);
     if (NULL == target) {
         return;
     }
 
     GR_CREATE_TRACE_MARKER("GrContext::drawOval", target);
 
     GrColor color = paint.getColor();
     if (!fOvalRenderer->drawOval(target,
                                  &pipelineBuilder,
                                  color,
                                  viewMatrix,
                                  paint.isAntiAlias(),
                                  oval,
                                  strokeInfo)) {
         SkPath path;
+        path.setIsVolatile(true);
         path.addOval(oval);
         this->internalDrawPath(target, &pipelineBuilder, viewMatrix, color, paint.isAntiAlias(),
                                path, strokeInfo);
     }
 }
 
 // Can 'path' be drawn as a pair of filled nested rectangles?
 static bool is_nested_rects(GrDrawTarget* target,
                             GrPipelineBuilder* pipelineBuilder,
                             GrColor color,
@@ skipping 830 matching lines @@
     geometry.fColor = GrRandomColor(random);
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif