Vulkan: Don't store device handles in wrapped objects.

src/libANGLE/renderer/vulkan/BufferVk.cpp

@@ -24,6 +24,13 @@ BufferVk::~BufferVk()
 {
 }
 
+void BufferVk::destroy(ContextImpl *contextImpl)
+{
+    VkDevice device = GetAs<ContextVk>(contextImpl)->getDevice();
+
+    mBuffer.destroy(device);
+}
+
 gl::Error BufferVk::setData(ContextImpl *context,
                             GLenum target,
                             const void *data,
@@ -45,8 +52,8 @@ gl::Error BufferVk::setData(ContextImpl *context,
     createInfo.queueFamilyIndexCount = 0;
     createInfo.pQueueFamilyIndices   = nullptr;
 
-    vk::Buffer newBuffer(device);
-    ANGLE_TRY(newBuffer.init(createInfo));
+    vk::Buffer newBuffer;
+    ANGLE_TRY(newBuffer.init(device, createInfo));
 
     // Find a compatible memory pool index. If the index doesn't change, we could cache it.
     // Not finding a valid memory pool means an out-of-spec driver, or internal error.
@@ -73,14 +80,14 @@ gl::Error BufferVk::setData(ContextImpl *context,
     allocInfo.memoryTypeIndex = memoryTypeIndex.value();
     allocInfo.allocationSize  = memoryRequirements.size;
 
-    ANGLE_TRY(newBuffer.getMemory().allocate(allocInfo));
-    ANGLE_TRY(newBuffer.bindMemory());
+    ANGLE_TRY(newBuffer.getMemory().allocate(device, allocInfo));
+    ANGLE_TRY(newBuffer.bindMemory(device));
 
-    mBuffer = std::move(newBuffer);
+    mBuffer.retain(device, std::move(newBuffer));
 
     if (data)
     {
-        ANGLE_TRY(setDataImpl(static_cast<const uint8_t *>(data), size, 0));
+        ANGLE_TRY(setDataImpl(device, static_cast<const uint8_t *>(data), size, 0));
     }
 
     return gl::NoError();
@@ -95,7 +102,9 @@ gl::Error BufferVk::setSubData(ContextImpl *context,
     ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
     ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
 
-    ANGLE_TRY(setDataImpl(static_cast<const uint8_t *>(data), size, offset));
+    VkDevice device = GetAs<ContextVk>(context)->getDevice();
+
+    ANGLE_TRY(setDataImpl(device, static_cast<const uint8_t *>(data), size, offset));
 
     return gl::NoError();
 }
@@ -115,8 +124,10 @@ gl::Error BufferVk::map(ContextImpl *context, GLenum access, GLvoid **mapPtr)
     ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
     ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
 
-    ANGLE_TRY(
-        mBuffer.getMemory().map(0, mState.getSize(), 0, reinterpret_cast<uint8_t **>(mapPtr)));
+    VkDevice device = GetAs<ContextVk>(context)->getDevice();
+
+    ANGLE_TRY(mBuffer.getMemory().map(device, 0, mState.getSize(), 0,
+                                      reinterpret_cast<uint8_t **>(mapPtr)));
 
     return gl::NoError();
 }
@@ -130,7 +141,10 @@ gl::Error BufferVk::mapRange(ContextImpl *context,
     ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
     ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
 
-    ANGLE_TRY(mBuffer.getMemory().map(offset, length, 0, reinterpret_cast<uint8_t **>(mapPtr)));
+    VkDevice device = GetAs<ContextVk>(context)->getDevice();
+
+    ANGLE_TRY(
+        mBuffer.getMemory().map(device, offset, length, 0, reinterpret_cast<uint8_t **>(mapPtr)));
 
     return gl::NoError();
 }
@@ -140,7 +154,9 @@ gl::Error BufferVk::unmap(ContextImpl *context, GLboolean *result)
     ASSERT(mBuffer.getHandle() != VK_NULL_HANDLE);
     ASSERT(mBuffer.getMemory().getHandle() != VK_NULL_HANDLE);
 
-    mBuffer.getMemory().unmap();
+    VkDevice device = GetAs<ContextVk>(context)->getDevice();
+
+    mBuffer.getMemory().unmap(device);
 
     return gl::NoError();
 }
@@ -155,15 +171,15 @@ gl::Error BufferVk::getIndexRange(GLenum type,
     return gl::Error(GL_INVALID_OPERATION);
 }
 
-vk::Error BufferVk::setDataImpl(const uint8_t *data, size_t size, size_t offset)
+vk::Error BufferVk::setDataImpl(VkDevice device, const uint8_t *data, size_t size, size_t offset)
 {
     uint8_t *mapPointer = nullptr;
-    ANGLE_TRY(mBuffer.getMemory().map(offset, size, 0, &mapPointer));
+    ANGLE_TRY(mBuffer.getMemory().map(device, offset, size, 0, &mapPointer));
     ASSERT(mapPointer);
 
     memcpy(mapPointer, data, size);
 
-    mBuffer.getMemory().unmap();
+    mBuffer.getMemory().unmap(device);
 
     return vk::NoError();
 }

src/libANGLE/renderer/vulkan/BufferVk.h

@@ -21,6 +21,7 @@ class BufferVk : public BufferImpl
   public:
     BufferVk(const gl::BufferState &state);
     ~BufferVk() override;
+    void destroy(ContextImpl *contextImpl) override;
 
     gl::Error setData(ContextImpl *context,
                       GLenum target,
@@ -54,7 +55,7 @@ class BufferVk : public BufferImpl
     const vk::Buffer &getVkBuffer() const;
 
   private:
-    vk::Error setDataImpl(const uint8_t *data, size_t size, size_t offset);
+    vk::Error setDataImpl(VkDevice device, const uint8_t *data, size_t size, size_t offset);
 
     vk::Buffer mBuffer;
     size_t mRequiredSize;

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -41,6 +41,7 @@ ContextVk::ContextVk(const gl::ContextState &state, RendererVk *renderer)
 
 ContextVk::~ContextVk()
 {
+    mCurrentPipeline.destroy(getDevice());
 }
 
 gl::Error ContextVk::initialize()
@@ -259,10 +260,10 @@ gl::Error ContextVk::drawArrays(GLenum mode, GLint first, GLsizei count)
     pipelineInfo.basePipelineHandle  = VK_NULL_HANDLE;
     pipelineInfo.basePipelineIndex   = 0;
 
-    vk::Pipeline newPipeline(device);
-    ANGLE_TRY(newPipeline.initGraphics(pipelineInfo));
+    vk::Pipeline newPipeline;
+    ANGLE_TRY(newPipeline.initGraphics(device, pipelineInfo));
 
-    mCurrentPipeline = std::move(newPipeline);
+    mCurrentPipeline.retain(device, std::move(newPipeline));
 
     vk::CommandBuffer *commandBuffer = mRenderer->getCommandBuffer();
     ANGLE_TRY(vkFBO->beginRenderPass(device, commandBuffer, state));

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -17,6 +17,7 @@
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/renderer_utils.h"
 #include "libANGLE/renderer/vulkan/ContextVk.h"
+#include "libANGLE/renderer/vulkan/DisplayVk.h"
 #include "libANGLE/renderer/vulkan/RenderTargetVk.h"
 #include "libANGLE/renderer/vulkan/RendererVk.h"
 #include "libANGLE/renderer/vulkan/SurfaceVk.h"
@@ -79,16 +80,20 @@ FramebufferVk *FramebufferVk::CreateDefaultFBO(const gl::FramebufferState &state
 FramebufferVk::FramebufferVk(const gl::FramebufferState &state)
     : FramebufferImpl(state),
       mBackbuffer(nullptr),
-      mRenderPass(VK_NULL_HANDLE),
-      mFramebuffer(VK_NULL_HANDLE)
+      mRenderPass(),
+      mFramebuffer(),
+      mDirtyRenderPass(true),
+      mDirtyFramebuffer(true)
 {
 }
 
 FramebufferVk::FramebufferVk(const gl::FramebufferState &state, WindowSurfaceVk *backbuffer)
     : FramebufferImpl(state),
       mBackbuffer(backbuffer),
-      mRenderPass(VK_NULL_HANDLE),
-      mFramebuffer(VK_NULL_HANDLE)
+      mRenderPass(),
+      mFramebuffer(),
+      mDirtyRenderPass(true),
+      mDirtyFramebuffer(true)
 {
 }
 
@@ -96,6 +101,22 @@ FramebufferVk::~FramebufferVk()
 {
 }
 
+void FramebufferVk::destroy(ContextImpl *contextImpl)
+{
+    VkDevice device = GetAs<ContextVk>(contextImpl)->getDevice();
+
+    mRenderPass.destroy(device);
+    mFramebuffer.destroy(device);
+}
+
+void FramebufferVk::destroyDefault(DisplayImpl *displayImpl)
+{
+    VkDevice device = GetAs<DisplayVk>(displayImpl)->getRenderer()->getDevice();
+
+    mRenderPass.destroy(device);
+    mFramebuffer.destroy(device);
+}
+
 gl::Error FramebufferVk::discard(size_t count, const GLenum *attachments)
 {
     UNIMPLEMENTED();
@@ -152,7 +173,7 @@ gl::Error FramebufferVk::clear(ContextImpl *context, GLbitfield mask)
     const gl::Rectangle renderArea(0, 0, size.width, size.height);
 
     vk::CommandBuffer *commandBuffer = contextVk->getCommandBuffer();
-    ANGLE_TRY(commandBuffer->begin());
+    ANGLE_TRY(commandBuffer->begin(contextVk->getDevice()));
 
     for (const auto &colorAttachment : mState.getColorAttachments())
     {
@@ -253,15 +274,15 @@ gl::Error FramebufferVk::readPixels(ContextImpl *context,
 
     ContextVk *contextVk = GetAs<ContextVk>(context);
     RendererVk *renderer = contextVk->getRenderer();
+    VkDevice device      = renderer->getDevice();
 
     vk::Image *readImage = renderTarget->image;
     vk::StagingImage stagingImage;
-    ANGLE_TRY_RESULT(renderer->createStagingImage(TextureDimension::TEX_2D, *renderTarget->format,
-                                                  renderTarget->extents),
-                     stagingImage);
+    ANGLE_TRY(renderer->createStagingImage(TextureDimension::TEX_2D, *renderTarget->format,
+                                           renderTarget->extents, &stagingImage));
 
     vk::CommandBuffer *commandBuffer = contextVk->getCommandBuffer();
-    commandBuffer->begin();
+    commandBuffer->begin(device);
     stagingImage.getImage().changeLayoutTop(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_GENERAL,
                                             commandBuffer);
 
@@ -283,7 +304,8 @@ gl::Error FramebufferVk::readPixels(ContextImpl *context,
 
     // TODO(jmadill): parameters
     uint8_t *mapPointer = nullptr;
-    ANGLE_TRY(stagingImage.getDeviceMemory().map(0, stagingImage.getSize(), 0, &mapPointer));
+    ANGLE_TRY(
+        stagingImage.getDeviceMemory().map(device, 0, stagingImage.getSize(), 0, &mapPointer));
 
     const auto &angleFormat = renderTarget->format->format();
 
@@ -301,7 +323,9 @@ gl::Error FramebufferVk::readPixels(ContextImpl *context,
     PackPixels(params, angleFormat, inputPitch, mapPointer, reinterpret_cast<uint8_t *>(pixels));
 
     stagingImage.getImage().destroy(renderer->getDevice());
-    stagingImage.getDeviceMemory().unmap();
+    stagingImage.getDeviceMemory().unmap(device);
+
+    stagingImage.destroy(device);
 
     return vk::NoError();
 }
@@ -325,13 +349,13 @@ bool FramebufferVk::checkStatus() const
 void FramebufferVk::syncState(const gl::Framebuffer::DirtyBits &dirtyBits)
 {
     // TODO(jmadill): Smarter update.
-    mRenderPass  = vk::RenderPass();
-    mFramebuffer = vk::Framebuffer();
+    mDirtyRenderPass  = true;
+    mDirtyFramebuffer = true;
 }
 
 gl::ErrorOrResult<vk::RenderPass *> FramebufferVk::getRenderPass(VkDevice device)
 {
-    if (mRenderPass.valid())
+    if (mRenderPass.valid() && !mDirtyRenderPass)
     {
         return &mRenderPass;
     }
@@ -430,10 +454,12 @@ gl::ErrorOrResult<vk::RenderPass *> FramebufferVk::getRenderPass(VkDevice device
     renderPassInfo.dependencyCount = 0;
     renderPassInfo.pDependencies   = nullptr;
 
-    vk::RenderPass renderPass(device);
-    ANGLE_TRY(renderPass.init(renderPassInfo));
+    vk::RenderPass renderPass;
+    ANGLE_TRY(renderPass.init(device, renderPassInfo));
 
-    mRenderPass = std::move(renderPass);
+    mRenderPass.retain(device, std::move(renderPass));
+
+    mDirtyRenderPass = false;
 
     return &mRenderPass;
 }
@@ -441,7 +467,7 @@ gl::ErrorOrResult<vk::RenderPass *> FramebufferVk::getRenderPass(VkDevice device
 gl::ErrorOrResult<vk::Framebuffer *> FramebufferVk::getFramebuffer(VkDevice device)
 {
     // If we've already created our cached Framebuffer, return it.
-    if (mFramebuffer.valid())
+    if (mFramebuffer.valid() && !mDirtyFramebuffer)
     {
         return &mFramebuffer;
     }
@@ -499,10 +525,12 @@ gl::ErrorOrResult<vk::Framebuffer *> FramebufferVk::getFramebuffer(VkDevice devi
     framebufferInfo.height          = static_cast<uint32_t>(attachmentsSize.height);
     framebufferInfo.layers          = 1;
 
-    vk::Framebuffer framebuffer(device);
-    ANGLE_TRY(static_cast<gl::Error>(framebuffer.init(framebufferInfo)));
+    vk::Framebuffer framebuffer;
+    ANGLE_TRY(static_cast<gl::Error>(framebuffer.init(device, framebufferInfo)));
+
+    mFramebuffer.retain(device, std::move(framebuffer));
 
-    mFramebuffer = std::move(framebuffer);
+    mDirtyFramebuffer = false;
 
     return &mFramebuffer;
 }
@@ -544,7 +572,7 @@ gl::Error FramebufferVk::beginRenderPass(VkDevice device,
     ANGLE_TRY(mState.getFirstColorAttachment()->getRenderTarget(&renderTarget));
     renderTarget->image->updateLayout(VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
 
-    ANGLE_TRY(commandBuffer->begin());
+    ANGLE_TRY(commandBuffer->begin(device));
     commandBuffer->beginRenderPass(*renderPass, *framebuffer, glState.getViewport(),
                                    attachmentClearValues);
     return gl::NoError();

src/libANGLE/renderer/vulkan/FramebufferVk.h

@@ -31,6 +31,8 @@ class FramebufferVk : public FramebufferImpl
                                            WindowSurfaceVk *backbuffer);
 
     ~FramebufferVk() override;
+    void destroy(ContextImpl *contextImpl) override;
+    void destroyDefault(DisplayImpl *displayImpl) override;
 
     gl::Error discard(size_t count, const GLenum *attachments) override;
     gl::Error invalidate(size_t count, const GLenum *attachments) override;
@@ -93,6 +95,8 @@ class FramebufferVk : public FramebufferImpl
 
     vk::RenderPass mRenderPass;
     vk::Framebuffer mFramebuffer;
+    bool mDirtyRenderPass;
+    bool mDirtyFramebuffer;
 };
 
 }  // namespace rx

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -25,6 +25,15 @@ ProgramVk::~ProgramVk()
 {
 }
 
+void ProgramVk::destroy(const ContextImpl *contextImpl)
+{
+    VkDevice device = GetAs<ContextVk>(contextImpl)->getDevice();
+
+    mLinkedFragmentModule.destroy(device);
+    mLinkedVertexModule.destroy(device);
+    mPipelineLayout.destroy(device);
+}
+
 LinkResult ProgramVk::load(const ContextImpl *contextImpl,
                            gl::InfoLog &infoLog,
                            gl::BinaryInputStream *stream)
@@ -66,8 +75,9 @@ LinkResult ProgramVk::link(ContextImpl *contextImpl,
         return false;
     }
 
-    vk::ShaderModule vertexModule(renderer->getDevice());
-    vk::ShaderModule fragmentModule(renderer->getDevice());
+    vk::ShaderModule vertexModule;
+    vk::ShaderModule fragmentModule;
+    VkDevice device = renderer->getDevice();
 
     {
         VkShaderModuleCreateInfo vertexShaderInfo;
@@ -76,7 +86,7 @@ LinkResult ProgramVk::link(ContextImpl *contextImpl,
         vertexShaderInfo.flags    = 0;
         vertexShaderInfo.codeSize = vertexCode.size() * sizeof(uint32_t);
         vertexShaderInfo.pCode    = vertexCode.data();
-        ANGLE_TRY(vertexModule.init(vertexShaderInfo));
+        ANGLE_TRY(vertexModule.init(device, vertexShaderInfo));
     }
 
     {
@@ -87,11 +97,11 @@ LinkResult ProgramVk::link(ContextImpl *contextImpl,
         fragmentShaderInfo.codeSize = fragmentCode.size() * sizeof(uint32_t);
         fragmentShaderInfo.pCode    = fragmentCode.data();
 
-        ANGLE_TRY(fragmentModule.init(fragmentShaderInfo));
+        ANGLE_TRY(fragmentModule.init(device, fragmentShaderInfo));
     }
 
-    mLinkedVertexModule   = std::move(vertexModule);
-    mLinkedFragmentModule = std::move(fragmentModule);
+    mLinkedVertexModule.retain(device, std::move(vertexModule));
+    mLinkedFragmentModule.retain(device, std::move(fragmentModule));
 
     return true;
 }
@@ -274,7 +284,7 @@ const vk::ShaderModule &ProgramVk::getLinkedFragmentModule() const
 
 gl::ErrorOrResult<vk::PipelineLayout *> ProgramVk::getPipelineLayout(VkDevice device)
 {
-    vk::PipelineLayout newLayout(device);
+    vk::PipelineLayout newLayout;
 
     // TODO(jmadill): Descriptor sets.
     VkPipelineLayoutCreateInfo createInfo;
@@ -286,9 +296,8 @@ gl::ErrorOrResult<vk::PipelineLayout *> ProgramVk::getPipelineLayout(VkDevice de
     createInfo.pushConstantRangeCount = 0;
     createInfo.pPushConstantRanges    = nullptr;
 
-    ANGLE_TRY(newLayout.init(createInfo));
-
-    mPipelineLayout = std::move(newLayout);
+    ANGLE_TRY(newLayout.init(device, createInfo));
+    mPipelineLayout.retain(device, std::move(newLayout));
 
     return &mPipelineLayout;
 }

src/libANGLE/renderer/vulkan/ProgramVk.h

@@ -21,6 +21,7 @@ class ProgramVk : public ProgramImpl
   public:
     ProgramVk(const gl::ProgramState &state);
     ~ProgramVk() override;
+    void destroy(const ContextImpl *contextImpl) override;
 
     LinkResult load(const ContextImpl *contextImpl,
                     gl::InfoLog &infoLog,

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -106,8 +106,15 @@ RendererVk::~RendererVk()
         mGlslangWrapper = nullptr;
     }
 
-    mCommandBuffer.reset(nullptr);
-    mCommandPool.reset(nullptr);
+    if (mCommandBuffer.valid())
+    {
+        mCommandBuffer.destroy(mDevice);
+    }
+
+    if (mCommandPool.valid())
+    {
+        mCommandPool.destroy(mDevice);
+    }
 
     if (mDevice)
     {
@@ -417,10 +424,9 @@ vk::Error RendererVk::initializeDevice(uint32_t queueFamilyIndex)
     commandPoolInfo.flags            = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
     commandPoolInfo.queueFamilyIndex = mCurrentQueueFamilyIndex;
 
-    mCommandPool.reset(new vk::CommandPool(mDevice));
-    ANGLE_TRY(mCommandPool->init(commandPoolInfo));
+    ANGLE_TRY(mCommandPool.init(mDevice, commandPoolInfo));
 
-    mCommandBuffer.reset(new vk::CommandBuffer(mDevice, mCommandPool.get()));
+    mCommandBuffer.setCommandPool(&mCommandPool);
 
     return vk::NoError();
 }
@@ -553,7 +559,7 @@ const gl::Limitations &RendererVk::getNativeLimitations() const
 
 vk::CommandBuffer *RendererVk::getCommandBuffer()
 {
-    return mCommandBuffer.get();
+    return &mCommandBuffer;
 }
 
 vk::Error RendererVk::submitAndFinishCommandBuffer(const vk::CommandBuffer &commandBuffer)
@@ -612,17 +618,17 @@ vk::Error RendererVk::waitThenFinishCommandBuffer(const vk::CommandBuffer &comma
     return vk::NoError();
 }
 
-vk::ErrorOrResult<vk::StagingImage> RendererVk::createStagingImage(TextureDimension dimension,
-                                                                   const vk::Format &format,
-                                                                   const gl::Extents &extent)
+vk::Error RendererVk::createStagingImage(TextureDimension dimension,
+                                         const vk::Format &format,
+                                         const gl::Extents &extent,
+                                         vk::StagingImage *imageOut)
 {
     ASSERT(mHostVisibleMemoryIndex != std::numeric_limits<uint32_t>::max());
 
-    vk::StagingImage stagingImage(mDevice);
-    ANGLE_TRY(stagingImage.init(mCurrentQueueFamilyIndex, mHostVisibleMemoryIndex, dimension,
-                                format.native, extent));
+    ANGLE_TRY(imageOut->init(mDevice, mCurrentQueueFamilyIndex, mHostVisibleMemoryIndex, dimension,
+                             format.native, extent));
 
-    return std::move(stagingImage);
+    return vk::NoError();
 }
 
 GlslangWrapper *RendererVk::getGlslangWrapper()

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -60,9 +60,10 @@ class RendererVk : angle::NonCopyable
     const gl::Extensions &getNativeExtensions() const;
     const gl::Limitations &getNativeLimitations() const;
 
-    vk::ErrorOrResult<vk::StagingImage> createStagingImage(TextureDimension dimension,
-                                                           const vk::Format &format,
-                                                           const gl::Extents &extent);
+    vk::Error createStagingImage(TextureDimension dimension,
+                                 const vk::Format &format,
+                                 const gl::Extents &extent,
+                                 vk::StagingImage *imageOut);
 
     GlslangWrapper *getGlslangWrapper();
 
@@ -90,8 +91,8 @@ class RendererVk : angle::NonCopyable
     VkQueue mQueue;
     uint32_t mCurrentQueueFamilyIndex;
     VkDevice mDevice;
-    std::unique_ptr<vk::CommandPool> mCommandPool;
-    std::unique_ptr<vk::CommandBuffer> mCommandBuffer;
+    vk::CommandPool mCommandPool;
+    vk::CommandBuffer mCommandBuffer;
     uint32_t mHostVisibleMemoryIndex;
     GlslangWrapper *mGlslangWrapper;
 };

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -133,8 +133,6 @@ WindowSurfaceVk::~WindowSurfaceVk()
 {
     ASSERT(mSurface == VK_NULL_HANDLE);
     ASSERT(mSwapchain == VK_NULL_HANDLE);
-    ASSERT(mSwapchainImages.empty());
-    ASSERT(mSwapchainImageViews.empty());
 }
 
 void WindowSurfaceVk::destroy(const DisplayImpl *displayImpl)
@@ -144,20 +142,23 @@ void WindowSurfaceVk::destroy(const DisplayImpl *displayImpl)
     VkDevice device            = rendererVk->getDevice();
     VkInstance instance        = rendererVk->getInstance();
 
+    mPresentCompleteSemaphore.destroy(device);
+
     for (auto &imageView : mSwapchainImageViews)
     {
         imageView.destroy(device);
     }
 
-    mSwapchainImageViews.clear();
-
     // Although we don't own the swapchain image handles, we need to keep our shutdown clean.
     for (auto &image : mSwapchainImages)
     {
         image.reset();
     }
 
-    mSwapchainImages.clear();
+    for (auto &framebuffer : mSwapchainFramebuffers)
+    {
+        framebuffer.destroy(device);
+    }
 
     if (mSwapchain)
     {
@@ -331,7 +332,7 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
 
     // CommandBuffer is a singleton in the Renderer.
     vk::CommandBuffer *commandBuffer = renderer->getCommandBuffer();
-    ANGLE_TRY(commandBuffer->begin());
+    ANGLE_TRY(commandBuffer->begin(device));
 
     VkClearColorValue transparentBlack;
     transparentBlack.float32[0] = 0.0f;
@@ -339,8 +340,13 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
     transparentBlack.float32[2] = 0.0f;
     transparentBlack.float32[3] = 0.0f;
 
-    for (auto swapchainImage : swapchainImages)
+    mSwapchainImages.resize(imageCount);
+    mSwapchainImageViews.resize(imageCount);
+
+    for (uint32_t imageIndex = 0; imageIndex < imageCount; ++imageIndex)
     {
+        VkImage swapchainImage = swapchainImages[imageIndex];
+
         VkImageViewCreateInfo imageViewInfo;
         imageViewInfo.sType                           = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
         imageViewInfo.pNext                           = nullptr;
@@ -359,16 +365,16 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
         imageViewInfo.subresourceRange.layerCount     = 1;
 
         vk::Image image(swapchainImage);
-        vk::ImageView imageView(device);
-        ANGLE_TRY(imageView.init(imageViewInfo));
+        vk::ImageView imageView;
+        ANGLE_TRY(imageView.init(device, imageViewInfo));
 
         // Set transfer dest layout, and clear the image to black.
         image.changeLayoutTop(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                               commandBuffer);
         commandBuffer->clearSingleColorImage(image, transparentBlack);
 
-        mSwapchainImages.push_back(std::move(image));
-        mSwapchainImageViews.push_back(std::move(imageView));
+        mSwapchainImages[imageIndex].retain(device, std::move(image));
+        mSwapchainImageViews[imageIndex].retain(device, std::move(imageView));
     }
 
     ANGLE_TRY(commandBuffer->end());
@@ -397,7 +403,7 @@ vk::Error WindowSurfaceVk::swapImpl(RendererVk *renderer)
 
     auto *image = &mSwapchainImages[mCurrentSwapchainImageIndex];
 
-    currentCB->begin();
+    currentCB->begin(renderer->getDevice());
     image->changeLayoutWithStages(VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                                   VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, currentCB);
@@ -427,14 +433,14 @@ vk::Error WindowSurfaceVk::nextSwapchainImage(RendererVk *renderer)
 {
     VkDevice device = renderer->getDevice();
 
-    vk::Semaphore presentComplete(device);
-    ANGLE_TRY(presentComplete.init());
+    vk::Semaphore presentComplete;
+    ANGLE_TRY(presentComplete.init(device));
 
     ANGLE_VK_TRY(vkAcquireNextImageKHR(device, mSwapchain, std::numeric_limits<uint64_t>::max(),
                                        presentComplete.getHandle(), VK_NULL_HANDLE,
                                        &mCurrentSwapchainImageIndex));
 
-    mPresentCompleteSemaphore = std::move(presentComplete);
+    mPresentCompleteSemaphore.retain(device, std::move(presentComplete));
 
     // Update RenderTarget pointers.
     mRenderTarget.image     = &mSwapchainImages[mCurrentSwapchainImageIndex];
@@ -522,15 +528,17 @@ gl::ErrorOrResult<vk::Framebuffer *> WindowSurfaceVk::getCurrentFramebuffer(
     framebufferInfo.height          = static_cast<uint32_t>(mRenderTarget.extents.height);
     framebufferInfo.layers          = 1;
 
-    for (const auto &imageView : mSwapchainImageViews)
+    mSwapchainFramebuffers.resize(mSwapchainImageViews.size());
+    for (size_t imageIndex = 0; imageIndex < mSwapchainFramebuffers.size(); ++imageIndex)
     {
+        const auto &imageView        = mSwapchainImageViews[imageIndex];
         VkImageView imageViewHandle  = imageView.getHandle();
         framebufferInfo.pAttachments = &imageViewHandle;
 
-        vk::Framebuffer framebuffer(device);
-        ANGLE_TRY(framebuffer.init(framebufferInfo));
+        vk::Framebuffer framebuffer;
+        ANGLE_TRY(framebuffer.init(device, framebufferInfo));
 
-        mSwapchainFramebuffers.push_back(std::move(framebuffer));
+        mSwapchainFramebuffers[imageIndex].retain(device, std::move(framebuffer));
     }
 
     // We should only initialize framebuffers on the first swap.