some cleanup around GrGpu/GrDrawTarget copySurface

src/gpu/GrInOrderDrawBuffer.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
@@ skipping 34 matching lines @@
      * @param gpu        the gpu object that this draw buffer flushes to.
      * @param vertexPool pool where vertices for queued draws will be saved when
      *                   the vertex source is either reserved or array.
      * @param indexPool  pool where indices for queued draws will be saved when
      *                   the index source is either reserved or array.
      */
     GrInOrderDrawBuffer(GrGpu* gpu,
                         GrVertexBufferAllocPool* vertexPool,
                         GrIndexBufferAllocPool* indexPool);
 
-    virtual ~GrInOrderDrawBuffer();
+    ~GrInOrderDrawBuffer() SK_OVERRIDE;
 
     /**
      * Empties the draw buffer of any queued up draws. This must not be called while inside an
      * unbalanced pushGeometrySource(). The current draw state and clip are preserved.
      */
     void reset();
 
     /**
      * This plays the queued up draws to its GrGpu target. It also resets this object (i.e. flushing
      * is destructive). This buffer must not have an active reserved vertex or index source. Any
      * reserved geometry on the target will be finalized because it's geometry source will be pushed
      * before flushing and popped afterwards.
      */
     void flush();
 
     // tracking for draws
-    virtual DrawToken getCurrentDrawToken() { return DrawToken(this, fDrawID); }
+    DrawToken getCurrentDrawToken() { return DrawToken(this, fDrawID); }
 
     // overrides from GrDrawTarget
-    virtual bool geometryHints(size_t vertexStride,
-                               int* vertexCount,
-                               int* indexCount) const SK_OVERRIDE;
+    bool geometryHints(size_t vertexStride,
+                       int* vertexCount,
+                       int* indexCount) const SK_OVERRIDE;
 
-    virtual bool copySurface(GrSurface* dst,
-                             GrSurface* src,
-                             const SkIRect& srcRect,
-                             const SkIPoint& dstPoint)  SK_OVERRIDE;
+    void clearStencilClip(const SkIRect& rect,
+                          bool insideClip,
+                          GrRenderTarget* renderTarget) SK_OVERRIDE;
 
-    virtual bool canCopySurface(const GrSurface* dst,
-                                const GrSurface* src,
-                                const SkIRect& srcRect,
-                                const SkIPoint& dstPoint) SK_OVERRIDE;
-
-    virtual void clearStencilClip(const SkIRect& rect,
-                                  bool insideClip,
-                                  GrRenderTarget* renderTarget) SK_OVERRIDE;
-
-    virtual void discard(GrRenderTarget*) SK_OVERRIDE;
-
-    virtual void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
+    void discard(GrRenderTarget*) SK_OVERRIDE;
 
 private:
     typedef GrClipMaskManager::ScissorState ScissorState;
     enum {
         kDraw_Cmd           = 1,
         kStencilPath_Cmd    = 2,
         kSetState_Cmd       = 3,
         kClear_Cmd          = 4,
         kCopySurface_Cmd    = 5,
         kDrawPath_Cmd       = 6,
@@ skipping 160 matching lines @@
 
     bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) SK_OVERRIDE;
     bool onReserveIndexSpace(int indexCount, void** indices) SK_OVERRIDE;
     void releaseReservedVertexSpace() SK_OVERRIDE;
     void releaseReservedIndexSpace() SK_OVERRIDE;
     void geometrySourceWillPush() SK_OVERRIDE;
     void geometrySourceWillPop(const GeometrySrcState& restoredState) SK_OVERRIDE;
     void willReserveVertexAndIndexSpace(int vertexCount,
                                         size_t vertexStride,
                                         int indexCount) SK_OVERRIDE;
+    bool onCopySurface(GrSurface* dst,
+                       GrSurface* src,
+                       const SkIRect& srcRect,
+                       const SkIPoint& dstPoint) SK_OVERRIDE;
+    bool onCanCopySurface(const GrSurface* dst,
+                          const GrSurface* src,
+                          const SkIRect& srcRect,
+                          const SkIPoint& dstPoint) SK_OVERRIDE;
+    bool onInitCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE;
 
     // Attempts to concat instances from info onto the previous draw. info must represent an
     // instanced draw. The caller must have already recorded a new draw state and clip if necessary.
     int concatInstancedDraw(const GrDrawState&, const DrawInfo&);
 
     // Determines whether the current draw operation requires a new GrOptDrawState and if so
     // records it. If the draw can be skipped false is returned and no new GrOptDrawState is
     // recorded.
     bool SK_WARN_UNUSED_RESULT recordStateAndShouldDraw(const GrDrawState&,
                                                         GrGpu::DrawType,
@@ skipping 37 matching lines @@
     SkTDArray<char>                     fPathIndexBuffer;
     SkTDArray<float>                    fPathTransformBuffer;
     GeoPoolStateStack                   fGeoPoolStateStack;
     bool                                fFlushing;
     uint32_t                            fDrawID;
 
     typedef GrClipTarget INHERITED;
 };
 
 #endif