Move DstCopy on gpu into the GrXferProcessor.

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 659 matching lines @@
     }
 
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrDrawTargetCaps> fCaps;
 
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     // 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(GrPipelineBuilder*,
+    bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  GrDeviceCoordTexture* dstCopy,
                                  const SkRect* drawBounds);
 
 private:
     /**
      * This will be called before allocating a texture as a dst for copySurface. This function
      * populates the dstDesc's config, flags, and origin so as to maximize efficiency and guarantee
      * success of the copySurface call.
      */
     void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) {
@@ skipping 22 matching lines @@
     // implemented by subclass to handle release of reserved geom space
     virtual void releaseReservedVertexSpace() = 0;
     virtual void releaseReservedIndexSpace() = 0;
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
     virtual void onDraw(const GrPipelineBuilder&,
                         const GrGeometryProcessor*,
                         const DrawInfo&,
-                        const GrScissorState&,
-                        const GrDeviceCoordTexture* dstCopy) = 0;
+                        const GrScissorState&) = 0;
     virtual void onDrawBatch(GrBatch*,
                              const GrPipelineBuilder&,
                              const GrScissorState&,
-                             const GrDeviceCoordTexture* dstCopy) = 0;
+                             const SkRect* devBounds) = 0;
     // TODO copy in order drawbuffer onDrawRect to here
     virtual void onDrawRect(GrPipelineBuilder*,
                             GrColor color,
                             const SkMatrix& viewMatrix,
                             const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) = 0;
 
     virtual void onStencilPath(const GrPipelineBuilder&,
                                const GrPathProcessor*,
                                const GrPath*,
                                const GrScissorState&,
                                const GrStencilSettings&) = 0;
     virtual void onDrawPath(const GrPipelineBuilder&,
                             const GrPathProcessor*,
                             const GrPath*,
                             const GrScissorState&,
                             const GrStencilSettings&,
-                            const GrDeviceCoordTexture* dstCopy) = 0;
+                            const SkRect* devBounds) = 0;
     virtual void onDrawPaths(const GrPipelineBuilder&,
                              const GrPathProcessor*,
                              const GrPathRange*,
                              const void* indices,
                              PathIndexType,
                              const float transformValues[],
                              PathTransformType,
                              int count,
                              const GrScissorState&,
                              const GrStencilSettings&,
-                             const GrDeviceCoordTexture*) = 0;
+                             const SkRect* devBounds) = 0;
 
     virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
                          GrRenderTarget* renderTarget) = 0;
 
     /** The subclass will get a chance to copy the surface for falling back to the default
         implementation, which simply draws a rectangle (and fails if dst isn't a render target). It
         should assume that any clipping has already been performed on the rect and point. It won't
         be called if the copy can be skipped. */
     virtual bool onCopySurface(GrSurface* dst,
                                GrSurface* src,
@@ skipping 103 matching lines @@
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreEffects* are,
                            GrPipelineBuilder::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif