some cleanup around GrGpu/GrDrawTarget copySurface

src/gpu/GrTest.cpp

 
 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTest.h"
 
@@ skipping 35 matching lines @@
 
 #include "GrBufferAllocPool.h"
 #include "GrInOrderDrawBuffer.h"
 #include "GrGpu.h"
 
 class GrOptDrawState;
 
 class MockGpu : public GrGpu {
 public:
     MockGpu(GrContext* context) : INHERITED(context) { fCaps.reset(SkNEW(GrDrawTargetCaps)); }
-    virtual ~MockGpu() { }
-    virtual bool canWriteTexturePixels(const GrTexture*,
-                                       GrPixelConfig srcConfig) const SK_OVERRIDE {
+    ~MockGpu() SK_OVERRIDE {}
+    bool canWriteTexturePixels(const GrTexture*, GrPixelConfig srcConfig) const SK_OVERRIDE {
         return true;
     }
 
-    virtual bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
-                                           int left, int top,
-                                           int width, int height,
-                                           GrPixelConfig config,
-                                           size_t rowBytes) const SK_OVERRIDE { return false; }
-    virtual void buildProgramDesc(const GrOptDrawState&,
-                                  const GrProgramDesc::DescInfo&,
-                                  GrGpu::DrawType,
-                                  GrProgramDesc* desc) SK_OVERRIDE { }
+    bool readPixelsWillPayForYFlip(GrRenderTarget* renderTarget,
+                                   int left, int top,
+                                   int width, int height,
+                                   GrPixelConfig config,
+                                   size_t rowBytes) const SK_OVERRIDE { return false; }
+    void buildProgramDesc(const GrOptDrawState&,
+                          const GrProgramDesc::DescInfo&,
+                          GrGpu::DrawType,
+                          GrProgramDesc* desc) SK_OVERRIDE {}
 
-    virtual void discard(GrRenderTarget*) SK_OVERRIDE { }
+    void discard(GrRenderTarget*) SK_OVERRIDE {}
 
-    virtual bool canCopySurface(const GrSurface* dst,
-                                const GrSurface* src,
-                                const SkIRect& srcRect,
-                                const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
+    bool canCopySurface(const GrSurface* dst,
+                        const GrSurface* src,
+                        const SkIRect& srcRect,
+                        const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
 
-    virtual bool copySurface(GrSurface* dst,
-                             GrSurface* src,
-                             const SkIRect& srcRect,
-                             const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
+    bool copySurface(GrSurface* dst,
+                     GrSurface* src,
+                     const SkIRect& srcRect,
+                     const SkIPoint& dstPoint) SK_OVERRIDE { return false; };
+
+    bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) SK_OVERRIDE {
+        return false;
+    }
 
 private:
-    virtual void onResetContext(uint32_t resetBits) { };
-    virtual GrTexture* onCreateTexture(const GrSurfaceDesc& desc,
-                                       const void* srcData,
-                                       size_t rowBytes)  SK_OVERRIDE {
+    void onResetContext(uint32_t resetBits) SK_OVERRIDE {}
+
+    GrTexture* onCreateTexture(const GrSurfaceDesc& desc,
+                               const void* srcData,
+                               size_t rowBytes) SK_OVERRIDE {
         return NULL;
     }
 
-    virtual GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
-                                                 const void* srcData)  SK_OVERRIDE {
+    GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc,
+                                         const void* srcData) SK_OVERRIDE {
         return NULL;
     }
 
-    virtual GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&)  SK_OVERRIDE {
+    GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&) SK_OVERRIDE { return NULL; }
+
+    GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&) SK_OVERRIDE {
         return NULL;
     }
 
-    virtual GrRenderTarget* onWrapBackendRenderTarget(
-                                    const GrBackendRenderTargetDesc&) SK_OVERRIDE {
-        return NULL;
-    }
+    GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) SK_OVERRIDE { return NULL; }
 
-    virtual GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic)  SK_OVERRIDE {
-        return NULL;
-    }
+    GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) SK_OVERRIDE { return NULL; }
 
-    virtual GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic)  SK_OVERRIDE {
-        return NULL;
-    }
+    void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
+                         bool canIgnoreRect) SK_OVERRIDE {}
 
-    virtual void onClear(GrRenderTarget*, const SkIRect* rect, GrColor color,
-                         bool canIgnoreRect)  SK_OVERRIDE { }
+    void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) SK_OVERRIDE {}
 
-    virtual void onClearStencilClip(GrRenderTarget*,
-                                    const SkIRect& rect,
-                                    bool insideClip)  SK_OVERRIDE { }
+    void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&) SK_OVERRIDE {}
 
-    virtual void onDraw(const GrOptDrawState&, const GrDrawTarget::DrawInfo&)  SK_OVERRIDE { }
-    virtual bool onReadPixels(GrRenderTarget* target,
-                              int left, int top, int width, int height,
-                              GrPixelConfig,
-                              void* buffer,
-                              size_t rowBytes)  SK_OVERRIDE {
+    bool onReadPixels(GrRenderTarget* target,
+                      int left, int top, int width, int height,
+                      GrPixelConfig,
+                      void* buffer,
+                      size_t rowBytes) SK_OVERRIDE {
         return false;
     }
 
-    virtual bool onWriteTexturePixels(GrTexture* texture,
-                                      int left, int top, int width, int height,
-                                      GrPixelConfig config, const void* buffer,
-                                      size_t rowBytes)  SK_OVERRIDE {
+    bool onWriteTexturePixels(GrTexture* texture,
+                              int left, int top, int width, int height,
+                              GrPixelConfig config, const void* buffer,
+                              size_t rowBytes) SK_OVERRIDE {
         return false;
     }
 
-    virtual void onResolveRenderTarget(GrRenderTarget* target)  SK_OVERRIDE {
-        return;
-    }
+    void onResolveRenderTarget(GrRenderTarget* target) SK_OVERRIDE { return; }
 
-    virtual bool createStencilBufferForRenderTarget(GrRenderTarget*, int width,
-                                                    int height) SK_OVERRIDE {
+    bool createStencilBufferForRenderTarget(GrRenderTarget*, int width, int height) SK_OVERRIDE {
         return false;
     }
 
-    virtual bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*)  SK_OVERRIDE {
+    bool attachStencilBufferToRenderTarget(GrStencilBuffer*, GrRenderTarget*) SK_OVERRIDE {
         return false;
     }
 
-    virtual bool flushGraphicsState(const GrOptDrawState&, DrawType)  SK_OVERRIDE {
-        return false;
-    }
+    bool flushGraphicsState(const GrOptDrawState&, DrawType) SK_OVERRIDE { return false; }
 
-    virtual void clearStencil(GrRenderTarget* target)  SK_OVERRIDE  { }
+    void clearStencil(GrRenderTarget* target) SK_OVERRIDE  {}
 
-    virtual void didAddGpuTraceMarker() SK_OVERRIDE { }
-    virtual void didRemoveGpuTraceMarker() SK_OVERRIDE { }
+    void didAddGpuTraceMarker() SK_OVERRIDE { }
+
+    void didRemoveGpuTraceMarker() SK_OVERRIDE { }
 
     typedef GrGpu INHERITED;
 };
 
 GrContext* GrContext::CreateMockContext() {
     GrContext* context = SkNEW_ARGS(GrContext, (Options()));
 
     context->initMockContext();
     return context;
 }
 
 void GrContext::initMockContext() {
     SkASSERT(NULL == fGpu);
     fGpu = SkNEW_ARGS(MockGpu, (this));
     SkASSERT(fGpu);
     this->initCommon();
 
     // We delete these because we want to test the cache starting with zero resources. Also, none of
     // these objects are required for any of tests that use this context. TODO: make stop allocating
     // resources in the buffer pools.
     SkDELETE(fDrawBuffer);
     SkDELETE(fDrawBufferVBAllocPool);
     SkDELETE(fDrawBufferIBAllocPool);
 
     fDrawBuffer = NULL;
     fDrawBufferVBAllocPool = NULL;
     fDrawBufferIBAllocPool = NULL;
 }