Remove GrRenderTarget from GrPipelineBuilder

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 99 matching lines @@
      * 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(const GrPipelineBuilder&, GrDrawContext*,
                      const GrClip&, const SkMatrix& viewMatrix,
                      const GrPath*, GrPathRendering::FillType);
 
     /**
-     * Clear the passed in render target. Ignores the GrPipelineBuilder and clip. Clears the whole
+     * Clear the passed in drawContext. Ignores the GrPipelineBuilder and clip. Clears the whole
      * thing if rect is nullptr, otherwise just the rect. If canIgnoreRect is set then the entire
-     * render target can be optionally cleared.
+     * drawContext can be optionally cleared.
      */
     void clear(const SkIRect* rect,
                GrColor color,
                bool canIgnoreRect,
                GrDrawContext*);
 
     /** Discards the contents render target. */
     void discard(GrRenderTarget*);
 
     /**
      * Copies a pixel rectangle from one surface to another. This call may finalize
      * reserved vertex/index data (as though a draw call was made). The src pixels
      * copied are specified by srcRect. They are copied to a rect of the same
      * size in dst with top left at dstPoint. If the src rect is clipped by the
      * src bounds then  pixel values in the dst rect corresponding to area clipped
      * by the src rect are not overwritten. This method is not guaranteed to succeed
      * depending on the type of surface, configs, etc, and the backend-specific
      * limitations.
      */
     bool copySurface(GrSurface* dst,
                      GrSurface* src,
                      const SkIRect& srcRect,
                      const SkIPoint& dstPoint);
 
-    /** Provides access to internal functions to GrClipMaskManager without friending all of
-        GrDrawTarget to CMM. */
-    class CMMAccess {
-    public:
-        CMMAccess(GrDrawTarget* drawTarget) : fDrawTarget(drawTarget) {}
-    private:
-        void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) const {
-            fDrawTarget->clearStencilClip(rect, insideClip, rt);
-        }
-
-        GrContext* context() const { return fDrawTarget->fContext; }
-        GrResourceProvider* resourceProvider() const { return fDrawTarget->fResourceProvider; }
-        GrDrawTarget* fDrawTarget;
-        friend class GrClipMaskManager;
-    };
-
-    const CMMAccess cmmAccess() { return CMMAccess(this); }
-
-    GrAuditTrail* getAuditTrail() const { return fAuditTrail; }
-
 private:
     friend class GrDrawingManager; // for resetFlag & TopoSortTraits
     friend class GrDrawContextPriv; // for clearStencilClip
 
     enum Flags {
         kClosed_Flag    = 0x01,   //!< This drawTarget can't accept any more batches
 
         kWasOutput_Flag = 0x02,   //!< Flag for topological sorting
         kTempMark_Flag  = 0x04,   //!< Flag for topological sorting
     };
@@ skipping 34 matching lines @@
         }
     };
 
     void recordBatch(GrBatch*);
     void forwardCombine();
 
     // 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 GrClip&,
-        const GrPipelineOptimizations& optimizations,
-        GrXferProcessor::DstTexture*,
-        const SkRect& batchBounds);
+                                 GrRenderTarget*,
+                                 const GrClip&,
+                                 const GrPipelineOptimizations& optimizations,
+                                 GrXferProcessor::DstTexture*,
+                                 const SkRect& batchBounds);
 
     void addDependency(GrDrawTarget* dependedOn);
 
-    // Used only by CMM.
+    // Used only by drawContextPriv.
     void clearStencilClip(const SkIRect&, bool insideClip, GrRenderTarget*);
 
     SkSTArray<256, SkAutoTUnref<GrBatch>, true> fBatches;
     // The context is only in service of the clip mask manager, remove once CMM doesn't need this.
     GrContext*                                  fContext;
     GrGpu*                                      fGpu;
     GrResourceProvider*                         fResourceProvider;
     GrAuditTrail*                               fAuditTrail;
 
     SkDEBUGCODE(int                             fDebugID;)
     uint32_t                                    fFlags;
 
     // 'this' drawTarget relies on the output of the drawTargets in 'fDependencies'
     SkTDArray<GrDrawTarget*>                    fDependencies;
     GrRenderTarget*                             fRenderTarget;
 
     bool                                        fClipBatchToBounds;
     bool                                        fDrawBatchBounds;
     int                                         fMaxBatchLookback;
     int                                         fMaxBatchLookahead;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif