Rename Execute to Do in the Engine commands.

The Do prefix is shorter and easier to read.

7 files changed, 124 insertions, 125 deletions

diff --git a/src/dawn/engine_dawn.cc b/src/dawn/engine_dawn.cc
index cdd4f35..7edaed8 100644
--- a/src/dawn/engine_dawn.cc
+++ b/src/dawn/engine_dawn.cc
@@ -69,57 +69,57 @@ Result EngineDawn::SetBuffer(BufferType,
   return Result("Dawn:SetBuffer not implemented");
 }
 
-Result EngineDawn::ExecuteClearColor(const ClearColorCommand*) {
-  return Result("Dawn:ExecuteClearColor not implemented");
+Result EngineDawn::DoClearColor(const ClearColorCommand*) {
+  return Result("Dawn:DoClearColor not implemented");
 }
 
-Result EngineDawn::ExecuteClearStencil(const ClearStencilCommand*) {
-  return Result("Dawn:ExecuteClearStencil not implemented");
+Result EngineDawn::DoClearStencil(const ClearStencilCommand*) {
+  return Result("Dawn:DoClearStencil not implemented");
 }
 
-Result EngineDawn::ExecuteClearDepth(const ClearDepthCommand*) {
-  return Result("Dawn:ExecuteClearDepth not implemented");
+Result EngineDawn::DoClearDepth(const ClearDepthCommand*) {
+  return Result("Dawn:DoClearDepth not implemented");
 }
 
-Result EngineDawn::ExecuteClear(const ClearCommand*) {
-  return Result("Dawn:ExecuteClear not implemented");
+Result EngineDawn::DoClear(const ClearCommand*) {
+  return Result("Dawn:DoClear not implemented");
 }
 
-Result EngineDawn::ExecuteDrawRect(const DrawRectCommand*) {
-  return Result("Dawn:ExecuteDrawRect not implemented");
+Result EngineDawn::DoDrawRect(const DrawRectCommand*) {
+  return Result("Dawn:DoDrawRect not implemented");
 }
 
-Result EngineDawn::ExecuteDrawArrays(const DrawArraysCommand*) {
-  return Result("Dawn:ExecuteDrawArrays not implemented");
+Result EngineDawn::DoDrawArrays(const DrawArraysCommand*) {
+  return Result("Dawn:DoDrawArrays not implemented");
 }
 
-Result EngineDawn::ExecuteCompute(const ComputeCommand*) {
-  return Result("Dawn:ExecuteCompute not implemented");
+Result EngineDawn::DoCompute(const ComputeCommand*) {
+  return Result("Dawn:DoCompute not implemented");
 }
 
-Result EngineDawn::ExecuteEntryPoint(const EntryPointCommand*) {
-  return Result("Dawn:ExecuteEntryPoint not implemented");
+Result EngineDawn::DoEntryPoint(const EntryPointCommand*) {
+  return Result("Dawn:DoEntryPoint not implemented");
 }
 
-Result EngineDawn::ExecutePatchParameterVertices(
+Result EngineDawn::DoPatchParameterVertices(
     const PatchParameterVerticesCommand*) {
-  return Result("Dawn:ExecutePatch not implemented");
+  return Result("Dawn:DoPatch not implemented");
 }
 
-Result EngineDawn::ExecuteProbe(const ProbeCommand*) {
-  return Result("Dawn:ExecutePatch not implemented");
+Result EngineDawn::DoProbe(const ProbeCommand*) {
+  return Result("Dawn:DoPatch not implemented");
 }
 
-Result EngineDawn::ExecuteProbeSSBO(const ProbeSSBOCommand*) {
-  return Result("Dawn:ExecuteProbeSSBO not implemented");
+Result EngineDawn::DoProbeSSBO(const ProbeSSBOCommand*) {
+  return Result("Dawn:DoProbeSSBO not implemented");
 }
 
-Result EngineDawn::ExecuteBuffer(const BufferCommand*) {
-  return Result("Dawn:ExecuteBuffer not implemented");
+Result EngineDawn::DoBuffer(const BufferCommand*) {
+  return Result("Dawn:DoBuffer not implemented");
 }
 
-Result EngineDawn::ExecuteTolerance(const ToleranceCommand*) {
-  return Result("Dawn:ExecuteTolerance not implemented");
+Result EngineDawn::DoTolerance(const ToleranceCommand*) {
+  return Result("Dawn:DoTolerance not implemented");
 }
 
 }  // namespace dawn
diff --git a/src/dawn/engine_dawn.h b/src/dawn/engine_dawn.h
index d3dd9ff..50d0d09 100644
--- a/src/dawn/engine_dawn.h
+++ b/src/dawn/engine_dawn.h
@@ -41,20 +41,20 @@ class EngineDawn : public Engine {
                    uint8_t location,
                    const Format& format,
                    const std::vector<Value>& data) override;
-  Result ExecuteClearColor(const ClearColorCommand* cmd) override;
-  Result ExecuteClearStencil(const ClearStencilCommand* cmd) override;
-  Result ExecuteClearDepth(const ClearDepthCommand* cmd) override;
-  Result ExecuteClear(const ClearCommand* cmd) override;
-  Result ExecuteDrawRect(const DrawRectCommand* cmd) override;
-  Result ExecuteDrawArrays(const DrawArraysCommand* cmd) override;
-  Result ExecuteCompute(const ComputeCommand* cmd) override;
-  Result ExecuteEntryPoint(const EntryPointCommand* cmd) override;
-  Result ExecutePatchParameterVertices(
+  Result DoClearColor(const ClearColorCommand* cmd) override;
+  Result DoClearStencil(const ClearStencilCommand* cmd) override;
+  Result DoClearDepth(const ClearDepthCommand* cmd) override;
+  Result DoClear(const ClearCommand* cmd) override;
+  Result DoDrawRect(const DrawRectCommand* cmd) override;
+  Result DoDrawArrays(const DrawArraysCommand* cmd) override;
+  Result DoCompute(const ComputeCommand* cmd) override;
+  Result DoEntryPoint(const EntryPointCommand* cmd) override;
+  Result DoPatchParameterVertices(
       const PatchParameterVerticesCommand* cmd) override;
-  Result ExecuteProbe(const ProbeCommand* cmd) override;
-  Result ExecuteProbeSSBO(const ProbeSSBOCommand* cmd) override;
-  Result ExecuteBuffer(const BufferCommand* cmd) override;
-  Result ExecuteTolerance(const ToleranceCommand* cmd) override;
+  Result DoProbe(const ProbeCommand* cmd) override;
+  Result DoProbeSSBO(const ProbeSSBOCommand* cmd) override;
+  Result DoBuffer(const BufferCommand* cmd) override;
+  Result DoTolerance(const ToleranceCommand* cmd) override;
 
  private:
   ::dawn::Device device_;
diff --git a/src/engine.h b/src/engine.h
index a58a41e..82e3655 100644
--- a/src/engine.h
+++ b/src/engine.h
@@ -67,44 +67,44 @@ class Engine {
                            const std::vector<Value>& data) = 0;
 
   // Execute the clear color command
-  virtual Result ExecuteClearColor(const ClearColorCommand* cmd) = 0;
+  virtual Result DoClearColor(const ClearColorCommand* cmd) = 0;
 
   // Execute the clear stencil command
-  virtual Result ExecuteClearStencil(const ClearStencilCommand* cmd) = 0;
+  virtual Result DoClearStencil(const ClearStencilCommand* cmd) = 0;
 
   // Execute the clear depth command
-  virtual Result ExecuteClearDepth(const ClearDepthCommand* cmd) = 0;
+  virtual Result DoClearDepth(const ClearDepthCommand* cmd) = 0;
 
   // Execute the clear command
-  virtual Result ExecuteClear(const ClearCommand* cmd) = 0;
+  virtual Result DoClear(const ClearCommand* cmd) = 0;
 
   // Execute the draw rect command
-  virtual Result ExecuteDrawRect(const DrawRectCommand* cmd) = 0;
+  virtual Result DoDrawRect(const DrawRectCommand* cmd) = 0;
 
   // Execute the draw arrays command
-  virtual Result ExecuteDrawArrays(const DrawArraysCommand* cmd) = 0;
+  virtual Result DoDrawArrays(const DrawArraysCommand* cmd) = 0;
 
   // Execute the compute command
-  virtual Result ExecuteCompute(const ComputeCommand* cmd) = 0;
+  virtual Result DoCompute(const ComputeCommand* cmd) = 0;
 
   // Execute the entry point command
-  virtual Result ExecuteEntryPoint(const EntryPointCommand* cmd) = 0;
+  virtual Result DoEntryPoint(const EntryPointCommand* cmd) = 0;
 
   // Execute the patch command
-  virtual Result ExecutePatchParameterVertices(
+  virtual Result DoPatchParameterVertices(
       const PatchParameterVerticesCommand* cmd) = 0;
 
   // Execute the probe command
-  virtual Result ExecuteProbe(const ProbeCommand* cmd) = 0;
+  virtual Result DoProbe(const ProbeCommand* cmd) = 0;
 
   // Execute the probe ssbo command
-  virtual Result ExecuteProbeSSBO(const ProbeSSBOCommand* cmd) = 0;
+  virtual Result DoProbeSSBO(const ProbeSSBOCommand* cmd) = 0;
 
   // Execute the buffer command
-  virtual Result ExecuteBuffer(const BufferCommand* cmd) = 0;
+  virtual Result DoBuffer(const BufferCommand* cmd) = 0;
 
   // Execute the tolerance command
-  virtual Result ExecuteTolerance(const ToleranceCommand* cmd) = 0;
+  virtual Result DoTolerance(const ToleranceCommand* cmd) = 0;
 
  protected:
   Engine();
diff --git a/src/vkscript/executor.cc b/src/vkscript/executor.cc
index bd6bad0..8357612 100644
--- a/src/vkscript/executor.cc
+++ b/src/vkscript/executor.cc
@@ -113,32 +113,31 @@ Result Executor::Execute(Engine* engine, const amber::Script* src_script) {
 
     for (const auto& cmd : node->AsTest()->GetCommands()) {
       if (cmd->IsClear()) {
-        r = engine->ExecuteClear(cmd->AsClear());
+        r = engine->DoClear(cmd->AsClear());
       } else if (cmd->IsClearColor()) {
-        r = engine->ExecuteClearColor(cmd->AsClearColor());
+        r = engine->DoClearColor(cmd->AsClearColor());
       } else if (cmd->IsClearDepth()) {
-        r = engine->ExecuteClearDepth(cmd->AsClearDepth());
+        r = engine->DoClearDepth(cmd->AsClearDepth());
       } else if (cmd->IsClearStencil()) {
-        r = engine->ExecuteClearStencil(cmd->AsClearStencil());
+        r = engine->DoClearStencil(cmd->AsClearStencil());
       } else if (cmd->IsDrawRect()) {
-        r = engine->ExecuteDrawRect(cmd->AsDrawRect());
+        r = engine->DoDrawRect(cmd->AsDrawRect());
       } else if (cmd->IsDrawArrays()) {
-        r = engine->ExecuteDrawArrays(cmd->AsDrawArrays());
+        r = engine->DoDrawArrays(cmd->AsDrawArrays());
       } else if (cmd->IsCompute()) {
-        r = engine->ExecuteCompute(cmd->AsCompute());
+        r = engine->DoCompute(cmd->AsCompute());
       } else if (cmd->IsEntryPoint()) {
-        r = engine->ExecuteEntryPoint(cmd->AsEntryPoint());
+        r = engine->DoEntryPoint(cmd->AsEntryPoint());
       } else if (cmd->IsPatchParameterVertices()) {
-        r = engine->ExecutePatchParameterVertices(
-            cmd->AsPatchParameterVertices());
+        r = engine->DoPatchParameterVertices(cmd->AsPatchParameterVertices());
       } else if (cmd->IsProbe()) {
-        r = engine->ExecuteProbe(cmd->AsProbe());
+        r = engine->DoProbe(cmd->AsProbe());
       } else if (cmd->IsProbeSSBO()) {
-        r = engine->ExecuteProbeSSBO(cmd->AsProbeSSBO());
+        r = engine->DoProbeSSBO(cmd->AsProbeSSBO());
       } else if (cmd->IsBuffer()) {
-        r = engine->ExecuteBuffer(cmd->AsBuffer());
+        r = engine->DoBuffer(cmd->AsBuffer());
       } else if (cmd->IsTolerance()) {
-        r = engine->ExecuteTolerance(cmd->AsTolerance());
+        r = engine->DoTolerance(cmd->AsTolerance());
       } else {
         return Result("Unknown command type");
       }
diff --git a/src/vkscript/executor_test.cc b/src/vkscript/executor_test.cc
index 53af91e..40ab220 100644
--- a/src/vkscript/executor_test.cc
+++ b/src/vkscript/executor_test.cc
@@ -86,7 +86,7 @@ class EngineStub : public Engine {
   void FailClearColorCommand() { fail_clear_color_command_ = true; }
   bool DidClearColorCommand() { return did_clear_color_command_ = true; }
   ClearColorCommand* GetLastClearColorCommand() { return last_clear_color_; }
-  Result ExecuteClearColor(const ClearColorCommand* cmd) override {
+  Result DoClearColor(const ClearColorCommand* cmd) override {
     did_clear_color_command_ = true;
 
     if (fail_clear_color_command_)
@@ -98,7 +98,7 @@ class EngineStub : public Engine {
 
   void FailClearStencilCommand() { fail_clear_stencil_command_ = true; }
   bool DidClearStencilCommand() const { return did_clear_stencil_command_; }
-  Result ExecuteClearStencil(const ClearStencilCommand*) override {
+  Result DoClearStencil(const ClearStencilCommand*) override {
     did_clear_stencil_command_ = true;
 
     if (fail_clear_stencil_command_)
@@ -109,7 +109,7 @@ class EngineStub : public Engine {
 
   void FailClearDepthCommand() { fail_clear_depth_command_ = true; }
   bool DidClearDepthCommand() const { return did_clear_depth_command_; }
-  Result ExecuteClearDepth(const ClearDepthCommand*) override {
+  Result DoClearDepth(const ClearDepthCommand*) override {
     did_clear_depth_command_ = true;
 
     if (fail_clear_depth_command_)
@@ -120,7 +120,7 @@ class EngineStub : public Engine {
 
   void FailClearCommand() { fail_clear_command_ = true; }
   bool DidClearCommand() const { return did_clear_command_; }
-  Result ExecuteClear(const ClearCommand*) override {
+  Result DoClear(const ClearCommand*) override {
     did_clear_command_ = true;
 
     if (fail_clear_command_)
@@ -130,7 +130,7 @@ class EngineStub : public Engine {
 
   void FailDrawRectCommand() { fail_draw_rect_command_ = true; }
   bool DidDrawRectCommand() const { return did_draw_rect_command_; }
-  Result ExecuteDrawRect(const DrawRectCommand*) override {
+  Result DoDrawRect(const DrawRectCommand*) override {
     did_draw_rect_command_ = true;
 
     if (fail_draw_rect_command_)
@@ -140,7 +140,7 @@ class EngineStub : public Engine {
 
   void FailDrawArraysCommand() { fail_draw_arrays_command_ = true; }
   bool DidDrawArraysCommand() const { return did_draw_arrays_command_; }
-  Result ExecuteDrawArrays(const DrawArraysCommand*) override {
+  Result DoDrawArrays(const DrawArraysCommand*) override {
     did_draw_arrays_command_ = true;
 
     if (fail_draw_arrays_command_)
@@ -150,7 +150,7 @@ class EngineStub : public Engine {
 
   void FailComputeCommand() { fail_compute_command_ = true; }
   bool DidComputeCommand() const { return did_compute_command_; }
-  Result ExecuteCompute(const ComputeCommand*) override {
+  Result DoCompute(const ComputeCommand*) override {
     did_compute_command_ = true;
 
     if (fail_compute_command_)
@@ -160,7 +160,7 @@ class EngineStub : public Engine {
 
   void FailEntryPointCommand() { fail_entry_point_command_ = true; }
   bool DidEntryPointCommand() const { return did_entry_point_command_; }
-  Result ExecuteEntryPoint(const EntryPointCommand*) override {
+  Result DoEntryPoint(const EntryPointCommand*) override {
     did_entry_point_command_ = true;
 
     if (fail_entry_point_command_)
@@ -170,7 +170,7 @@ class EngineStub : public Engine {
 
   void FailPatchParameterVerticesCommand() { fail_patch_command_ = true; }
   bool DidPatchParameterVerticesCommand() const { return did_patch_command_; }
-  Result ExecutePatchParameterVertices(
+  Result DoPatchParameterVertices(
       const PatchParameterVerticesCommand*) override {
     did_patch_command_ = true;
 
@@ -181,7 +181,7 @@ class EngineStub : public Engine {
 
   void FailProbeCommand() { fail_probe_command_ = true; }
   bool DidProbeCommand() const { return did_probe_commmand_; }
-  Result ExecuteProbe(const ProbeCommand*) override {
+  Result DoProbe(const ProbeCommand*) override {
     did_probe_commmand_ = true;
 
     if (fail_probe_command_)
@@ -191,7 +191,7 @@ class EngineStub : public Engine {
 
   void FailProbeSSBOCommand() { fail_probe_ssbo_command_ = true; }
   bool DidProbeSSBOCommand() const { return did_probe_ssbo_command_; }
-  Result ExecuteProbeSSBO(const ProbeSSBOCommand*) override {
+  Result DoProbeSSBO(const ProbeSSBOCommand*) override {
     did_probe_ssbo_command_ = true;
 
     if (fail_probe_ssbo_command_)
@@ -201,7 +201,7 @@ class EngineStub : public Engine {
 
   void FailBufferCommand() { fail_buffer_command_ = true; }
   bool DidBufferCommand() const { return did_buffer_command_; }
-  Result ExecuteBuffer(const BufferCommand*) override {
+  Result DoBuffer(const BufferCommand*) override {
     did_buffer_command_ = true;
 
     if (fail_buffer_command_)
@@ -211,7 +211,7 @@ class EngineStub : public Engine {
 
   void FailToleranceCommand() { fail_tolerance_command_ = true; }
   bool DidToleranceCommand() const { return did_tolerance_command_; }
-  Result ExecuteTolerance(const ToleranceCommand*) override {
+  Result DoTolerance(const ToleranceCommand*) override {
     did_tolerance_command_ = true;
 
     if (fail_tolerance_command_)
@@ -297,22 +297,22 @@ class EngineCountingStub : public Engine {
     return {};
   }
 
-  Result ExecuteClearColor(const ClearColorCommand*) override { return {}; }
-  Result ExecuteClearStencil(const ClearStencilCommand*) override { return {}; }
-  Result ExecuteClearDepth(const ClearDepthCommand*) override { return {}; }
-  Result ExecuteClear(const ClearCommand*) override { return {}; }
-  Result ExecuteDrawRect(const DrawRectCommand*) override { return {}; }
-  Result ExecuteDrawArrays(const DrawArraysCommand*) override { return {}; }
-  Result ExecuteCompute(const ComputeCommand*) override { return {}; }
-  Result ExecuteEntryPoint(const EntryPointCommand*) override { return {}; }
-  Result ExecutePatchParameterVertices(
+  Result DoClearColor(const ClearColorCommand*) override { return {}; }
+  Result DoClearStencil(const ClearStencilCommand*) override { return {}; }
+  Result DoClearDepth(const ClearDepthCommand*) override { return {}; }
+  Result DoClear(const ClearCommand*) override { return {}; }
+  Result DoDrawRect(const DrawRectCommand*) override { return {}; }
+  Result DoDrawArrays(const DrawArraysCommand*) override { return {}; }
+  Result DoCompute(const ComputeCommand*) override { return {}; }
+  Result DoEntryPoint(const EntryPointCommand*) override { return {}; }
+  Result DoPatchParameterVertices(
       const PatchParameterVerticesCommand*) override {
     return {};
   }
-  Result ExecuteProbe(const ProbeCommand*) override { return {}; }
-  Result ExecuteProbeSSBO(const ProbeSSBOCommand*) override { return {}; }
-  Result ExecuteBuffer(const BufferCommand*) override { return {}; }
-  Result ExecuteTolerance(const ToleranceCommand*) override { return {}; }
+  Result DoProbe(const ProbeCommand*) override { return {}; }
+  Result DoProbeSSBO(const ProbeSSBOCommand*) override { return {}; }
+  Result DoBuffer(const BufferCommand*) override { return {}; }
+  Result DoTolerance(const ToleranceCommand*) override { return {}; }
 
  private:
   int32_t stage_count_ = 0;
diff --git a/src/vulkan/engine_vulkan.cc b/src/vulkan/engine_vulkan.cc
index 4618296..a22bb5c 100644
--- a/src/vulkan/engine_vulkan.cc
+++ b/src/vulkan/engine_vulkan.cc
@@ -202,7 +202,7 @@ Result EngineVulkan::SetBuffer(BufferType type,
   return {};
 }
 
-Result EngineVulkan::ExecuteClearColor(const ClearColorCommand* command) {
+Result EngineVulkan::DoClearColor(const ClearColorCommand* command) {
   if (!pipeline_->IsGraphics())
     return Result("Vulkan::Clear Color Command for Non-Graphics Pipeline");
 
@@ -210,68 +210,68 @@ Result EngineVulkan::ExecuteClearColor(const ClearColorCommand* command) {
       command->GetR(), command->GetG(), command->GetB(), command->GetA());
 }
 
-Result EngineVulkan::ExecuteClearStencil(const ClearStencilCommand* command) {
+Result EngineVulkan::DoClearStencil(const ClearStencilCommand* command) {
   if (!pipeline_->IsGraphics())
     return Result("Vulkan::Clear Stencil Command for Non-Graphics Pipeline");
 
   return pipeline_->AsGraphics()->SetClearStencil(command->GetValue());
 }
 
-Result EngineVulkan::ExecuteClearDepth(const ClearDepthCommand* command) {
+Result EngineVulkan::DoClearDepth(const ClearDepthCommand* command) {
   if (!pipeline_->IsGraphics())
     return Result("Vulkan::Clear Depth Command for Non-Graphics Pipeline");
 
   return pipeline_->AsGraphics()->SetClearDepth(command->GetValue());
 }
 
-Result EngineVulkan::ExecuteClear(const ClearCommand*) {
+Result EngineVulkan::DoClear(const ClearCommand*) {
   if (!pipeline_->IsGraphics())
     return Result("Vulkan::Clear Command for Non-Graphics Pipeline");
 
   return pipeline_->AsGraphics()->Clear();
 }
 
-Result EngineVulkan::ExecuteDrawRect(const DrawRectCommand*) {
-  return Result("Vulkan::ExecuteDrawRect Not Implemented");
+Result EngineVulkan::DoDrawRect(const DrawRectCommand*) {
+  return Result("Vulkan::DoDrawRect Not Implemented");
 }
 
-Result EngineVulkan::ExecuteDrawArrays(const DrawArraysCommand*) {
+Result EngineVulkan::DoDrawArrays(const DrawArraysCommand*) {
   if (!pipeline_->IsGraphics())
     return Result("Vulkan::DrawArrays for Non-Graphics Pipeline");
 
   return pipeline_->AsGraphics()->Draw();
 }
 
-Result EngineVulkan::ExecuteCompute(const ComputeCommand*) {
-  return Result("Vulkan::ExecuteCompute Not Implemented");
+Result EngineVulkan::DoCompute(const ComputeCommand*) {
+  return Result("Vulkan::DoCompute Not Implemented");
 }
 
-Result EngineVulkan::ExecuteEntryPoint(const EntryPointCommand*) {
-  return Result("Vulkan::ExecuteEntryPoint Not Implemented");
+Result EngineVulkan::DoEntryPoint(const EntryPointCommand*) {
+  return Result("Vulkan::DoEntryPoint Not Implemented");
 }
 
-Result EngineVulkan::ExecutePatchParameterVertices(
+Result EngineVulkan::DoPatchParameterVertices(
     const PatchParameterVerticesCommand*) {
-  return Result("Vulkan::ExecutePatch Not Implemented");
+  return Result("Vulkan::DoPatch Not Implemented");
 }
 
-Result EngineVulkan::ExecuteProbe(const ProbeCommand* command) {
+Result EngineVulkan::DoProbe(const ProbeCommand* command) {
   if (!pipeline_->IsGraphics())
     return Result("Vulkan::Probe FrameBuffer for Non-Graphics Pipeline");
 
   return pipeline_->AsGraphics()->Probe(command);
 }
 
-Result EngineVulkan::ExecuteProbeSSBO(const ProbeSSBOCommand*) {
-  return Result("Vulkan::ExecuteProbeSSBO Not Implemented");
+Result EngineVulkan::DoProbeSSBO(const ProbeSSBOCommand*) {
+  return Result("Vulkan::DoProbeSSBO Not Implemented");
 }
 
-Result EngineVulkan::ExecuteBuffer(const BufferCommand*) {
-  return Result("Vulkan::ExecuteBuffer Not Implemented");
+Result EngineVulkan::DoBuffer(const BufferCommand*) {
+  return Result("Vulkan::DoBuffer Not Implemented");
 }
 
-Result EngineVulkan::ExecuteTolerance(const ToleranceCommand*) {
-  return Result("Vulkan::ExecuteTolerance Not Implemented");
+Result EngineVulkan::DoTolerance(const ToleranceCommand*) {
+  return Result("Vulkan::DoTolerance Not Implemented");
 }
 
 }  // namespace vulkan
diff --git a/src/vulkan/engine_vulkan.h b/src/vulkan/engine_vulkan.h
index c8c2a00..f131f3b 100644
--- a/src/vulkan/engine_vulkan.h
+++ b/src/vulkan/engine_vulkan.h
@@ -44,20 +44,20 @@ class EngineVulkan : public Engine {
                    uint8_t location,
                    const Format& format,
                    const std::vector<Value>& data) override;
-  Result ExecuteClearColor(const ClearColorCommand* cmd) override;
-  Result ExecuteClearStencil(const ClearStencilCommand* cmd) override;
-  Result ExecuteClearDepth(const ClearDepthCommand* cmd) override;
-  Result ExecuteClear(const ClearCommand* cmd) override;
-  Result ExecuteDrawRect(const DrawRectCommand* cmd) override;
-  Result ExecuteDrawArrays(const DrawArraysCommand* cmd) override;
-  Result ExecuteCompute(const ComputeCommand* cmd) override;
-  Result ExecuteEntryPoint(const EntryPointCommand* cmd) override;
-  Result ExecutePatchParameterVertices(
+  Result DoClearColor(const ClearColorCommand* cmd) override;
+  Result DoClearStencil(const ClearStencilCommand* cmd) override;
+  Result DoClearDepth(const ClearDepthCommand* cmd) override;
+  Result DoClear(const ClearCommand* cmd) override;
+  Result DoDrawRect(const DrawRectCommand* cmd) override;
+  Result DoDrawArrays(const DrawArraysCommand* cmd) override;
+  Result DoCompute(const ComputeCommand* cmd) override;
+  Result DoEntryPoint(const EntryPointCommand* cmd) override;
+  Result DoPatchParameterVertices(
       const PatchParameterVerticesCommand* cmd) override;
-  Result ExecuteProbe(const ProbeCommand* cmd) override;
-  Result ExecuteProbeSSBO(const ProbeSSBOCommand* cmd) override;
-  Result ExecuteBuffer(const BufferCommand* cmd) override;
-  Result ExecuteTolerance(const ToleranceCommand* cmd) override;
+  Result DoProbe(const ProbeCommand* cmd) override;
+  Result DoProbeSSBO(const ProbeSSBOCommand* cmd) override;
+  Result DoBuffer(const BufferCommand* cmd) override;
+  Result DoTolerance(const ToleranceCommand* cmd) override;
 
  private:
   Result InitDeviceAndCreateCommand();