Start to propagate constness of GrPipelineBuilder up the stack

src/gpu/GrDrawContext.cpp

 
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrAtlasTextContext.h"
@@ skipping 98 matching lines @@
 
 void GrDrawContext::drawPaths(GrPipelineBuilder* pipelineBuilder,
                               const GrPathProcessor* pathProc,
                               const GrPathRange* pathRange,
                               const void* indices,
                               int /*GrDrawTarget::PathIndexType*/ indexType,
                               const float transformValues[],
                               int /*GrDrawTarget::PathTransformType*/ transformType,
                               int count,
                               int /*GrPathRendering::FillType*/ fill) {
-    fDrawTarget->drawPaths(pipelineBuilder, pathProc, pathRange,
+    fDrawTarget->drawPaths(*pipelineBuilder, pathProc, pathRange,
                            indices, (GrDrawTarget::PathIndexType) indexType,
                            transformValues,
                            (GrDrawTarget::PathTransformType) transformType,
                            count, (GrPathRendering::FillType) fill);
 }
 
 void GrDrawContext::discard(GrRenderTarget* renderTarget) {
     RETURN_IF_ABANDONED
     SkASSERT(renderTarget);
     AutoCheckFlush acf(fContext);
@@ skipping 55 matching lines @@
             SkDebugf("Could not invert matrix\n");
             return;
         }
 
         AutoCheckFlush acf(fContext);
         if (!this->prepareToDraw(rt)) {
             return;
         }
 
         GrPipelineBuilder pipelineBuilder(*paint, rt, clip);
-        fDrawTarget->drawBWRect(&pipelineBuilder,
+        fDrawTarget->drawBWRect(pipelineBuilder,
                                 paint->getColor(),
                                 SkMatrix::I(),
                                 r,
                                 NULL,
                                 &localMatrix);
     }
 }
 
 static inline bool is_irect(const SkRect& r) {
   return SkScalarIsInt(r.fLeft)  && SkScalarIsInt(r.fTop) &&
@@ skipping 274 matching lines @@
     GrColor color = paint.getColor();
     SkRect devBoundRect;
     bool needAA = paint.isAntiAlias() &&
                   !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
     bool doAA = needAA && apply_aa_to_rect(fDrawTarget, &pipelineBuilder, &devBoundRect, rect,
                                            width, viewMatrix, color);
 
     if (doAA) {
         if (width >= 0) {
             GrAARectRenderer::StrokeAARect(fDrawTarget,
-                                           &pipelineBuilder,
+                                           pipelineBuilder,
                                            color,
                                            viewMatrix,
                                            rect,
                                            devBoundRect,
                                            *strokeInfo);
         } else {
             // filled AA rect
             GrAARectRenderer::FillAARect(fDrawTarget,
-                                         &pipelineBuilder,
+                                         pipelineBuilder,
                                          color,
                                          viewMatrix,
                                          rect,
                                          devBoundRect);
         }
         return;
     }
 
     if (width >= 0) {
         StrokeRectBatch::Geometry geometry;
         geometry.fViewMatrix = viewMatrix;
         geometry.fColor = color;
         geometry.fRect = rect;
         geometry.fStrokeWidth = width;
 
         // Non-AA hairlines are snapped to pixel centers to make which pixels are hit deterministic
         bool snapToPixelCenters = (0 == width && !rt->isUnifiedMultisampled());
         SkAutoTUnref<GrBatch> batch(StrokeRectBatch::Create(geometry, snapToPixelCenters));
 
         // Depending on sub-pixel coordinates and the particular GPU, we may lose a corner of
         // hairline rects. We jam all the vertices to pixel centers to avoid this, but not when MSAA
         // is enabled because it can cause ugly artifacts.
         pipelineBuilder.setState(GrPipelineBuilder::kSnapVerticesToPixelCenters_Flag,
                                  snapToPixelCenters);
-        fDrawTarget->drawBatch(&pipelineBuilder, batch);
+        fDrawTarget->drawBatch(pipelineBuilder, batch);
     } else {
         // filled BW rect
-        fDrawTarget->drawSimpleRect(&pipelineBuilder, color, viewMatrix, rect);
+        fDrawTarget->drawSimpleRect(pipelineBuilder, color, viewMatrix, rect);
     }
 }
 
 void GrDrawContext::drawNonAARectToRect(GrRenderTarget* rt,
                                         const GrClip& clip,
                                         const GrPaint& paint,
                                         const SkMatrix& viewMatrix,
                                         const SkRect& rectToDraw,
                                         const SkRect& localRect,
                                         const SkMatrix* localMatrix) {
     RETURN_IF_ABANDONED
     AutoCheckFlush acf(fContext);
     if (!this->prepareToDraw(rt)) {
         return;
     }
 
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
-    fDrawTarget->drawBWRect(&pipelineBuilder,
+    fDrawTarget->drawBWRect(pipelineBuilder,
                             paint.getColor(),
                             viewMatrix,
                             rectToDraw,
                             &localRect,
                             localMatrix);
 }
 
 static const GrGeometryProcessor* set_vertex_attributes(bool hasLocalCoords,
                                                         bool hasColors,
                                                         int* colorOffset,
@@ skipping 298 matching lines @@
         bounds.outset(0.5f, 0.5f);
     }
 
     DrawVerticesBatch::Geometry geometry;
     geometry.fColor = paint.getColor();
     SkAutoTUnref<GrBatch> batch(DrawVerticesBatch::Create(geometry, primitiveType, viewMatrix,
                                                           positions, vertexCount, indices,
                                                           indexCount, colors, texCoords,
                                                           bounds));
 
-    fDrawTarget->drawBatch(&pipelineBuilder, batch);
+    fDrawTarget->drawBatch(pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawContext::drawRRect(GrRenderTarget*rt,
                               const GrClip& clip,
                               const GrPaint& paint,
                               const SkMatrix& viewMatrix,
                               const SkRRect& rrect,
                               const GrStrokeInfo& strokeInfo) {
@@ skipping 193 matching lines @@
     GrPipelineBuilder pipelineBuilder(paint, rt, clip);
     if (!strokeInfo.isDashed()) {
         bool useCoverageAA = paint.isAntiAlias() &&
                 !pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
 
         if (useCoverageAA && strokeInfo.getWidth() < 0 && !path.isConvex()) {
             // Concave AA paths are expensive - try to avoid them for special cases
             SkRect rects[2];
 
             if (is_nested_rects(viewMatrix, path, strokeInfo, rects)) {
-                GrAARectRenderer::FillAANestedRects(fDrawTarget, &pipelineBuilder, color,
+                GrAARectRenderer::FillAANestedRects(fDrawTarget, pipelineBuilder, color,
                                                     viewMatrix, rects);
                 return;
             }
         }
         SkRect ovalRect;
         bool isOval = path.isOval(&ovalRect);
 
         if (isOval && !path.isInverseFillType()) {
             if (GrOvalRenderer::DrawOval(fDrawTarget,
                                          &pipelineBuilder,
@@ skipping 92 matching lines @@
 
 bool GrDrawContext::prepareToDraw(GrRenderTarget* rt) {
     RETURN_FALSE_IF_ABANDONED
 
     ASSERT_OWNED_RESOURCE(rt);
     SkASSERT(rt);
     return true;
 }
 
 void GrDrawContext::drawBatch(GrPipelineBuilder* pipelineBuilder, GrBatch* batch) {
-    fDrawTarget->drawBatch(pipelineBuilder, batch);
+    fDrawTarget->drawBatch(*pipelineBuilder, batch);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef GR_TEST_UTILS
 
 BATCH_TEST_DEFINE(StrokeRectBatch) {
     StrokeRectBatch::Geometry geometry;
     geometry.fViewMatrix = GrTest::TestMatrix(random);
     geometry.fColor = GrRandomColor(random);
@@ skipping 109 matching lines @@
     return DrawVerticesBatch::Create(geometry, type, viewMatrix,
                                      positions.begin(), vertexCount,
                                      indices.begin(), hasIndices ? vertexCount : 0,
                                      colors.begin(),
                                      texCoords.begin(),
                                      bounds);
 }
 
 #endif