refactor: Use clang-tidy on layers/*.cpp files

This change was automatically generated with the following clang-tidy
checks:

- -*
- google*
- readability-identifier-naming
- -google-readability-todo

Plus the following check options:
- readability-identifier-naming.VariableCase
- readability-identifier-naming.GlobalConstantCase
- readability-identifier-naming.GlobalConstantPrefix

Plus the following "one-time regex fixups":
- s/(^+.*\W)p_(semaphore|fence|cb|queue)(\W)/\1\2_state\3/g: fix
  duplicate variable names
- s/(^+.*\W)p_([a-z])/\1\2/g: fix non-function-parameter variable names
  with p prefix

Change-Id: I518ef21643e1850f9dd5539d5fb5e039ce31eeb5

Author: ncesario-lunarg

.clang-tidy

@@ -0,0 +1,5 @@
+Checks: '-*,google*,readability-identifier-naming,-google-readability-todo'
+CheckOptions:
+  - { key: readability-identifier-naming.VariableCase,  value: lower_case }
+  - { key: readability-identifier-naming.GlobalConstantCase,  value: CamelCase }
+  - { key: readability-identifier-naming.GlobalConstantPrefix,  value: k }

layers/best_practices_utils.cpp

@@ -188,30 +188,30 @@ void ConvertVkRenderPassCreateInfoToV2KHR(const VkRenderPassCreateInfo& in_struc
         for (uint32_t i = 0; i < input_attachment_aspect_info->aspectReferenceCount; ++i) {
             const uint32_t subpass = input_attachment_aspect_info->pAspectReferences[i].subpass;
             const uint32_t input_attachment = input_attachment_aspect_info->pAspectReferences[i].inputAttachmentIndex;
-            const VkImageAspectFlags aspectMask = input_attachment_aspect_info->pAspectReferences[i].aspectMask;
+            const VkImageAspectFlags aspect_mask = input_attachment_aspect_info->pAspectReferences[i].aspectMask;
 
             if (subpass < input_attachment_aspect_masks.size() &&
                 input_attachment < input_attachment_aspect_masks[subpass].size()) {
-                input_attachment_aspect_masks[subpass][input_attachment] = aspectMask;
+                input_attachment_aspect_masks[subpass][input_attachment] = aspect_mask;
             }
         }
     }
 
-    const bool has_viewMask = multiview_info && multiview_info->subpassCount && multiview_info->pViewMasks;
+    const bool has_view_mask = multiview_info && multiview_info->subpassCount && multiview_info->pViewMasks;
     if (out_struct->subpassCount && in_struct.pSubpasses) {
         out_struct->pSubpasses = new safe_VkSubpassDescription2[out_struct->subpassCount];
         for (uint32_t i = 0; i < out_struct->subpassCount; ++i) {
-            const uint32_t viewMask = has_viewMask ? multiview_info->pViewMasks[i] : 0;
-            out_struct->pSubpasses[i] = ToV2KHR(in_struct.pSubpasses[i], viewMask, input_attachment_aspect_masks[i].data());
+            const uint32_t view_mask = has_view_mask ? multiview_info->pViewMasks[i] : 0;
+            out_struct->pSubpasses[i] = ToV2KHR(in_struct.pSubpasses[i], view_mask, input_attachment_aspect_masks[i].data());
         }
     }
 
-    const bool has_viewOffset = multiview_info && multiview_info->dependencyCount && multiview_info->pViewOffsets;
+    const bool has_view_offset = multiview_info && multiview_info->dependencyCount && multiview_info->pViewOffsets;
     if (out_struct->dependencyCount && in_struct.pDependencies) {
         out_struct->pDependencies = new safe_VkSubpassDependency2[out_struct->dependencyCount];
         for (uint32_t i = 0; i < out_struct->dependencyCount; ++i) {
-            const int32_t viewOffset = has_viewOffset ? multiview_info->pViewOffsets[i] : 0;
-            out_struct->pDependencies[i] = ToV2KHR(in_struct.pDependencies[i], viewOffset);
+            const int32_t view_offset = has_view_offset ? multiview_info->pViewOffsets[i] : 0;
+            out_struct->pDependencies[i] = ToV2KHR(in_struct.pDependencies[i], view_offset);
         }
     }
 

layers/buffer_validation.cpp

@@ -285,7 +285,7 @@ bool DebugPrintf::InstrumentShader(const VkShaderModuleCreateInfo *pCreateInfo,
     opt_options.set_run_validator(true);
     opt_options.set_validator_options(val_options);
     Optimizer optimizer(target_env);
-    const spvtools::MessageConsumer DebugPrintfConsoleMessageConsumer =
+    const spvtools::MessageConsumer debug_printf_console_message_consumer =
         [this](spv_message_level_t level, const char *, const spv_position_t &position, const char *message) -> void {
         switch (level) {
             case SPV_MSG_FATAL:
@@ -298,7 +298,7 @@ bool DebugPrintf::InstrumentShader(const VkShaderModuleCreateInfo *pCreateInfo,
                 break;
         }
     };
-    optimizer.SetMessageConsumer(DebugPrintfConsoleMessageConsumer);
+    optimizer.SetMessageConsumer(debug_printf_console_message_consumer);
     optimizer.RegisterPass(CreateInstDebugPrintfPass(desc_set_bind_index, unique_shader_module_id));
     bool pass = optimizer.Run(new_pgm.data(), new_pgm.size(), &new_pgm, opt_options);
     if (!pass) {
@@ -372,10 +372,10 @@ std::vector<DPFSubstring> DebugPrintf::ParseFormatString(const std::string forma
         }
         // Find the type of the value
         pos = format_string.find_first_of(types, pos);
-        if (pos == format_string.npos)
+        if (pos == format_string.npos) {
             // This really shouldn't happen with a legal value string
             pos = format_string.length();
-        else {
+        } else {
             char tempstring[32];
             int count = 0;
             std::string specifier = {};
@@ -537,13 +537,14 @@ void DebugPrintf::AnalyzeAndGenerateMessages(VkCommandBuffer command_buffer, VkQ
                             break;
                     }
                     values = static_cast<uint32_t *>(values) + 1;
-                } else
+                } else {
                     needed = snprintf(temp_string, static_size, substring.string.c_str());
+                }
             }
 
-            if (needed < static_size)
+            if (needed < static_size) {
                 shader_message << temp_string;
-            else {
+            } else {
                 // Static buffer not big enough for message, use malloc to get enough
                 snprintf_with_malloc(shader_message, substring, needed, values);
             }
@@ -601,8 +602,8 @@ void DebugPrintf::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount,
         for (uint32_t i = 0; i < submit->commandBufferCount; i++) {
             auto cb_node = GetCBState(submit->pCommandBuffers[i]);
             if (GetBufferInfo(cb_node->commandBuffer).size()) buffers_present = true;
-            for (auto secondaryCmdBuffer : cb_node->linkedCommandBuffers) {
-                if (GetBufferInfo(secondaryCmdBuffer->commandBuffer).size()) buffers_present = true;
+            for (auto secondary_cmd_buffer : cb_node->linkedCommandBuffers) {
+                if (GetBufferInfo(secondary_cmd_buffer->commandBuffer).size()) buffers_present = true;
             }
         }
     }
@@ -617,8 +618,8 @@ void DebugPrintf::PostCallRecordQueueSubmit(VkQueue queue, uint32_t submitCount,
         for (uint32_t i = 0; i < submit->commandBufferCount; i++) {
             auto cb_node = GetCBState(submit->pCommandBuffers[i]);
             UtilProcessInstrumentationBuffer(queue, cb_node, this);
-            for (auto secondaryCmdBuffer : cb_node->linkedCommandBuffers) {
-                UtilProcessInstrumentationBuffer(queue, secondaryCmdBuffer, this);
+            for (auto secondary_cmd_buffer : cb_node->linkedCommandBuffers) {
+                UtilProcessInstrumentationBuffer(queue, secondary_cmd_buffer, this);
             }
         }
     }
@@ -814,23 +815,23 @@ void DebugPrintf::AllocateDebugPrintfResources(const VkCommandBuffer cmd_buffer,
 
     // Allocate memory for the output block that the gpu will use to return values for printf
     DPFDeviceMemoryBlock output_block = {};
-    VkBufferCreateInfo bufferInfo = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
-    bufferInfo.size = output_buffer_size;
-    bufferInfo.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
-    VmaAllocationCreateInfo allocInfo = {};
-    allocInfo.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
-    result = vmaCreateBuffer(vmaAllocator, &bufferInfo, &allocInfo, &output_block.buffer, &output_block.allocation, nullptr);
+    VkBufferCreateInfo buffer_info = {VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO};
+    buffer_info.size = output_buffer_size;
+    buffer_info.usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT;
+    VmaAllocationCreateInfo alloc_info = {};
+    alloc_info.usage = VMA_MEMORY_USAGE_GPU_TO_CPU;
+    result = vmaCreateBuffer(vmaAllocator, &buffer_info, &alloc_info, &output_block.buffer, &output_block.allocation, nullptr);
     if (result != VK_SUCCESS) {
         ReportSetupProblem(device, "Unable to allocate device memory.  Device could become unstable.");
         aborted = true;
         return;
     }
 
     // Clear the output block to zeros so that only printf values from the gpu will be present
-    uint32_t *pData;
-    result = vmaMapMemory(vmaAllocator, output_block.allocation, (void **)&pData);
+    uint32_t *data;
+    result = vmaMapMemory(vmaAllocator, output_block.allocation, reinterpret_cast<void **>(&data));
     if (result == VK_SUCCESS) {
-        memset(pData, 0, output_buffer_size);
+        memset(data, 0, output_buffer_size);
         vmaUnmapMemory(vmaAllocator, output_block.allocation);
     }