Start to propagate constness of GrPipelineBuilder up the stack

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
@@ skipping 48 matching lines @@
      * This plays any queued up draws to its GrGpu target. It also resets this object (i.e. flushing
      * is destructive).
      */
     void flush();
 
     /**
      * Gets the capabilities of the draw target.
      */
     const GrCaps* caps() const { return fCaps; }
 
-    void drawBatch(GrPipelineBuilder*, GrBatch*);
+    void drawBatch(const GrPipelineBuilder&, GrBatch*);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * winding (not inverse or hairline). It will respect the HW antialias flag
      * on the GrPipelineBuilder (if possible in the 3D API).  Note, we will never have an inverse
      * fill with stencil path
      */
-    void stencilPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
+    void stencilPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*,
                      GrPathRendering::FillType);
 
     /**
      * Draws a path. Fill must not be a hairline. It will respect the HW
      * antialias flag on the GrPipelineBuilder (if possible in the 3D API).
      */
-    void drawPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
+    void drawPath(const GrPipelineBuilder&, const GrPathProcessor*, const GrPath*,
                   GrPathRendering::FillType);
 
     /**
      * Draws the aggregate path from combining multiple. Note that this will not
      * always be equivalent to back-to-back calls to drawPath(). It will respect
      * the HW antialias flag on the GrPipelineBuilder (if possible in the 3D API).
      *
      * @param pathRange       Source paths to draw from
      * @param indices         Array of path indices to draw
      * @param indexType       Data type of the array elements in indexBuffer
      * @param transformValues Array of transforms for the individual paths
      * @param transformType   Type of transforms in transformBuffer
      * @param count           Number of paths to draw
      * @param fill            Fill type for drawing all the paths
      */
-    void drawPaths(GrPipelineBuilder*,
+    void drawPaths(const GrPipelineBuilder&,
                    const GrPathProcessor*,
                    const GrPathRange* pathRange,
                    const void* indices,
                    PathIndexType indexType,
                    const float transformValues[],
                    PathTransformType transformType,
                    int count,
                    GrPathRendering::FillType fill);
 
     /**
      * Helper function for drawing rects.
      *
      * @param rect        the rect to draw
      * @param localRect   optional rect that specifies local coords to map onto
      *                    rect. If NULL then rect serves as the local coords.
      * @param localMatrix Optional local matrix. The local coordinates are specified by localRect,
      *                    or if it is NULL by rect. This matrix applies to the coordinate implied by
      *                    that rectangle before it is input to GrCoordTransforms that read local
      *                    coordinates
      */
-    void drawBWRect(GrPipelineBuilder* pipelineBuilder,
+    void drawBWRect(const GrPipelineBuilder& pipelineBuilder,
                     GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& rect,
                     const SkRect* localRect,
                     const SkMatrix* localMatrix);
 
     /**
      * Helper for drawRect when the caller doesn't need separate local rects or matrices.
      */
-    void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM,
+    void drawSimpleRect(const GrPipelineBuilder& ds, GrColor color, const SkMatrix& viewM,
                         const SkRect& rect) {
         this->drawBWRect(ds, color, viewM, rect, NULL, NULL);
     }
-    void drawSimpleRect(GrPipelineBuilder* ds, GrColor color, const SkMatrix& viewM,
+    void drawSimpleRect(const GrPipelineBuilder& ds, GrColor color, const SkMatrix& viewM,
                         const SkIRect& irect) {
         SkRect rect = SkRect::Make(irect);
         this->drawBWRect(ds, color, viewM, rect, NULL, NULL);
     }
 
-    void drawAARect(GrPipelineBuilder* pipelineBuilder,
+    void drawAARect(const GrPipelineBuilder& pipelineBuilder,
                     GrColor color,
                     const SkMatrix& viewMatrix,
                     const SkRect& rect,
                     const SkRect& devRect);
 
     /**
      * Clear the passed in render target. Ignores the GrPipelineBuilder and clip. Clears the whole
      * thing if rect is NULL, otherwise just the rect. If canIgnoreRect is set then the entire
      * render target can be optionally cleared.
      */
@@ skipping 62 matching lines @@
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  const GrProcOptInfo& colorPOI,
                                  const GrProcOptInfo& coveragePOI,
                                  GrXferProcessor::DstTexture*,
                                  const SkRect* drawBounds);
 
     struct PipelineInfo {
-        PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
+        PipelineInfo(const GrPipelineBuilder& pipelineBuilder, GrScissorState* scissor,
                      const GrPrimitiveProcessor* primProc,
                      const SkRect* devBounds, GrDrawTarget* target);
 
-        PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
+        PipelineInfo(const GrPipelineBuilder& pipelineBuilder, GrScissorState* scissor,
                      const GrBatch* batch, const SkRect* devBounds,
                      GrDrawTarget* target);
 
         bool willColorBlendWithDst(const GrPrimitiveProcessor* primProc) const {
             return fPipelineBuilder->willColorBlendWithDst(primProc);
         }
     private:
         friend class GrDrawTarget;
 
         bool mustSkipDraw() const { return (NULL == fPipelineBuilder); }
 
-        GrPipelineBuilder*          fPipelineBuilder;
+        const GrPipelineBuilder*    fPipelineBuilder;
         GrScissorState*             fScissor;
         GrProcOptInfo               fColorPOI; 
         GrProcOptInfo               fCoveragePOI; 
         GrXferProcessor::DstTexture fDstTexture;
     };
 
     void setupPipeline(const PipelineInfo& pipelineInfo, GrPipeline* pipeline);
 
 private:
     virtual void onReset() = 0;
@@ skipping 29 matching lines @@
                                GrSurface* src,
                                const SkIRect& srcRect,
                                const SkIPoint& dstPoint) = 0;
 
     // Check to see if this set of draw commands has been sent out
     virtual bool       isIssued(uint32_t drawID) { return true; }
     void getPathStencilSettingsForFilltype(GrPathRendering::FillType,
                                            const GrStencilAttachment*,
                                            GrStencilSettings*);
     virtual GrClipMaskManager* clipMaskManager() = 0;
-    virtual bool setupClip(GrPipelineBuilder*,
+    virtual bool setupClip(const GrPipelineBuilder&,
                            GrPipelineBuilder::AutoRestoreFragmentProcessors*,
                            GrPipelineBuilder::AutoRestoreStencil*,
                            GrPipelineBuilder::AutoRestoreProcessorDataManager*,
                            GrScissorState*,
                            const SkRect* devBounds) = 0;
 
     GrGpu*                  fGpu;
     const GrCaps*           fCaps;
     GrResourceProvider*     fResourceProvider;
     // To keep track that we always have at least as many debug marker adds as removes
@@ skipping 32 matching lines @@
      */
     void purgeResources() override;
 
 protected:
     SkAutoTDelete<GrClipMaskManager> fClipMaskManager;
     GrContext*                       fContext;
 
 private:
     GrClipMaskManager* clipMaskManager() override { return fClipMaskManager; }
 
-    bool setupClip(GrPipelineBuilder*,
+    bool setupClip(const GrPipelineBuilder&,
                    GrPipelineBuilder::AutoRestoreFragmentProcessors*,
                    GrPipelineBuilder::AutoRestoreStencil*,
                    GrPipelineBuilder::AutoRestoreProcessorDataManager*,
                    GrScissorState* scissorState,
                    const SkRect* devBounds) override;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif