Remove debug prints in GrVkGpu

src/gpu/vk/GrVkGpu.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrVkGpu_DEFINED
 #define GrVkGpu_DEFINED
 
@@ skipping 49 matching lines @@
     };
 
     bool onGetReadPixelsInfo(GrSurface* srcSurface, int readWidth, int readHeight, size_t rowBytes,
                              GrPixelConfig readConfig, DrawPreference*,
                              ReadPixelTempDrawInfo*) override;
 
     bool onGetWritePixelsInfo(GrSurface* dstSurface, int width, int height,
                               GrPixelConfig srcConfig, DrawPreference*,
                               WritePixelTempDrawInfo*) override;
 
-    void discard(GrRenderTarget*) override {
-        SkDebugf("discard not yet implemented for Vulkan\n");
-    }
+    void discard(GrRenderTarget*) override {}
 
     bool onCopySurface(GrSurface* dst,
                        GrSurface* src,
                        const SkIRect& srcRect,
                        const SkIPoint& dstPoint) override;
 
     void onGetMultisampleSpecs(GrRenderTarget* rt,
                                const GrStencilSettings&,
                                int* effectiveSampleCnt,
                                SkAutoTDeleteArray<SkPoint>*);
 
     bool initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc) const override {
-        SkDebugf("initCopySurfaceDstDesc not yet implemented for Vulkan\n");
         return false;
     }
 
     void xferBarrier(GrRenderTarget*, GrXferBarrierType) override {}
 
     GrBackendObject createTestingOnlyBackendTexture(void* pixels, int w, int h,
                                                     GrPixelConfig config) override;
     bool isTestingOnlyBackendTexture(GrBackendObject id) const override;
     void deleteTestingOnlyBackendTexture(GrBackendObject id, bool abandonTexture) override;
 
     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
                                                                 int width,
                                                                 int height) override;
 
     void clearStencil(GrRenderTarget* target) override;
 
-    void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {
-        SkDebugf("drawDebugWireRect not yet implemented for Vulkan\n");
-    }
+    void drawDebugWireRect(GrRenderTarget*, const SkIRect&, GrColor) override {}
 
     void addMemoryBarrier(VkPipelineStageFlags srcStageMask,
                           VkPipelineStageFlags dstStageMask,
                           bool byRegion,
                           VkMemoryBarrier* barrier) const;
     void addBufferMemoryBarrier(VkPipelineStageFlags srcStageMask,
                                 VkPipelineStageFlags dstStageMask,
                                 bool byRegion,
                                 VkBufferMemoryBarrier* barrier) const;
     void addImageMemoryBarrier(VkPipelineStageFlags srcStageMask,
@@ skipping 10 matching lines @@
 private:
     GrVkGpu(GrContext* context, const GrContextOptions& options,
             const GrVkBackendContext* backendContext);
 
     void onResetContext(uint32_t resetBits) override {}
 
     GrTexture* onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle,
                                const SkTArray<GrMipLevel>&) override;
 
     GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle,
-                                         const SkTArray<GrMipLevel>&) override {
-        SkDebugf("onCreateCompressedTexture not yet implemented for Vulkan\n");
-        return NULL;
-    }
+                                         const SkTArray<GrMipLevel>&) override { return NULL; }
 
     GrTexture* onWrapBackendTexture(const GrBackendTextureDesc&, GrWrapOwnership) override;
 
     GrRenderTarget* onWrapBackendRenderTarget(const GrBackendRenderTargetDesc&,
                                               GrWrapOwnership) override;
     GrRenderTarget* onWrapBackendTextureAsRenderTarget(const GrBackendTextureDesc&,
-                                                       GrWrapOwnership) override {
-        SkDebugf("onWrapBackendTextureAsRenderTarget not yet implemented for Vulkan\n");
-        return NULL;
-    }
+                                                       GrWrapOwnership) override { return NULL; }
 
     GrVertexBuffer* onCreateVertexBuffer(size_t size, bool dynamic) override;
     GrIndexBuffer* onCreateIndexBuffer(size_t size, bool dynamic) override;
     GrTransferBuffer* onCreateTransferBuffer(size_t size, TransferType type) override;
 
     void onClear(GrRenderTarget*, const SkIRect& rect, GrColor color) override;
 
     void onClearStencilClip(GrRenderTarget*, const SkIRect& rect, bool insideClip) override;
 
     void onDraw(const GrPipeline&,
                 const GrPrimitiveProcessor&,
                 const GrMesh*,
                 int meshCount) override;
 
     bool onReadPixels(GrSurface* surface,
                       int left, int top, int width, int height,
                       GrPixelConfig,
                       void* buffer,
                       size_t rowBytes) override;
 
     bool onWritePixels(GrSurface* surface,
                        int left, int top, int width, int height,
                        GrPixelConfig config, const SkTArray<GrMipLevel>&) override;
 
     bool onTransferPixels(GrSurface*,
                           int left, int top, int width, int height,
                           GrPixelConfig config, GrTransferBuffer* buffer,
-                          size_t offset, size_t rowBytes) override {
-        SkDebugf("onTransferPixels not yet implemented for Vulkan\n");
-        return false;
-    }
+                          size_t offset, size_t rowBytes) override { return false; }
 
-    void onResolveRenderTarget(GrRenderTarget* target) override {
-        SkDebugf("onResolveRenderTarget not yet implemented for Vulkan\n");
-    }
+    void onResolveRenderTarget(GrRenderTarget* target) override {}
 
     bool prepareDrawState(const GrPipeline&,
                           const GrPrimitiveProcessor&,
                           GrPrimitiveType,
                           const GrVkRenderPass&,
                           GrVkPipelineState** pipelineState);
 
     // Bind vertex and index buffers
     void bindGeometry(const GrPrimitiveProcessor&, const GrNonInstancedMesh&);
 
@@ skipping 41 matching lines @@
 
     // Shaderc compiler used for compiling glsl in spirv. We only want to create the compiler once
     // since there is significant overhead to the first compile of any compiler.
     shaderc_compiler_t fCompiler;
 
 
     typedef GrGpu INHERITED;
 };
 
 #endif