Style bikeshed - remove extraneous whitespace

src/gpu/vk/GrVkGpu.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrVkGpu.h"
 
 #include "GrContextOptions.h"
@@ skipping 61 matching lines @@
         }
     } else {
         vkBackendContext->ref();
     }
 
     return new GrVkGpu(context, options, vkBackendContext);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-GrVkGpu::GrVkGpu(GrContext* context, const GrContextOptions& options, 
+GrVkGpu::GrVkGpu(GrContext* context, const GrContextOptions& options,
                  const GrVkBackendContext* backendCtx)
     : INHERITED(context)
     , fVkInstance(backendCtx->fInstance)
     , fDevice(backendCtx->fDevice)
     , fQueue(backendCtx->fQueue)
     , fResourceProvider(this) {
     fBackendContext.reset(backendCtx);
 
 #ifdef ENABLE_VK_LAYERS
     if (backendCtx->fExtensions & kEXT_debug_report_GrVkExtensionFlag) {
@@ skipping 22 matching lines @@
     fCaps.reset(SkRef(fVkCaps.get()));
 
     VK_CALL(GetPhysicalDeviceMemoryProperties(backendCtx->fPhysicalDevice, &fPhysDevMemProps));
 
     const VkCommandPoolCreateInfo cmdPoolInfo = {
         VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // sType
         nullptr,                                    // pNext
         VK_COMMAND_POOL_CREATE_TRANSIENT_BIT,       // CmdPoolCreateFlags
         backendCtx->fQueueFamilyIndex,              // queueFamilyIndex
     };
-    GR_VK_CALL_ERRCHECK(this->vkInterface(), CreateCommandPool(fDevice, &cmdPoolInfo, nullptr, 
+    GR_VK_CALL_ERRCHECK(this->vkInterface(), CreateCommandPool(fDevice, &cmdPoolInfo, nullptr,
                                                                &fCmdPool));
 
     // must call this after creating the CommandPool
     fResourceProvider.init();
     fCurrentCmdBuffer = fResourceProvider.createCommandBuffer();
     SkASSERT(fCurrentCmdBuffer);
     fCurrentCmdBuffer->begin(this);
 }
 
 GrVkGpu::~GrVkGpu() {
     fCurrentCmdBuffer->end(this);
     fCurrentCmdBuffer->unref(this);
 
     // wait for all commands to finish
     fResourceProvider.checkCommandBuffers();
     SkDEBUGCODE(VkResult res =) VK_CALL(QueueWaitIdle(fQueue));
     // VK_ERROR_DEVICE_LOST is acceptable when tearing down (see 4.2.4 in spec)
     SkASSERT(VK_SUCCESS == res || VK_ERROR_DEVICE_LOST == res);
- 
+
     // must call this just before we destroy the VkDevice
     fResourceProvider.destroyResources();
 
     VK_CALL(DestroyCommandPool(fDevice, fCmdPool, nullptr));
 
     shaderc_compiler_release(fCompiler);
 
 #ifdef ENABLE_VK_LAYERS
     VK_CALL(DestroyDebugReportCallbackEXT(fVkInstance, fCallback, nullptr));
 #endif
@@ skipping 46 matching lines @@
     if (kIndex_8_GrPixelConfig == srcConfig || GrPixelConfigIsCompressed(dstSurface->config())) {
         return false;
     }
 
     // Currently we don't handle draws, so if the caller wants/needs to do a draw we need to fail
     if (kNoDraw_DrawPreference != *drawPreference) {
         return false;
     }
 
     if (dstSurface->config() != srcConfig) {
-        // TODO: This should fall back to drawing or copying to change config of dstSurface to 
+        // TODO: This should fall back to drawing or copying to change config of dstSurface to
         // match that of srcConfig.
         return false;
     }
 
     return true;
 }
 
 bool GrVkGpu::onWritePixels(GrSurface* surface,
                             int left, int top, int width, int height,
                             GrPixelConfig config,
@@ skipping 90 matching lines @@
         GR_VK_CALL(interface, GetImageSubresourceLayout(fDevice,
                                                         tex->textureImage(),
                                                         &subres,
                                                         &layout));
 
         int texTop = kBottomLeft_GrSurfaceOrigin == desc.fOrigin ? tex->height() - top - height
                                                                     : top;
         VkDeviceSize offset = texTop*layout.rowPitch + left*bpp;
         VkDeviceSize size = height*layout.rowPitch;
         void* mapPtr;
-        err = GR_VK_CALL(interface, MapMemory(fDevice, tex->textureMemory(), offset, size, 0, 
+        err = GR_VK_CALL(interface, MapMemory(fDevice, tex->textureMemory(), offset, size, 0,
                                                 &mapPtr));
         if (err) {
             return false;
         }
 
         if (kBottomLeft_GrSurfaceOrigin == desc.fOrigin) {
             // copy into buffer by rows
             const char* srcRow = reinterpret_cast<const char*>(data);
             char* dstRow = reinterpret_cast<char*>(mapPtr)+(height - 1)*layout.rowPitch;
             for (int y = 0; y < height; y++) {
@@ skipping 216 matching lines @@
     surfDesc.fHeight = desc.fHeight;
     surfDesc.fConfig = desc.fConfig;
     surfDesc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
     bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag);
     // In GL, Chrome assumes all textures are BottomLeft
     // In VK, we don't have this restriction
     surfDesc.fOrigin = resolve_origin(desc.fOrigin);
 
     GrVkTexture* texture = nullptr;
     if (renderTarget) {
-        texture = GrVkTextureRenderTarget::CreateWrappedTextureRenderTarget(this, surfDesc, 
+        texture = GrVkTextureRenderTarget::CreateWrappedTextureRenderTarget(this, surfDesc,
                                                                             lifeCycle, format,
                                                                             info);
     } else {
-        texture = GrVkTexture::CreateWrappedTexture(this, surfDesc, lifeCycle, format, 
+        texture = GrVkTexture::CreateWrappedTexture(this, surfDesc, lifeCycle, format,
                                                     info);
     }
     if (!texture) {
         return nullptr;
     }
 
     return texture;
 }
 
 GrRenderTarget* GrVkGpu::onWrapBackendRenderTarget(const GrBackendRenderTargetDesc& wrapDesc,
                                                    GrWrapOwnership ownership) {
-    
+
     const GrVkTextureInfo* info =
         reinterpret_cast<const GrVkTextureInfo*>(wrapDesc.fRenderTargetHandle);
     if (VK_NULL_HANDLE == info->fImage ||
         (VK_NULL_HANDLE == info->fAlloc && kAdopt_GrWrapOwnership == ownership)) {
         return nullptr;
     }
 
     GrGpuResource::LifeCycle lifeCycle = (kAdopt_GrWrapOwnership == ownership)
                                          ? GrGpuResource::kAdopted_LifeCycle
                                          : GrGpuResource::kBorrowed_LifeCycle;
 
     GrSurfaceDesc desc;
     desc.fConfig = wrapDesc.fConfig;
     desc.fFlags = kCheckAllocation_GrSurfaceFlag;
     desc.fWidth = wrapDesc.fWidth;
     desc.fHeight = wrapDesc.fHeight;
     desc.fSampleCnt = SkTMin(wrapDesc.fSampleCnt, this->caps()->maxSampleCount());
 
     desc.fOrigin = resolve_origin(wrapDesc.fOrigin);
 
     GrVkRenderTarget* tgt = GrVkRenderTarget::CreateWrappedRenderTarget(this, desc,
-                                                                        lifeCycle, 
+                                                                        lifeCycle,
                                                                         info);
     if (tgt && wrapDesc.fStencilBits) {
         if (!createStencilAttachmentForRenderTarget(tgt, desc.fWidth, desc.fHeight)) {
             tgt->unref();
             return nullptr;
         }
     }
     return tgt;
 }
 
@@ skipping 360 matching lines @@
 
     return;
 }
 
 void GrVkGpu::onClear(GrRenderTarget* target, const SkIRect& rect, GrColor color) {
     // parent class should never let us get here with no RT
     SkASSERT(target);
 
     VkClearColorValue vkColor;
     GrColorToRGBAFloat(color, vkColor.float32);
-   
+
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(target);
     VkImageLayout origDstLayout = vkRT->currentLayout();
 
     if (rect.width() != target->width() || rect.height() != target->height()) {
         VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);
         VkAccessFlags dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
         VkPipelineStageFlags srcStageMask =
             GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
         VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
         vkRT->setImageLayout(this,
@@ skipping 49 matching lines @@
 
 
     VkImageSubresourceRange subRange;
     memset(&subRange, 0, sizeof(VkImageSubresourceRange));
     subRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     subRange.baseMipLevel = 0;
     subRange.levelCount = 1;
     subRange.baseArrayLayer = 0;
     subRange.layerCount = 1;
 
-    // In the future we may not actually be doing this type of clear at all. If we are inside a 
+    // In the future we may not actually be doing this type of clear at all. If we are inside a
     // render pass or doing a non full clear then we will use CmdClearColorAttachment. The more
     // common use case will be clearing an attachment at the start of a render pass, in which case
     // we will use the clear load ops.
     fCurrentCmdBuffer->clearColorImage(this,
                                        vkRT,
                                        &vkColor,
                                        1, &subRange);
 }
 
 inline bool can_copy_image(const GrSurface* dst,
@@ skipping 25 matching lines @@
     VkImageLayout origDstLayout = dstTex->currentLayout();
     VkImageLayout origSrcLayout = srcTex->currentLayout();
 
     VkPipelineStageFlags srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origDstLayout);
     VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
 
     // These flags are for flushing/invalidating caches and for the dst image it doesn't matter if
     // the cache is flushed since it is only being written to.
     VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origDstLayout);;
     VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
-    
+
     dstTex->setImageLayout(this,
                            VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                            srcAccessMask,
                            dstAccessMask,
                            srcStageMask,
                            dstStageMask,
                            false);
-    
+
     srcStageMask = GrVkMemory::LayoutToPipelineStageFlags(origSrcLayout);
     dstStageMask = VK_PIPELINE_STAGE_TRANSFER_BIT;
 
     srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(origSrcLayout);
     dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
 
     srcTex->setImageLayout(this,
                            VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                            srcAccessMask,
                            dstAccessMask,
@@ skipping 105 matching lines @@
     VkAccessFlags srcAccessMask = GrVkMemory::LayoutToSrcAccessMask(layout);
     VkAccessFlags dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
     tgt->setImageLayout(this,
                         VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                         srcAccessMask,
                         dstAccessMask,
                         srcStageMask,
                         dstStageMask,
                         false);
 
-    GrVkTransferBuffer* transferBuffer = 
+    GrVkTransferBuffer* transferBuffer =
         static_cast<GrVkTransferBuffer*>(this->createBuffer(kXferGpuToCpu_GrBufferType,
                                                             rowBytes * height,
                                                             kStream_GrAccessPattern));
 
     bool flipY = kBottomLeft_GrSurfaceOrigin == surface->origin();
     VkOffset3D offset = {
         left,
         flipY ? surface->height() - top - height : top,
         0
     };
@@ skipping 195 matching lines @@
     aglSwapBuffers(aglGetCurrentContext());
     int set_a_break_pt_here = 9;
     aglSwapBuffers(aglGetCurrentContext());
 #elif defined(SK_BUILD_FOR_WIN32)
     SwapBuf();
     int set_a_break_pt_here = 9;
     SwapBuf();
 #endif
 #endif
 }
-