Get Vk compiling post-MIP map changes

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 241 matching lines @@
         // 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, const void* buffer,
-                            size_t rowBytes) {
+                            GrPixelConfig config,
+                            const SkTArray<GrMipLevel>& texels) {
     GrVkTexture* vkTex = static_cast<GrVkTexture*>(surface->asTexture());
     if (!vkTex) {
         return false;
     }
 
+    // TODO: We're ignoring MIP levels here.
+
     // We assume Vulkan doesn't do sRGB <-> linear conversions when reading and writing pixels.
     if (GrPixelConfigIsSRGB(surface->config()) != GrPixelConfigIsSRGB(config)) {
         return false;
     }
 
     bool success = false;
     if (GrPixelConfigIsCompressed(vkTex->desc().fConfig)) {
         // We check that config == desc.fConfig in GrGpu::getWritePixelsInfo()
         SkASSERT(config == vkTex->desc().fConfig);
         // TODO: add compressed texture support
@@ skipping 13 matching lines @@
             VkAccessFlags dstAccessMask = VK_ACCESS_HOST_WRITE_BIT;
             vkTex->setImageLayout(this,
                                   VK_IMAGE_LAYOUT_GENERAL,
                                   srcAccessMask,
                                   dstAccessMask,
                                   srcStageMask,
                                   dstStageMask,
                                   false);
         }
         success = this->uploadTexData(vkTex, left, top, width, height, config,
-                                      buffer, rowBytes);
+                                      texels.begin()->fPixels, texels.begin()->fRowBytes);
     }
 
     if (success) {
         vkTex->texturePriv().dirtyMipMaps(true);
         return true;
     }
 
     return false;
 }
 
@@ skipping 144 matching lines @@
         this->submitCommandBuffer(kSkip_SyncQueue);
 
         transferBuffer->unref();
     }
 
     return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 GrTexture* GrVkGpu::onCreateTexture(const GrSurfaceDesc& desc, GrGpuResource::LifeCycle lifeCycle,
-                                    const void* srcData, size_t rowBytes) {
+                                    const SkTArray<GrMipLevel>& texels) {
     bool renderTarget = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
 
     VkFormat pixelFormat;
     if (!GrPixelConfigToVkFormat(desc.fConfig, &pixelFormat)) {
         return nullptr;
     }
 
     if (!fVkCaps->isConfigTexturable(desc.fConfig)) {
         return nullptr;
     }
@@ skipping 14 matching lines @@
     }
 
     // For now we will set the VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT and
     // VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT on every texture since we do not know whether or not we
     // will be using this texture in some copy or not. Also this assumes, as is the current case,
     // that all render targets in vulkan are also texutres. If we change this practice of setting
     // both bits, we must make sure to set the destination bit if we are uploading srcData to the
     // texture.
     usageFlags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
 
-    VkFlags memProps = (srcData && linearTiling) ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
-                                                   VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
+    VkFlags memProps = (!texels.empty() && linearTiling) ? VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT :
+                                                           VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
 
     // This ImageDesc refers to the texture that will be read by the client. Thus even if msaa is
     // requested, this ImageDesc describes the resolved texutre. Therefore we always have samples set
     // to 1.
     GrVkImage::ImageDesc imageDesc;
     imageDesc.fImageType = VK_IMAGE_TYPE_2D;
     imageDesc.fFormat = pixelFormat;
     imageDesc.fWidth = desc.fWidth;
     imageDesc.fHeight = desc.fHeight;
     imageDesc.fLevels = 1;
@@ skipping 13 matching lines @@
         this->clear(rect, GrColor_TRANSPARENT_BLACK, tex->asRenderTarget());
 #endif
     } else {
         tex = GrVkTexture::CreateNewTexture(this, desc, lifeCycle, imageDesc);
     }
 
     if (!tex) {
         return nullptr;
     }
 
-    if (srcData) {
-        if (!this->uploadTexData(tex, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig, srcData,
-                                 rowBytes)) {
+    // TODO: We're ignoring MIP levels here.
+    if (!texels.empty()) {
+        if (!this->uploadTexData(tex, 0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+                                 texels.begin()->fPixels, texels.begin()->fRowBytes)) {
             tex->unref();
             return nullptr;
         }
     }
 
     return tex;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ skipping 852 matching lines @@
     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
 }