got Vulkan compiling on Linux again

src/gpu/vk/GrVkBackendContext.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 "vk/GrVkBackendContext.h"
 #include "vk/GrVkExtensions.h"
 #include "vk/GrVkInterface.h"
@@ skipping 41 matching lines @@
         kGrVkMinimumVersion,                // apiVersion
     };
 
     GrVkExtensions extensions;
     extensions.initInstance(kGrVkMinimumVersion);
 
     SkTArray<const char*> instanceLayerNames;
     SkTArray<const char*> instanceExtensionNames;
     uint32_t extensionFlags = 0;
 #ifdef ENABLE_VK_LAYERS
-    for (int i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
+    for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
         if (extensions.hasInstanceLayer(kDebugLayerNames[i])) {
             instanceLayerNames.push_back(kDebugLayerNames[i]);
         }
     }
     if (extensions.hasInstanceExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME)) {
         instanceExtensionNames.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
         extensionFlags |= kEXT_debug_report_GrVkExtensionFlag;
     }
 #endif
 
     const VkInstanceCreateInfo instance_create = {
-        VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, // sType
-        nullptr,                                // pNext
-        0,                                      // flags
-        &app_info,                              // pApplicationInfo
-        instanceLayerNames.count(),             // enabledLayerNameCount
-        instanceLayerNames.begin(),             // ppEnabledLayerNames
-        instanceExtensionNames.count(),         // enabledExtensionNameCount
-        instanceExtensionNames.begin(),         // ppEnabledExtensionNames
+        VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,    // sType
+        nullptr,                                   // pNext
+        0,                                         // flags
+        &app_info,                                 // pApplicationInfo
+        (uint32_t) instanceLayerNames.count(),     // enabledLayerNameCount
+        instanceLayerNames.begin(),                // ppEnabledLayerNames
+        (uint32_t) instanceExtensionNames.count(), // enabledExtensionNameCount
+        instanceExtensionNames.begin(),            // ppEnabledExtensionNames
     };
 
     err = vkCreateInstance(&instance_create, nullptr, &inst);
     if (err < 0) {
         SkDebugf("vkCreateInstance failed: %d\n", err);
         SkFAIL("failing");
     }
 
     uint32_t gpuCount;
     err = vkEnumeratePhysicalDevices(inst, &gpuCount, nullptr);
@@ skipping 30 matching lines @@
             break;
         }
     }
     SkASSERT(graphicsQueueIndex < queueCount);
 
     extensions.initDevice(kGrVkMinimumVersion, inst, physDev);
 
     SkTArray<const char*> deviceLayerNames;
     SkTArray<const char*> deviceExtensionNames;
 #ifdef ENABLE_VK_LAYERS
-    for (int i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
+    for (size_t i = 0; i < SK_ARRAY_COUNT(kDebugLayerNames); ++i) {
         if (extensions.hasDeviceLayer(kDebugLayerNames[i])) {
             deviceLayerNames.push_back(kDebugLayerNames[i]);
         }
     }
 #endif
     if (extensions.hasDeviceExtension("VK_NV_glsl_shader")) {
         deviceExtensionNames.push_back("VK_NV_glsl_shader");
         extensionFlags |= kNV_glsl_shader_GrVkExtensionFlag;
     }
 
@@ skipping 20 matching lines @@
     // If one is needed, the client will need its own setup code
     const VkDeviceQueueCreateInfo queueInfo = {
         VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, // sType
         nullptr,                                    // pNext
         0,                                          // VkDeviceQueueCreateFlags
         graphicsQueueIndex,                         // queueFamilyIndex
         1,                                          // queueCount
         queuePriorities,                            // pQueuePriorities
     };
     const VkDeviceCreateInfo deviceInfo = {
-        VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,  // sType
-        nullptr,                               // pNext
-        0,                                     // VkDeviceCreateFlags
-        1,                                     // queueCreateInfoCount
-        &queueInfo,                            // pQueueCreateInfos
-        deviceLayerNames.count(),              // layerCount
-        deviceLayerNames.begin(),              // ppEnabledLayerNames
-        deviceExtensionNames.count(),          // extensionCount
-        deviceExtensionNames.begin(),          // ppEnabledExtensionNames
-        &deviceFeatures                        // ppEnabledFeatures
+        VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,    // sType
+        nullptr,                                 // pNext
+        0,                                       // VkDeviceCreateFlags
+        1,                                       // queueCreateInfoCount
+        &queueInfo,                              // pQueueCreateInfos
+        (uint32_t) deviceLayerNames.count(),     // layerCount
+        deviceLayerNames.begin(),                // ppEnabledLayerNames
+        (uint32_t) deviceExtensionNames.count(), // extensionCount
+        deviceExtensionNames.begin(),            // ppEnabledExtensionNames
+        &deviceFeatures                          // ppEnabledFeatures
     };
 
     err = vkCreateDevice(physDev, &deviceInfo, nullptr, &device);
     if (err) {
         SkDebugf("CreateDevice failed: %d\n", err);
         return nullptr;
     }
 
     VkQueue queue;
     vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);
@@ skipping 11 matching lines @@
   
     return ctx;
 }
 
 GrVkBackendContext::~GrVkBackendContext() {
     vkDestroyDevice(fDevice, nullptr);
     fDevice = VK_NULL_HANDLE;
     vkDestroyInstance(fInstance, nullptr);
     fInstance = VK_NULL_HANDLE;
 }