Vulkan: Refactor SecondaryCommandBuffers class

A strictly cosmetic change to move code into alphabetical order.
In working with SecondaryCommandBuffer commands in separate CLs,
it can be difficult/annoying to track which commands are already
in place as some of them are out-of-order. This change puts the
command enums, functions, and processing in alphabetical order
to simplify searching and adding new commands.

Bug: b/154030403
Change-Id: I6dba4cf48d6f27c056585ac633c694e083b1a263
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2158816
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Tobin Ehlis <tobine@google.com>

2 files changed, 242 insertions, 247 deletions

diff --git a/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.cpp b/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.cpp
index 4bf6ba46a0..e0d67cee1e 100644
--- a/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.cpp
+++ b/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.cpp
@@ -27,6 +27,8 @@ const char *GetCommandString(CommandID id)
             return "--Invalid--";
         case CommandID::BeginQuery:
             return "BeginQuery";
+        case CommandID::BeginTransformFeedback:
+            return "BeginTransformFeedback";
         case CommandID::BindComputePipeline:
             return "BindComputePipeline";
         case CommandID::BindDescriptorSets:
@@ -35,10 +37,10 @@ const char *GetCommandString(CommandID id)
             return "BindGraphicsPipeline";
         case CommandID::BindIndexBuffer:
             return "BindIndexBuffer";
-        case CommandID::BindVertexBuffers:
-            return "BindVertexBuffers";
         case CommandID::BindTransformFeedbackBuffers:
             return "BindTransformFeedbackBuffers";
+        case CommandID::BindVertexBuffers:
+            return "BindVertexBuffers";
         case CommandID::BlitImage:
             return "BlitImage";
         case CommandID::BufferBarrier:
@@ -67,22 +69,24 @@ const char *GetCommandString(CommandID id)
             return "DrawIndexed";
         case CommandID::DrawIndexedBaseVertex:
             return "DrawIndexedBaseVertex";
+        case CommandID::DrawIndexedIndirect:
+            return "DrawIndexedIndirect";
         case CommandID::DrawIndexedInstanced:
             return "DrawIndexedInstanced";
         case CommandID::DrawIndexedInstancedBaseVertex:
             return "DrawIndexedInstancedBaseVertex";
         case CommandID::DrawIndexedInstancedBaseVertexBaseInstance:
             return "DrawIndexedInstancedBaseVertexBaseInstance";
+        case CommandID::DrawIndirect:
+            return "DrawIndirect";
         case CommandID::DrawInstanced:
             return "DrawInstanced";
         case CommandID::DrawInstancedBaseInstance:
             return "DrawInstancedBaseInstance";
-        case CommandID::DrawIndexedIndirect:
-            return "DrawIndexedIndirect";
-        case CommandID::DrawIndirect:
-            return "DrawIndirect";
         case CommandID::EndQuery:
             return "EndQuery";
+        case CommandID::EndTransformFeedback:
+            return "EndTransformFeedback";
         case CommandID::ExecutionBarrier:
             return "ExecutionBarrier";
         case CommandID::FillBuffer:
@@ -107,10 +111,6 @@ const char *GetCommandString(CommandID id)
             return "WaitEvents";
         case CommandID::WriteTimestamp:
             return "WriteTimestamp";
-        case CommandID::BeginTransformFeedback:
-            return "BeginTransformFeedback";
-        case CommandID::EndTransformFeedback:
-            return "EndTransformFeedback";
         default:
             // Need this to work around MSVC warning 4715.
             UNREACHABLE();
@@ -141,6 +141,20 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
                     vkCmdBeginQuery(cmdBuffer, params->queryPool, params->query, params->flags);
                     break;
                 }
+                case CommandID::BeginTransformFeedback:
+                {
+                    const BeginTransformFeedbackParams *params =
+                        getParamPtr<BeginTransformFeedbackParams>(currentCommand);
+                    const VkBuffer *counterBuffers =
+                        Offset<VkBuffer>(params, sizeof(BeginTransformFeedbackParams));
+                    // Workaround for AMD driver bug where it expects the offsets array to be
+                    // non-null
+                    gl::TransformFeedbackBuffersArray<VkDeviceSize> offsets;
+                    offsets.fill(0);
+                    vkCmdBeginTransformFeedbackEXT(cmdBuffer, 0, params->bufferCount,
+                                                   counterBuffers, offsets.data());
+                    break;
+                }
                 case CommandID::BindComputePipeline:
                 {
                     const BindPipelineParams *params =
@@ -311,6 +325,13 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
                     vkCmdDrawIndexed(cmdBuffer, params->indexCount, 1, 0, params->vertexOffset, 0);
                     break;
                 }
+                case CommandID::DrawIndexedIndirect:
+                {
+                    const DrawIndexedIndirectParams *params =
+                        getParamPtr<DrawIndexedIndirectParams>(currentCommand);
+                    vkCmdDrawIndexedIndirect(cmdBuffer, params->buffer, params->offset, 1, 0);
+                    break;
+                }
                 case CommandID::DrawIndexedInstanced:
                 {
                     const DrawIndexedInstancedParams *params =
@@ -336,6 +357,13 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
                                      params->firstInstance);
                     break;
                 }
+                case CommandID::DrawIndirect:
+                {
+                    const DrawIndirectParams *params =
+                        getParamPtr<DrawIndirectParams>(currentCommand);
+                    vkCmdDrawIndirect(cmdBuffer, params->buffer, params->offset, 1, 0);
+                    break;
+                }
                 case CommandID::DrawInstanced:
                 {
                     const DrawInstancedParams *params =
@@ -352,26 +380,26 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
                               params->firstVertex, params->firstInstance);
                     break;
                 }
-                case CommandID::DrawIndirect:
-                {
-                    const DrawIndirectParams *params =
-                        getParamPtr<DrawIndirectParams>(currentCommand);
-                    vkCmdDrawIndirect(cmdBuffer, params->buffer, params->offset, 1, 0);
-                    break;
-                }
-                case CommandID::DrawIndexedIndirect:
-                {
-                    const DrawIndexedIndirectParams *params =
-                        getParamPtr<DrawIndexedIndirectParams>(currentCommand);
-                    vkCmdDrawIndexedIndirect(cmdBuffer, params->buffer, params->offset, 1, 0);
-                    break;
-                }
                 case CommandID::EndQuery:
                 {
                     const EndQueryParams *params = getParamPtr<EndQueryParams>(currentCommand);
                     vkCmdEndQuery(cmdBuffer, params->queryPool, params->query);
                     break;
                 }
+                case CommandID::EndTransformFeedback:
+                {
+                    const EndTransformFeedbackParams *params =
+                        getParamPtr<EndTransformFeedbackParams>(currentCommand);
+                    const VkBuffer *counterBuffers =
+                        Offset<VkBuffer>(params, sizeof(EndTransformFeedbackParams));
+                    // Workaround for AMD driver bug where it expects the offsets array to be
+                    // non-null
+                    gl::TransformFeedbackBuffersArray<VkDeviceSize> offsets;
+                    offsets.fill(0);
+                    vkCmdEndTransformFeedbackEXT(cmdBuffer, 0, params->bufferCount, counterBuffers,
+                                                 offsets.data());
+                    break;
+                }
                 case CommandID::ExecutionBarrier:
                 {
                     const ExecutionBarrierParams *params =
@@ -487,34 +515,6 @@ void SecondaryCommandBuffer::executeCommands(VkCommandBuffer cmdBuffer)
                                         params->query);
                     break;
                 }
-                case CommandID::BeginTransformFeedback:
-                {
-                    const BeginTransformFeedbackParams *params =
-                        getParamPtr<BeginTransformFeedbackParams>(currentCommand);
-                    const VkBuffer *counterBuffers =
-                        Offset<VkBuffer>(params, sizeof(BeginTransformFeedbackParams));
-                    // Workaround for AMD driver bug where it expects the offsets array to be
-                    // non-null
-                    gl::TransformFeedbackBuffersArray<VkDeviceSize> offsets;
-                    offsets.fill(0);
-                    vkCmdBeginTransformFeedbackEXT(cmdBuffer, 0, params->bufferCount,
-                                                   counterBuffers, offsets.data());
-                    break;
-                }
-                case CommandID::EndTransformFeedback:
-                {
-                    const EndTransformFeedbackParams *params =
-                        getParamPtr<EndTransformFeedbackParams>(currentCommand);
-                    const VkBuffer *counterBuffers =
-                        Offset<VkBuffer>(params, sizeof(EndTransformFeedbackParams));
-                    // Workaround for AMD driver bug where it expects the offsets array to be
-                    // non-null
-                    gl::TransformFeedbackBuffersArray<VkDeviceSize> offsets;
-                    offsets.fill(0);
-                    vkCmdEndTransformFeedbackEXT(cmdBuffer, 0, params->bufferCount, counterBuffers,
-                                                 offsets.data());
-                    break;
-                }
                 default:
                 {
                     UNREACHABLE();
diff --git a/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h b/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h
index 2471612af6..49a172347c 100644
--- a/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h
+++ b/src/libANGLE/renderer/vulkan/SecondaryCommandBuffer.h
@@ -24,12 +24,15 @@ namespace vk
 
 namespace priv
 {
-
+// NOTE: Please keep command-related enums, stucts, functions
+//  and other code dealing with commands in alphabetical order
+//  This simplifies searching and updating commands.
 enum class CommandID : uint16_t
 {
     // Invalid cmd used to mark end of sequence of commands
     Invalid = 0,
     BeginQuery,
+    BeginTransformFeedback,
     BindComputePipeline,
     BindDescriptorSets,
     BindGraphicsPipeline,
@@ -50,14 +53,15 @@ enum class CommandID : uint16_t
     Draw,
     DrawIndexed,
     DrawIndexedBaseVertex,
+    DrawIndexedIndirect,
     DrawIndexedInstanced,
     DrawIndexedInstancedBaseVertex,
     DrawIndexedInstancedBaseVertexBaseInstance,
+    DrawIndirect,
     DrawInstanced,
     DrawInstancedBaseInstance,
-    DrawIndirect,
-    DrawIndexedIndirect,
     EndQuery,
+    EndTransformFeedback,
     ExecutionBarrier,
     FillBuffer,
     ImageBarrier,
@@ -70,8 +74,6 @@ enum class CommandID : uint16_t
     SetEvent,
     WaitEvents,
     WriteTimestamp,
-    BeginTransformFeedback,
-    EndTransformFeedback,
 };
 
 #define VERIFY_4_BYTE_ALIGNMENT(StructName) \
@@ -81,11 +83,19 @@ enum class CommandID : uint16_t
 // This makes it easy to know the size of params & to copy params
 // TODO: Could optimize the size of some of these structs through bit-packing
 //  and customizing sizing based on limited parameter sets used by ANGLE
-struct BindPipelineParams
+struct BeginQueryParams
 {
-    VkPipeline pipeline;
+    VkQueryPool queryPool;
+    uint32_t query;
+    VkQueryControlFlags flags;
 };
-VERIFY_4_BYTE_ALIGNMENT(BindPipelineParams)
+VERIFY_4_BYTE_ALIGNMENT(BeginQueryParams)
+
+struct BeginTransformFeedbackParams
+{
+    uint32_t bufferCount;
+};
+VERIFY_4_BYTE_ALIGNMENT(BeginTransformFeedbackParams)
 
 struct BindDescriptorSetParams
 {
@@ -105,19 +115,20 @@ struct BindIndexBufferParams
 };
 VERIFY_4_BYTE_ALIGNMENT(BindIndexBufferParams)
 
-struct BindTransformFeedbackBuffersParams
+struct BindPipelineParams
 {
-    // ANGLE always has firstBinding of 0 so not storing that currently
-    uint32_t bindingCount;
+    VkPipeline pipeline;
 };
-VERIFY_4_BYTE_ALIGNMENT(BindTransformFeedbackBuffersParams)
+VERIFY_4_BYTE_ALIGNMENT(BindPipelineParams)
 
-struct BindVertexBuffersParams
+struct BindTransformFeedbackBuffersParams
 {
     // ANGLE always has firstBinding of 0 so not storing that currently
     uint32_t bindingCount;
 };
-VERIFY_4_BYTE_ALIGNMENT(BindVertexBuffersParams)
+VERIFY_4_BYTE_ALIGNMENT(BindTransformFeedbackBuffersParams)
+
+using BindVertexBuffersParams = BindTransformFeedbackBuffersParams;
 
 struct BlitImageParams
 {
@@ -128,6 +139,39 @@ struct BlitImageParams
 };
 VERIFY_4_BYTE_ALIGNMENT(BlitImageParams)
 
+struct BufferBarrierParams
+{
+    VkPipelineStageFlags srcStageMask;
+    VkPipelineStageFlags dstStageMask;
+    VkBufferMemoryBarrier bufferMemoryBarrier;
+};
+VERIFY_4_BYTE_ALIGNMENT(BufferBarrierParams)
+
+struct ClearAttachmentsParams
+{
+    uint32_t attachmentCount;
+    VkClearRect rect;
+};
+VERIFY_4_BYTE_ALIGNMENT(ClearAttachmentsParams)
+
+struct ClearColorImageParams
+{
+    VkImage image;
+    VkImageLayout imageLayout;
+    VkClearColorValue color;
+    VkImageSubresourceRange range;
+};
+VERIFY_4_BYTE_ALIGNMENT(ClearColorImageParams)
+
+struct ClearDepthStencilImageParams
+{
+    VkImage image;
+    VkImageLayout imageLayout;
+    VkClearDepthStencilValue depthStencil;
+    VkImageSubresourceRange range;
+};
+VERIFY_4_BYTE_ALIGNMENT(ClearDepthStencilImageParams)
+
 struct CopyBufferParams
 {
     VkBuffer srcBuffer;
@@ -164,39 +208,20 @@ struct CopyImageToBufferParams
 };
 VERIFY_4_BYTE_ALIGNMENT(CopyImageToBufferParams)
 
-struct ClearAttachmentsParams
-{
-    uint32_t attachmentCount;
-    VkClearRect rect;
-};
-VERIFY_4_BYTE_ALIGNMENT(ClearAttachmentsParams)
-
-struct ClearColorImageParams
-{
-    VkImage image;
-    VkImageLayout imageLayout;
-    VkClearColorValue color;
-    VkImageSubresourceRange range;
-};
-VERIFY_4_BYTE_ALIGNMENT(ClearColorImageParams)
-
-struct ClearDepthStencilImageParams
+struct DispatchParams
 {
-    VkImage image;
-    VkImageLayout imageLayout;
-    VkClearDepthStencilValue depthStencil;
-    VkImageSubresourceRange range;
+    uint32_t groupCountX;
+    uint32_t groupCountY;
+    uint32_t groupCountZ;
 };
-VERIFY_4_BYTE_ALIGNMENT(ClearDepthStencilImageParams)
+VERIFY_4_BYTE_ALIGNMENT(DispatchParams)
 
-struct PushConstantsParams
+struct DispatchIndirectParams
 {
-    VkPipelineLayout layout;
-    VkShaderStageFlags flag;
-    uint32_t offset;
-    uint32_t size;
+    VkBuffer buffer;
+    VkDeviceSize offset;
 };
-VERIFY_4_BYTE_ALIGNMENT(PushConstantsParams)
+VERIFY_4_BYTE_ALIGNMENT(DispatchIndirectParams)
 
 struct DrawParams
 {
@@ -205,23 +230,6 @@ struct DrawParams
 };
 VERIFY_4_BYTE_ALIGNMENT(DrawParams)
 
-struct DrawInstancedParams
-{
-    uint32_t vertexCount;
-    uint32_t instanceCount;
-    uint32_t firstVertex;
-};
-VERIFY_4_BYTE_ALIGNMENT(DrawInstancedParams)
-
-struct DrawInstancedBaseInstanceParams
-{
-    uint32_t vertexCount;
-    uint32_t instanceCount;
-    uint32_t firstVertex;
-    uint32_t firstInstance;
-};
-VERIFY_4_BYTE_ALIGNMENT(DrawInstancedBaseInstanceParams)
-
 struct DrawIndexedParams
 {
     uint32_t indexCount;
@@ -235,6 +243,13 @@ struct DrawIndexedBaseVertexParams
 };
 VERIFY_4_BYTE_ALIGNMENT(DrawIndexedBaseVertexParams)
 
+struct DrawIndexedIndirectParams
+{
+    VkBuffer buffer;
+    VkDeviceSize offset;
+};
+VERIFY_4_BYTE_ALIGNMENT(DrawIndexedIndirectParams)
+
 struct DrawIndexedInstancedParams
 {
     uint32_t indexCount;
@@ -260,34 +275,48 @@ struct DrawIndexedInstancedBaseVertexBaseInstanceParams
 };
 VERIFY_4_BYTE_ALIGNMENT(DrawIndexedInstancedBaseVertexBaseInstanceParams)
 
-struct DrawIndexedIndirectParams
+struct DrawIndirectParams
 {
     VkBuffer buffer;
     VkDeviceSize offset;
 };
-VERIFY_4_BYTE_ALIGNMENT(DrawIndexedIndirectParams)
+VERIFY_4_BYTE_ALIGNMENT(DrawIndirectParams)
 
-struct DispatchParams
+struct DrawInstancedParams
 {
-    uint32_t groupCountX;
-    uint32_t groupCountY;
-    uint32_t groupCountZ;
+    uint32_t vertexCount;
+    uint32_t instanceCount;
+    uint32_t firstVertex;
 };
-VERIFY_4_BYTE_ALIGNMENT(DispatchParams)
+VERIFY_4_BYTE_ALIGNMENT(DrawInstancedParams)
 
-struct DrawIndirectParams
+struct DrawInstancedBaseInstanceParams
 {
-    VkBuffer buffer;
-    VkDeviceSize offset;
+    uint32_t vertexCount;
+    uint32_t instanceCount;
+    uint32_t firstVertex;
+    uint32_t firstInstance;
 };
-VERIFY_4_BYTE_ALIGNMENT(DrawIndirectParams)
+VERIFY_4_BYTE_ALIGNMENT(DrawInstancedBaseInstanceParams)
 
-struct DispatchIndirectParams
+struct EndQueryParams
 {
-    VkBuffer buffer;
-    VkDeviceSize offset;
+    VkQueryPool queryPool;
+    uint32_t query;
 };
-VERIFY_4_BYTE_ALIGNMENT(DispatchIndirectParams)
+VERIFY_4_BYTE_ALIGNMENT(EndQueryParams)
+
+struct EndTransformFeedbackParams
+{
+    uint32_t bufferCount;
+};
+VERIFY_4_BYTE_ALIGNMENT(EndTransformFeedbackParams)
+
+struct ExecutionBarrierParams
+{
+    VkPipelineStageFlags stageMask;
+};
+VERIFY_4_BYTE_ALIGNMENT(ExecutionBarrierParams)
 
 struct FillBufferParams
 {
@@ -298,6 +327,14 @@ struct FillBufferParams
 };
 VERIFY_4_BYTE_ALIGNMENT(FillBufferParams)
 
+struct ImageBarrierParams
+{
+    VkPipelineStageFlags srcStageMask;
+    VkPipelineStageFlags dstStageMask;
+    VkImageMemoryBarrier imageMemoryBarrier;
+};
+VERIFY_4_BYTE_ALIGNMENT(ImageBarrierParams)
+
 struct MemoryBarrierParams
 {
     VkPipelineStageFlags srcStageMask;
@@ -317,34 +354,14 @@ struct PipelineBarrierParams
 };
 VERIFY_4_BYTE_ALIGNMENT(PipelineBarrierParams)
 
-struct ExecutionBarrierParams
-{
-    VkPipelineStageFlags stageMask;
-};
-VERIFY_4_BYTE_ALIGNMENT(ExecutionBarrierParams)
-
-struct BufferBarrierParams
-{
-    VkPipelineStageFlags srcStageMask;
-    VkPipelineStageFlags dstStageMask;
-    VkBufferMemoryBarrier bufferMemoryBarrier;
-};
-VERIFY_4_BYTE_ALIGNMENT(BufferBarrierParams)
-
-struct ImageBarrierParams
-{
-    VkPipelineStageFlags srcStageMask;
-    VkPipelineStageFlags dstStageMask;
-    VkImageMemoryBarrier imageMemoryBarrier;
-};
-VERIFY_4_BYTE_ALIGNMENT(ImageBarrierParams)
-
-struct SetEventParams
+struct PushConstantsParams
 {
-    VkEvent event;
-    VkPipelineStageFlags stageMask;
+    VkPipelineLayout layout;
+    VkShaderStageFlags flag;
+    uint32_t offset;
+    uint32_t size;
 };
-VERIFY_4_BYTE_ALIGNMENT(SetEventParams)
+VERIFY_4_BYTE_ALIGNMENT(PushConstantsParams)
 
 struct ResetEventParams
 {
@@ -353,17 +370,6 @@ struct ResetEventParams
 };
 VERIFY_4_BYTE_ALIGNMENT(ResetEventParams)
 
-struct WaitEventsParams
-{
-    uint32_t eventCount;
-    VkPipelineStageFlags srcStageMask;
-    VkPipelineStageFlags dstStageMask;
-    uint32_t memoryBarrierCount;
-    uint32_t bufferMemoryBarrierCount;
-    uint32_t imageMemoryBarrierCount;
-};
-VERIFY_4_BYTE_ALIGNMENT(WaitEventsParams)
-
 struct ResetQueryPoolParams
 {
     VkQueryPool queryPool;
@@ -380,20 +386,23 @@ struct ResolveImageParams
 };
 VERIFY_4_BYTE_ALIGNMENT(ResolveImageParams)
 
-struct BeginQueryParams
+struct SetEventParams
 {
-    VkQueryPool queryPool;
-    uint32_t query;
-    VkQueryControlFlags flags;
+    VkEvent event;
+    VkPipelineStageFlags stageMask;
 };
-VERIFY_4_BYTE_ALIGNMENT(BeginQueryParams)
+VERIFY_4_BYTE_ALIGNMENT(SetEventParams)
 
-struct EndQueryParams
+struct WaitEventsParams
 {
-    VkQueryPool queryPool;
-    uint32_t query;
+    uint32_t eventCount;
+    VkPipelineStageFlags srcStageMask;
+    VkPipelineStageFlags dstStageMask;
+    uint32_t memoryBarrierCount;
+    uint32_t bufferMemoryBarrierCount;
+    uint32_t imageMemoryBarrierCount;
 };
-VERIFY_4_BYTE_ALIGNMENT(EndQueryParams)
+VERIFY_4_BYTE_ALIGNMENT(WaitEventsParams)
 
 struct WriteTimestampParams
 {
@@ -403,25 +412,12 @@ struct WriteTimestampParams
 };
 VERIFY_4_BYTE_ALIGNMENT(WriteTimestampParams)
 
-struct BeginTransformFeedbackParams
-{
-    uint32_t bufferCount;
-};
-VERIFY_4_BYTE_ALIGNMENT(BeginTransformFeedbackParams)
-
-struct EndTransformFeedbackParams
-{
-    uint32_t bufferCount;
-};
-VERIFY_4_BYTE_ALIGNMENT(EndTransformFeedbackParams)
-
 // Header for every cmd in custom cmd buffer
 struct CommandHeader
 {
     CommandID id;
     uint16_t size;
 };
-
 static_assert(sizeof(CommandHeader) == 4, "Check CommandHeader size");
 
 template <typename DestT, typename T>
@@ -451,6 +447,8 @@ class SecondaryCommandBuffer final : angle::NonCopyable
     // Add commands
     void beginQuery(VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
 
+    void beginTransformFeedback(uint32_t counterBufferCount, const VkBuffer *pCounterBuffers);
+
     void bindComputePipeline(const Pipeline &pipeline);
 
     void bindDescriptorSets(const PipelineLayout &layout,
@@ -536,7 +534,10 @@ class SecondaryCommandBuffer final : angle::NonCopyable
 
     void drawIndexed(uint32_t indexCount);
     void drawIndexedBaseVertex(uint32_t indexCount, uint32_t vertexOffset);
-
+    void drawIndexedIndirect(const Buffer &buffer,
+                             VkDeviceSize offset,
+                             uint32_t drawCount,
+                             uint32_t stride);
     void drawIndexedInstanced(uint32_t indexCount, uint32_t instanceCount);
     void drawIndexedInstancedBaseVertex(uint32_t indexCount,
                                         uint32_t instanceCount,
@@ -547,23 +548,21 @@ class SecondaryCommandBuffer final : angle::NonCopyable
                                                     int32_t vertexOffset,
                                                     uint32_t firstInstance);
 
+    void drawIndirect(const Buffer &buffer,
+                      VkDeviceSize offset,
+                      uint32_t drawCount,
+                      uint32_t stride);
+
     void drawInstanced(uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex);
     void drawInstancedBaseInstance(uint32_t vertexCount,
                                    uint32_t instanceCount,
                                    uint32_t firstVertex,
                                    uint32_t firstInstance);
 
-    void drawIndirect(const Buffer &buffer,
-                      VkDeviceSize offset,
-                      uint32_t drawCount,
-                      uint32_t stride);
-    void drawIndexedIndirect(const Buffer &buffer,
-                             VkDeviceSize offset,
-                             uint32_t drawCount,
-                             uint32_t stride);
-
     void endQuery(VkQueryPool queryPool, uint32_t query);
 
+    void endTransformFeedback(uint32_t counterBufferCount, const VkBuffer *pCounterBuffers);
+
     void executionBarrier(VkPipelineStageFlags stageMask);
 
     void fillBuffer(const Buffer &dstBuffer,
@@ -623,10 +622,6 @@ class SecondaryCommandBuffer final : angle::NonCopyable
                         VkQueryPool queryPool,
                         uint32_t query);
 
-    void beginTransformFeedback(uint32_t counterBufferCount, const VkBuffer *pCounterBuffers);
-
-    void endTransformFeedback(uint32_t counterBufferCount, const VkBuffer *pCounterBuffers);
-
     // No-op for compatibility
     VkResult end() { return VK_SUCCESS; }
 
@@ -766,6 +761,17 @@ ANGLE_INLINE void SecondaryCommandBuffer::beginQuery(VkQueryPool queryPool,
     paramStruct->flags            = flags;
 }
 
+ANGLE_INLINE void SecondaryCommandBuffer::beginTransformFeedback(uint32_t bufferCount,
+                                                                 const VkBuffer *counterBuffers)
+{
+    uint8_t *writePtr;
+    size_t bufferSize                         = bufferCount * sizeof(VkBuffer);
+    BeginTransformFeedbackParams *paramStruct = initCommand<BeginTransformFeedbackParams>(
+        CommandID::BeginTransformFeedback, bufferSize, &writePtr);
+    paramStruct->bufferCount = bufferCount;
+    storePointerParameter(writePtr, counterBuffers, bufferSize);
+}
+
 ANGLE_INLINE void SecondaryCommandBuffer::bindComputePipeline(const Pipeline &pipeline)
 {
     BindPipelineParams *paramStruct =
@@ -1032,6 +1038,18 @@ ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedBaseVertex(uint32_t indexCo
     paramStruct->vertexOffset = vertexOffset;
 }
 
+ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedIndirect(const Buffer &buffer,
+                                                              VkDeviceSize offset,
+                                                              uint32_t drawCount,
+                                                              uint32_t stride)
+{
+    DrawIndexedIndirectParams *paramStruct =
+        initCommand<DrawIndexedIndirectParams>(CommandID::DrawIndexedIndirect);
+    paramStruct->buffer = buffer.getHandle();
+    paramStruct->offset = offset;
+    ASSERT(drawCount == 1);
+}
+
 ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstanced(uint32_t indexCount,
                                                                uint32_t instanceCount)
 {
@@ -1070,6 +1088,20 @@ ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedInstancedBaseVertexBaseInst
     paramStruct->firstInstance = firstInstance;
 }
 
+ANGLE_INLINE void SecondaryCommandBuffer::drawIndirect(const Buffer &buffer,
+                                                       VkDeviceSize offset,
+                                                       uint32_t drawCount,
+                                                       uint32_t stride)
+{
+    DrawIndirectParams *paramStruct = initCommand<DrawIndirectParams>(CommandID::DrawIndirect);
+    paramStruct->buffer             = buffer.getHandle();
+    paramStruct->offset             = offset;
+
+    // OpenGL ES doesn't have a way to specify a drawCount or stride, throw assert if something
+    // changes.
+    ASSERT(drawCount == 1);
+}
+
 ANGLE_INLINE void SecondaryCommandBuffer::drawInstanced(uint32_t vertexCount,
                                                         uint32_t instanceCount,
                                                         uint32_t firstVertex)
@@ -1093,32 +1125,6 @@ ANGLE_INLINE void SecondaryCommandBuffer::drawInstancedBaseInstance(uint32_t ver
     paramStruct->firstInstance = firstInstance;
 }
 
-ANGLE_INLINE void SecondaryCommandBuffer::drawIndirect(const Buffer &buffer,
-                                                       VkDeviceSize offset,
-                                                       uint32_t drawCount,
-                                                       uint32_t stride)
-{
-    DrawIndirectParams *paramStruct = initCommand<DrawIndirectParams>(CommandID::DrawIndirect);
-    paramStruct->buffer             = buffer.getHandle();
-    paramStruct->offset             = offset;
-
-    // OpenGL ES doesn't have a way to specify a drawCount or stride, throw assert if something
-    // changes.
-    ASSERT(drawCount == 1);
-}
-
-ANGLE_INLINE void SecondaryCommandBuffer::drawIndexedIndirect(const Buffer &buffer,
-                                                              VkDeviceSize offset,
-                                                              uint32_t drawCount,
-                                                              uint32_t stride)
-{
-    DrawIndexedIndirectParams *paramStruct =
-        initCommand<DrawIndexedIndirectParams>(CommandID::DrawIndexedIndirect);
-    paramStruct->buffer = buffer.getHandle();
-    paramStruct->offset = offset;
-    ASSERT(drawCount == 1);
-}
-
 ANGLE_INLINE void SecondaryCommandBuffer::endQuery(VkQueryPool queryPool, uint32_t query)
 {
     EndQueryParams *paramStruct = initCommand<EndQueryParams>(CommandID::EndQuery);
@@ -1126,6 +1132,17 @@ ANGLE_INLINE void SecondaryCommandBuffer::endQuery(VkQueryPool queryPool, uint32
     paramStruct->query          = query;
 }
 
+ANGLE_INLINE void SecondaryCommandBuffer::endTransformFeedback(uint32_t bufferCount,
+                                                               const VkBuffer *counterBuffers)
+{
+    uint8_t *writePtr;
+    size_t bufferSize                       = bufferCount * sizeof(VkBuffer);
+    EndTransformFeedbackParams *paramStruct = initCommand<EndTransformFeedbackParams>(
+        CommandID::EndTransformFeedback, bufferSize, &writePtr);
+    paramStruct->bufferCount = bufferCount;
+    storePointerParameter(writePtr, counterBuffers, bufferSize);
+}
+
 ANGLE_INLINE void SecondaryCommandBuffer::executionBarrier(VkPipelineStageFlags stageMask)
 {
     ExecutionBarrierParams *paramStruct =
@@ -1299,28 +1316,6 @@ ANGLE_INLINE void SecondaryCommandBuffer::writeTimestamp(VkPipelineStageFlagBits
     paramStruct->queryPool     = queryPool;
     paramStruct->query         = query;
 }
-
-ANGLE_INLINE void SecondaryCommandBuffer::beginTransformFeedback(uint32_t bufferCount,
-                                                                 const VkBuffer *counterBuffers)
-{
-    uint8_t *writePtr;
-    size_t bufferSize                         = bufferCount * sizeof(VkBuffer);
-    BeginTransformFeedbackParams *paramStruct = initCommand<BeginTransformFeedbackParams>(
-        CommandID::BeginTransformFeedback, bufferSize, &writePtr);
-    paramStruct->bufferCount = bufferCount;
-    storePointerParameter(writePtr, counterBuffers, bufferSize);
-}
-
-ANGLE_INLINE void SecondaryCommandBuffer::endTransformFeedback(uint32_t bufferCount,
-                                                               const VkBuffer *counterBuffers)
-{
-    uint8_t *writePtr;
-    size_t bufferSize                       = bufferCount * sizeof(VkBuffer);
-    EndTransformFeedbackParams *paramStruct = initCommand<EndTransformFeedbackParams>(
-        CommandID::EndTransformFeedback, bufferSize, &writePtr);
-    paramStruct->bufferCount = bufferCount;
-    storePointerParameter(writePtr, counterBuffers, bufferSize);
-}
 }  // namespace priv
 }  // namespace vk
 }  // namespace rx