src/dawn_native/d3d12/SwapChainD3D12.cpp - dawn - Git at Google

 // Copyright 2017 The Dawn Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "dawn_native/d3d12/SwapChainD3D12.h"

 #include "dawn_native/Surface.h"
 #include "dawn_native/d3d12/D3D12Error.h"
 #include "dawn_native/d3d12/DeviceD3D12.h"
 #include "dawn_native/d3d12/TextureD3D12.h"

 #include <dawn/dawn_wsi.h>

 #include <windows.ui.xaml.media.dxinterop.h>

 namespace dawn_native { namespace d3d12 {
     namespace {

         uint32_t PresentModeToBufferCount(wgpu::PresentMode mode) {
             switch (mode) {
                 case wgpu::PresentMode::Immediate:
                 case wgpu::PresentMode::Fifo:
                     return 2;
                 case wgpu::PresentMode::Mailbox:
                     return 3;
             }
         }

         uint32_t PresentModeToSwapInterval(wgpu::PresentMode mode) {
             switch (mode) {
                 case wgpu::PresentMode::Immediate:
                 case wgpu::PresentMode::Mailbox:
                     return 0;
                 case wgpu::PresentMode::Fifo:
                     return 1;
             }
         }

         UINT PresentModeToSwapChainFlags(wgpu::PresentMode mode) {
             UINT flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

             if (mode == wgpu::PresentMode::Immediate) {
                 flags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
             }

             return flags;
         }

         DXGI_USAGE ToDXGIUsage(wgpu::TextureUsage usage) {
             DXGI_USAGE dxgiUsage = DXGI_CPU_ACCESS_NONE;
             if (usage & wgpu::TextureUsage::TextureBinding) {
                 dxgiUsage |= DXGI_USAGE_SHADER_INPUT;
             }
             if (usage & wgpu::TextureUsage::StorageBinding) {
                 dxgiUsage |= DXGI_USAGE_UNORDERED_ACCESS;
             }
             if (usage & wgpu::TextureUsage::RenderAttachment) {
                 dxgiUsage |= DXGI_USAGE_RENDER_TARGET_OUTPUT;
             }
             return dxgiUsage;
         }

     }  // namespace

     // OldSwapChain

     // static
     Ref<OldSwapChain> OldSwapChain::Create(Device* device, const SwapChainDescriptor* descriptor) {
         return AcquireRef(new OldSwapChain(device, descriptor));
     }

     OldSwapChain::OldSwapChain(Device* device, const SwapChainDescriptor* descriptor)
         : OldSwapChainBase(device, descriptor) {
         const auto& im = GetImplementation();
         DawnWSIContextD3D12 wsiContext = {};
         wsiContext.device = ToAPI(GetDevice());
         im.Init(im.userData, &wsiContext);

         ASSERT(im.textureUsage != WGPUTextureUsage_None);
         mTextureUsage = static_cast<wgpu::TextureUsage>(im.textureUsage);
     }

     OldSwapChain::~OldSwapChain() = default;

     TextureBase* OldSwapChain::GetNextTextureImpl(const TextureDescriptor* descriptor) {
         DeviceBase* device = GetDevice();
         const auto& im = GetImplementation();
         DawnSwapChainNextTexture next = {};
         DawnSwapChainError error = im.GetNextTexture(im.userData, &next);
         if (error) {
             device->HandleError(InternalErrorType::Internal, error);
             return nullptr;
         }

         ComPtr<ID3D12Resource> d3d12Texture = static_cast<ID3D12Resource*>(next.texture.ptr);
         Ref<Texture> dawnTexture;
         if (device->ConsumedError(
                 Texture::Create(ToBackend(GetDevice()), descriptor, std::move(d3d12Texture)),
                 &dawnTexture)) {
             return nullptr;
         }

         return dawnTexture.Detach();
     }

     MaybeError OldSwapChain::OnBeforePresent(TextureViewBase* view) {
         Device* device = ToBackend(GetDevice());

         CommandRecordingContext* commandContext;
         DAWN_TRY_ASSIGN(commandContext, device->GetPendingCommandContext());

         // Perform the necessary transition for the texture to be presented.
         ToBackend(view->GetTexture())
             ->TrackUsageAndTransitionNow(commandContext, mTextureUsage,
                                          view->GetSubresourceRange());

         DAWN_TRY(device->ExecutePendingCommandContext());

         return {};
     }

     // SwapChain

     // static
     ResultOrError<Ref<SwapChain>> SwapChain::Create(Device* device,
                                                 Surface* surface,
                                                 NewSwapChainBase* previousSwapChain,
                                                 const SwapChainDescriptor* descriptor) {
         Ref<SwapChain> swapchain = AcquireRef(new SwapChain(device, surface, descriptor));
         DAWN_TRY(swapchain->Initialize(previousSwapChain));
         return swapchain;
     }

     SwapChain::~SwapChain() = default;

     void SwapChain::DestroyImpl() {
         SwapChainBase::DestroyImpl();
         DetachFromSurface();
     }

     // Initializes the swapchain on the surface. Note that `previousSwapChain` may or may not be
     // nullptr. If it is not nullptr it means that it is the swapchain previously in use on the
     // surface and that we have a chance to reuse it's underlying IDXGISwapChain and "buffers".
     MaybeError SwapChain::Initialize(NewSwapChainBase* previousSwapChain) {
         ASSERT(GetSurface()->GetType() == Surface::Type::WindowsHWND);

         // Precompute the configuration parameters we want for the DXGI swapchain.
         mConfig.bufferCount = PresentModeToBufferCount(GetPresentMode());
         mConfig.format = D3D12TextureFormat(GetFormat());
         mConfig.swapChainFlags = PresentModeToSwapChainFlags(GetPresentMode());
         mConfig.usage = ToDXGIUsage(GetUsage());

         // There is no previous swapchain so we can create one directly and don't have anything else
         // to do.
         if (previousSwapChain == nullptr) {
             return InitializeSwapChainFromScratch();
         }

         // TODO(crbug.com/dawn/269): figure out what should happen when surfaces are used by
         // multiple backends one after the other. It probably needs to block until the backend
         // and GPU are completely finished with the previous swapchain.
         DAWN_INVALID_IF(previousSwapChain->GetBackendType() != wgpu::BackendType::D3D12,
                         "D3D12 SwapChain cannot switch backend types from %s to %s.",
                         previousSwapChain->GetBackendType(), wgpu::BackendType::D3D12);

         // TODO(crbug.com/dawn/269): use ToBackend once OldSwapChainBase is removed.
         SwapChain* previousD3D12SwapChain = static_cast<SwapChain*>(previousSwapChain);

         // TODO(crbug.com/dawn/269): Figure out switching an HWND between devices, it might
         // require just losing the reference to the swapchain, but might also need to wait for
         // all previous operations to complete.
         DAWN_INVALID_IF(GetDevice() != previousSwapChain->GetDevice(),
                         "D3D12 SwapChain cannot switch between D3D Devices");

         // The previous swapchain is on the same device so we want to reuse it but it is still not
         // always possible. Because DXGI requires that a new swapchain be created if the
         // DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING flag is changed.
         bool canReuseSwapChain =
             ((mConfig.swapChainFlags ^ previousD3D12SwapChain->mConfig.swapChainFlags) &
              DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING) == 0;

         // We can't reuse the previous swapchain, so we destroy it and wait for all of its reference
         // to be forgotten (otherwise DXGI complains that there are outstanding references).
         if (!canReuseSwapChain) {
             DAWN_TRY(previousD3D12SwapChain->DetachAndWaitForDeallocation());
             return InitializeSwapChainFromScratch();
         }

         // After all this we know we can reuse the swapchain, see if it is possible to also reuse
         // the buffers.
         mDXGISwapChain = std::move(previousD3D12SwapChain->mDXGISwapChain);

         bool canReuseBuffers = GetWidth() == previousSwapChain->GetWidth() &&
                                GetHeight() == previousSwapChain->GetHeight() &&
                                GetFormat() == previousSwapChain->GetFormat() &&
                                GetPresentMode() == previousSwapChain->GetPresentMode();
         if (canReuseBuffers) {
             mBuffers = std::move(previousD3D12SwapChain->mBuffers);
             mBufferLastUsedSerials = std::move(previousD3D12SwapChain->mBufferLastUsedSerials);
             mCurrentBuffer = previousD3D12SwapChain->mCurrentBuffer;
             return {};
         }

         // We can't reuse the buffers so we need to resize, IDXGSwapChain->ResizeBuffers requires
         // that all references to buffers are lost before it is called. Contrary to D3D11, the
         // application is responsible for keeping references to the buffers until the GPU is done
         // using them so we have no choice but to synchrounously wait for all operations to complete
         // on the previous swapchain and then lose references to its buffers.
         DAWN_TRY(previousD3D12SwapChain->DetachAndWaitForDeallocation());
         DAWN_TRY(
             CheckHRESULT(mDXGISwapChain->ResizeBuffers(mConfig.bufferCount, GetWidth(), GetHeight(),
                                                        mConfig.format, mConfig.swapChainFlags),
                          "IDXGISwapChain::ResizeBuffer"));
         return CollectSwapChainBuffers();
     }

     MaybeError SwapChain::InitializeSwapChainFromScratch() {
         ASSERT(mDXGISwapChain == nullptr);

         Device* device = ToBackend(GetDevice());

         DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
         swapChainDesc.Width = GetWidth();
         swapChainDesc.Height = GetHeight();
         swapChainDesc.Format = mConfig.format;
         swapChainDesc.Stereo = false;
         swapChainDesc.SampleDesc.Count = 1;
         swapChainDesc.SampleDesc.Quality = 0;
         swapChainDesc.BufferUsage = mConfig.usage;
         swapChainDesc.BufferCount = mConfig.bufferCount;
         swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
         swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
         swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
         swapChainDesc.Flags = mConfig.swapChainFlags;

         ComPtr<IDXGIFactory2> factory2 = nullptr;
         DAWN_TRY(CheckHRESULT(device->GetFactory()->QueryInterface(IID_PPV_ARGS(&factory2)),
                               "Getting IDXGIFactory2"));

         ComPtr<IDXGISwapChain1> swapChain1;
         switch (GetSurface()->GetType()) {
             case Surface::Type::WindowsHWND: {
                 DAWN_TRY(CheckHRESULT(
                     factory2->CreateSwapChainForHwnd(device->GetCommandQueue().Get(),
                                                      static_cast<HWND>(GetSurface()->GetHWND()),
                                                      &swapChainDesc, nullptr, nullptr, &swapChain1),
                     "Creating the IDXGISwapChain1"));
                 break;
             }
             case Surface::Type::WindowsCoreWindow: {
                 DAWN_TRY(CheckHRESULT(
                     factory2->CreateSwapChainForCoreWindow(device->GetCommandQueue().Get(),
                                                            GetSurface()->GetCoreWindow(),
                                                            &swapChainDesc, nullptr, &swapChain1),
                     "Creating the IDXGISwapChain1"));
                 break;
             }
             case Surface::Type::WindowsSwapChainPanel: {
                 DAWN_TRY(CheckHRESULT(
                     factory2->CreateSwapChainForComposition(device->GetCommandQueue().Get(),
                                                             &swapChainDesc, nullptr, &swapChain1),
                     "Creating the IDXGISwapChain1"));
                 ComPtr<ISwapChainPanelNative> swapChainPanelNative;
                 DAWN_TRY(CheckHRESULT(GetSurface()->GetSwapChainPanel()->QueryInterface(
                                           IID_PPV_ARGS(&swapChainPanelNative)),
                                       "Getting ISwapChainPanelNative"));
                 DAWN_TRY(CheckHRESULT(swapChainPanelNative->SetSwapChain(swapChain1.Get()),
                                       "Setting SwapChain"));
                 break;
             }
             default:
                 UNREACHABLE();
         }

         DAWN_TRY(CheckHRESULT(swapChain1.As(&mDXGISwapChain), "Gettting IDXGISwapChain1"));

         return CollectSwapChainBuffers();
     }

     MaybeError SwapChain::CollectSwapChainBuffers() {
         ASSERT(mDXGISwapChain != nullptr);
         ASSERT(mBuffers.empty());

         mBuffers.resize(mConfig.bufferCount);
         for (uint32_t i = 0; i < mConfig.bufferCount; i++) {
             DAWN_TRY(CheckHRESULT(mDXGISwapChain->GetBuffer(i, IID_PPV_ARGS(&mBuffers[i])),
                                   "Getting IDXGISwapChain buffer"));
         }

         // Pretend all the buffers were last used at the beginning of time.
         mBufferLastUsedSerials.resize(mConfig.bufferCount, ExecutionSerial(0));
         return {};
     }

     MaybeError SwapChain::PresentImpl() {
         Device* device = ToBackend(GetDevice());

         // Transition the texture to the present state as required by IDXGISwapChain1::Present()
         // TODO(crbug.com/dawn/269): Remove the need for this by eagerly transitioning the
         // presentable texture to present at the end of submits that use them.
         CommandRecordingContext* commandContext;
         DAWN_TRY_ASSIGN(commandContext, device->GetPendingCommandContext());
         mApiTexture->TrackUsageAndTransitionNow(commandContext, kPresentTextureUsage,
                                                 mApiTexture->GetAllSubresources());
         DAWN_TRY(device->ExecutePendingCommandContext());

         // Do the actual present. DXGI_STATUS_OCCLUDED is a valid return value that's just a
         // message to the application that it could stop rendering.
         HRESULT presentResult =
             mDXGISwapChain->Present(PresentModeToSwapInterval(GetPresentMode()), 0);
         if (presentResult != DXGI_STATUS_OCCLUDED) {
             DAWN_TRY(CheckHRESULT(presentResult, "IDXGISwapChain::Present"));
         }

         // Record that "new" is the last time the buffer has been used.
         DAWN_TRY(device->NextSerial());
         mBufferLastUsedSerials[mCurrentBuffer] = device->GetPendingCommandSerial();

         mApiTexture->APIDestroy();
         mApiTexture = nullptr;

         return {};
     }

     ResultOrError<TextureViewBase*> SwapChain::GetCurrentTextureViewImpl() {
         Device* device = ToBackend(GetDevice());

         // Synchronously wait until previous operations on the next swapchain buffer are finished.
         // This is the logic that performs frame pacing.
         // TODO(crbug.com/dawn/269): Consider whether this should  be lifted for Mailbox so that
         // there is not frame pacing.
         mCurrentBuffer = mDXGISwapChain->GetCurrentBackBufferIndex();
         DAWN_TRY(device->WaitForSerial(mBufferLastUsedSerials[mCurrentBuffer]));

         // Create the API side objects for this use of the swapchain's buffer.
         TextureDescriptor descriptor = GetSwapChainBaseTextureDescriptor(this);
         DAWN_TRY_ASSIGN(mApiTexture, Texture::Create(ToBackend(GetDevice()), &descriptor,
                                                      mBuffers[mCurrentBuffer]));

         // TODO(dawn:723): change to not use AcquireRef for reentrant object creation.
         return mApiTexture->APICreateView();
     }

     MaybeError SwapChain::DetachAndWaitForDeallocation() {
         DetachFromSurface();

         // DetachFromSurface calls Texture->Destroy that enqueues the D3D12 resource in a
         // SerialQueue with the current "pending serial" so that we don't destroy the texture
         // before it is finished being used. Flush the commands and wait for that serial to be
         // passed, then Tick the device to make sure the reference to the D3D12 texture is removed.
         Device* device = ToBackend(GetDevice());
         DAWN_TRY(device->NextSerial());
         DAWN_TRY(device->WaitForSerial(device->GetLastSubmittedCommandSerial()));
         return device->TickImpl();
     }

     void SwapChain::DetachFromSurfaceImpl() {
         if (mApiTexture != nullptr) {
             mApiTexture->APIDestroy();
             mApiTexture = nullptr;
         }

         mDXGISwapChain = nullptr;
         mBuffers.clear();
     }

 }}  // namespace dawn_native::d3d12
	// Copyright 2017 The Dawn Authors
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "dawn_native/d3d12/SwapChainD3D12.h"

	#include "dawn_native/Surface.h"
	#include "dawn_native/d3d12/D3D12Error.h"
	#include "dawn_native/d3d12/DeviceD3D12.h"
	#include "dawn_native/d3d12/TextureD3D12.h"

	#include <dawn/dawn_wsi.h>

	#include <windows.ui.xaml.media.dxinterop.h>

	namespace dawn_native { namespace d3d12 {
	namespace {

	uint32_t PresentModeToBufferCount(wgpu::PresentMode mode) {
	switch (mode) {
	case wgpu::PresentMode::Immediate:
	case wgpu::PresentMode::Fifo:
	return 2;
	case wgpu::PresentMode::Mailbox:
	return 3;
	}
	}

	uint32_t PresentModeToSwapInterval(wgpu::PresentMode mode) {
	switch (mode) {
	case wgpu::PresentMode::Immediate:
	case wgpu::PresentMode::Mailbox:
	return 0;
	case wgpu::PresentMode::Fifo:
	return 1;
	}
	}

	UINT PresentModeToSwapChainFlags(wgpu::PresentMode mode) {
	UINT flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

	if (mode == wgpu::PresentMode::Immediate) {
	flags \|= DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING;
	}

	return flags;
	}

	DXGI_USAGE ToDXGIUsage(wgpu::TextureUsage usage) {
	DXGI_USAGE dxgiUsage = DXGI_CPU_ACCESS_NONE;
	if (usage & wgpu::TextureUsage::TextureBinding) {
	dxgiUsage \|= DXGI_USAGE_SHADER_INPUT;
	}
	if (usage & wgpu::TextureUsage::StorageBinding) {
	dxgiUsage \|= DXGI_USAGE_UNORDERED_ACCESS;
	}
	if (usage & wgpu::TextureUsage::RenderAttachment) {
	dxgiUsage \|= DXGI_USAGE_RENDER_TARGET_OUTPUT;
	}
	return dxgiUsage;
	}

	} // namespace

	// OldSwapChain

	// static
	Ref<OldSwapChain> OldSwapChain::Create(Device* device, const SwapChainDescriptor* descriptor) {
	return AcquireRef(new OldSwapChain(device, descriptor));
	}

	OldSwapChain::OldSwapChain(Device* device, const SwapChainDescriptor* descriptor)
	: OldSwapChainBase(device, descriptor) {
	const auto& im = GetImplementation();
	DawnWSIContextD3D12 wsiContext = {};
	wsiContext.device = ToAPI(GetDevice());
	im.Init(im.userData, &wsiContext);

	ASSERT(im.textureUsage != WGPUTextureUsage_None);
	mTextureUsage = static_cast<wgpu::TextureUsage>(im.textureUsage);
	}

	OldSwapChain::~OldSwapChain() = default;

	TextureBase* OldSwapChain::GetNextTextureImpl(const TextureDescriptor* descriptor) {
	DeviceBase* device = GetDevice();
	const auto& im = GetImplementation();
	DawnSwapChainNextTexture next = {};
	DawnSwapChainError error = im.GetNextTexture(im.userData, &next);
	if (error) {
	device->HandleError(InternalErrorType::Internal, error);
	return nullptr;
	}

	ComPtr<ID3D12Resource> d3d12Texture = static_cast<ID3D12Resource*>(next.texture.ptr);
	Ref<Texture> dawnTexture;
	if (device->ConsumedError(
	Texture::Create(ToBackend(GetDevice()), descriptor, std::move(d3d12Texture)),
	&dawnTexture)) {
	return nullptr;
	}

	return dawnTexture.Detach();
	}

	MaybeError OldSwapChain::OnBeforePresent(TextureViewBase* view) {
	Device* device = ToBackend(GetDevice());

	CommandRecordingContext* commandContext;
	DAWN_TRY_ASSIGN(commandContext, device->GetPendingCommandContext());

	// Perform the necessary transition for the texture to be presented.
	ToBackend(view->GetTexture())
	->TrackUsageAndTransitionNow(commandContext, mTextureUsage,
	view->GetSubresourceRange());

	DAWN_TRY(device->ExecutePendingCommandContext());

	return {};
	}

	// SwapChain

	// static
	ResultOrError<Ref<SwapChain>> SwapChain::Create(Device* device,
	Surface* surface,
	NewSwapChainBase* previousSwapChain,
	const SwapChainDescriptor* descriptor) {
	Ref<SwapChain> swapchain = AcquireRef(new SwapChain(device, surface, descriptor));
	DAWN_TRY(swapchain->Initialize(previousSwapChain));
	return swapchain;
	}

	SwapChain::~SwapChain() = default;

	void SwapChain::DestroyImpl() {
	SwapChainBase::DestroyImpl();
	DetachFromSurface();
	}

	// Initializes the swapchain on the surface. Note that `previousSwapChain` may or may not be
	// nullptr. If it is not nullptr it means that it is the swapchain previously in use on the
	// surface and that we have a chance to reuse it's underlying IDXGISwapChain and "buffers".
	MaybeError SwapChain::Initialize(NewSwapChainBase* previousSwapChain) {
	ASSERT(GetSurface()->GetType() == Surface::Type::WindowsHWND);

	// Precompute the configuration parameters we want for the DXGI swapchain.
	mConfig.bufferCount = PresentModeToBufferCount(GetPresentMode());
	mConfig.format = D3D12TextureFormat(GetFormat());
	mConfig.swapChainFlags = PresentModeToSwapChainFlags(GetPresentMode());
	mConfig.usage = ToDXGIUsage(GetUsage());

	// There is no previous swapchain so we can create one directly and don't have anything else
	// to do.
	if (previousSwapChain == nullptr) {
	return InitializeSwapChainFromScratch();
	}

	// TODO(crbug.com/dawn/269): figure out what should happen when surfaces are used by
	// multiple backends one after the other. It probably needs to block until the backend
	// and GPU are completely finished with the previous swapchain.
	DAWN_INVALID_IF(previousSwapChain->GetBackendType() != wgpu::BackendType::D3D12,
	"D3D12 SwapChain cannot switch backend types from %s to %s.",
	previousSwapChain->GetBackendType(), wgpu::BackendType::D3D12);

	// TODO(crbug.com/dawn/269): use ToBackend once OldSwapChainBase is removed.
	SwapChain* previousD3D12SwapChain = static_cast<SwapChain*>(previousSwapChain);

	// TODO(crbug.com/dawn/269): Figure out switching an HWND between devices, it might
	// require just losing the reference to the swapchain, but might also need to wait for
	// all previous operations to complete.
	DAWN_INVALID_IF(GetDevice() != previousSwapChain->GetDevice(),
	"D3D12 SwapChain cannot switch between D3D Devices");

	// The previous swapchain is on the same device so we want to reuse it but it is still not
	// always possible. Because DXGI requires that a new swapchain be created if the
	// DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING flag is changed.
	bool canReuseSwapChain =
	((mConfig.swapChainFlags ^ previousD3D12SwapChain->mConfig.swapChainFlags) &
	DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING) == 0;

	// We can't reuse the previous swapchain, so we destroy it and wait for all of its reference
	// to be forgotten (otherwise DXGI complains that there are outstanding references).
	if (!canReuseSwapChain) {
	DAWN_TRY(previousD3D12SwapChain->DetachAndWaitForDeallocation());
	return InitializeSwapChainFromScratch();
	}

	// After all this we know we can reuse the swapchain, see if it is possible to also reuse
	// the buffers.
	mDXGISwapChain = std::move(previousD3D12SwapChain->mDXGISwapChain);

	bool canReuseBuffers = GetWidth() == previousSwapChain->GetWidth() &&
	GetHeight() == previousSwapChain->GetHeight() &&
	GetFormat() == previousSwapChain->GetFormat() &&
	GetPresentMode() == previousSwapChain->GetPresentMode();
	if (canReuseBuffers) {
	mBuffers = std::move(previousD3D12SwapChain->mBuffers);
	mBufferLastUsedSerials = std::move(previousD3D12SwapChain->mBufferLastUsedSerials);
	mCurrentBuffer = previousD3D12SwapChain->mCurrentBuffer;
	return {};
	}

	// We can't reuse the buffers so we need to resize, IDXGSwapChain->ResizeBuffers requires
	// that all references to buffers are lost before it is called. Contrary to D3D11, the
	// application is responsible for keeping references to the buffers until the GPU is done
	// using them so we have no choice but to synchrounously wait for all operations to complete
	// on the previous swapchain and then lose references to its buffers.
	DAWN_TRY(previousD3D12SwapChain->DetachAndWaitForDeallocation());
	DAWN_TRY(
	CheckHRESULT(mDXGISwapChain->ResizeBuffers(mConfig.bufferCount, GetWidth(), GetHeight(),
	mConfig.format, mConfig.swapChainFlags),
	"IDXGISwapChain::ResizeBuffer"));
	return CollectSwapChainBuffers();
	}

	MaybeError SwapChain::InitializeSwapChainFromScratch() {
	ASSERT(mDXGISwapChain == nullptr);

	Device* device = ToBackend(GetDevice());

	DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {};
	swapChainDesc.Width = GetWidth();
	swapChainDesc.Height = GetHeight();
	swapChainDesc.Format = mConfig.format;
	swapChainDesc.Stereo = false;
	swapChainDesc.SampleDesc.Count = 1;
	swapChainDesc.SampleDesc.Quality = 0;
	swapChainDesc.BufferUsage = mConfig.usage;
	swapChainDesc.BufferCount = mConfig.bufferCount;
	swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
	swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
	swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_IGNORE;
	swapChainDesc.Flags = mConfig.swapChainFlags;

	ComPtr<IDXGIFactory2> factory2 = nullptr;
	DAWN_TRY(CheckHRESULT(device->GetFactory()->QueryInterface(IID_PPV_ARGS(&factory2)),
	"Getting IDXGIFactory2"));

	ComPtr<IDXGISwapChain1> swapChain1;
	switch (GetSurface()->GetType()) {
	case Surface::Type::WindowsHWND: {
	DAWN_TRY(CheckHRESULT(
	factory2->CreateSwapChainForHwnd(device->GetCommandQueue().Get(),
	static_cast<HWND>(GetSurface()->GetHWND()),
	&swapChainDesc, nullptr, nullptr, &swapChain1),
	"Creating the IDXGISwapChain1"));
	break;
	}
	case Surface::Type::WindowsCoreWindow: {
	DAWN_TRY(CheckHRESULT(
	factory2->CreateSwapChainForCoreWindow(device->GetCommandQueue().Get(),
	GetSurface()->GetCoreWindow(),
	&swapChainDesc, nullptr, &swapChain1),
	"Creating the IDXGISwapChain1"));
	break;
	}
	case Surface::Type::WindowsSwapChainPanel: {
	DAWN_TRY(CheckHRESULT(
	factory2->CreateSwapChainForComposition(device->GetCommandQueue().Get(),
	&swapChainDesc, nullptr, &swapChain1),
	"Creating the IDXGISwapChain1"));
	ComPtr<ISwapChainPanelNative> swapChainPanelNative;
	DAWN_TRY(CheckHRESULT(GetSurface()->GetSwapChainPanel()->QueryInterface(
	IID_PPV_ARGS(&swapChainPanelNative)),
	"Getting ISwapChainPanelNative"));
	DAWN_TRY(CheckHRESULT(swapChainPanelNative->SetSwapChain(swapChain1.Get()),
	"Setting SwapChain"));
	break;
	}
	default:
	UNREACHABLE();
	}

	DAWN_TRY(CheckHRESULT(swapChain1.As(&mDXGISwapChain), "Gettting IDXGISwapChain1"));

	return CollectSwapChainBuffers();
	}

	MaybeError SwapChain::CollectSwapChainBuffers() {
	ASSERT(mDXGISwapChain != nullptr);
	ASSERT(mBuffers.empty());

	mBuffers.resize(mConfig.bufferCount);
	for (uint32_t i = 0; i < mConfig.bufferCount; i++) {
	DAWN_TRY(CheckHRESULT(mDXGISwapChain->GetBuffer(i, IID_PPV_ARGS(&mBuffers[i])),
	"Getting IDXGISwapChain buffer"));
	}

	// Pretend all the buffers were last used at the beginning of time.
	mBufferLastUsedSerials.resize(mConfig.bufferCount, ExecutionSerial(0));
	return {};
	}

	MaybeError SwapChain::PresentImpl() {
	Device* device = ToBackend(GetDevice());

	// Transition the texture to the present state as required by IDXGISwapChain1::Present()
	// TODO(crbug.com/dawn/269): Remove the need for this by eagerly transitioning the
	// presentable texture to present at the end of submits that use them.
	CommandRecordingContext* commandContext;
	DAWN_TRY_ASSIGN(commandContext, device->GetPendingCommandContext());
	mApiTexture->TrackUsageAndTransitionNow(commandContext, kPresentTextureUsage,
	mApiTexture->GetAllSubresources());
	DAWN_TRY(device->ExecutePendingCommandContext());

	// Do the actual present. DXGI_STATUS_OCCLUDED is a valid return value that's just a
	// message to the application that it could stop rendering.
	HRESULT presentResult =
	mDXGISwapChain->Present(PresentModeToSwapInterval(GetPresentMode()), 0);
	if (presentResult != DXGI_STATUS_OCCLUDED) {
	DAWN_TRY(CheckHRESULT(presentResult, "IDXGISwapChain::Present"));
	}

	// Record that "new" is the last time the buffer has been used.
	DAWN_TRY(device->NextSerial());
	mBufferLastUsedSerials[mCurrentBuffer] = device->GetPendingCommandSerial();

	mApiTexture->APIDestroy();
	mApiTexture = nullptr;

	return {};
	}

	ResultOrError<TextureViewBase*> SwapChain::GetCurrentTextureViewImpl() {
	Device* device = ToBackend(GetDevice());

	// Synchronously wait until previous operations on the next swapchain buffer are finished.
	// This is the logic that performs frame pacing.
	// TODO(crbug.com/dawn/269): Consider whether this should be lifted for Mailbox so that
	// there is not frame pacing.
	mCurrentBuffer = mDXGISwapChain->GetCurrentBackBufferIndex();
	DAWN_TRY(device->WaitForSerial(mBufferLastUsedSerials[mCurrentBuffer]));

	// Create the API side objects for this use of the swapchain's buffer.
	TextureDescriptor descriptor = GetSwapChainBaseTextureDescriptor(this);
	DAWN_TRY_ASSIGN(mApiTexture, Texture::Create(ToBackend(GetDevice()), &descriptor,
	mBuffers[mCurrentBuffer]));

	// TODO(dawn:723): change to not use AcquireRef for reentrant object creation.
	return mApiTexture->APICreateView();
	}

	MaybeError SwapChain::DetachAndWaitForDeallocation() {
	DetachFromSurface();

	// DetachFromSurface calls Texture->Destroy that enqueues the D3D12 resource in a
	// SerialQueue with the current "pending serial" so that we don't destroy the texture
	// before it is finished being used. Flush the commands and wait for that serial to be
	// passed, then Tick the device to make sure the reference to the D3D12 texture is removed.
	Device* device = ToBackend(GetDevice());
	DAWN_TRY(device->NextSerial());
	DAWN_TRY(device->WaitForSerial(device->GetLastSubmittedCommandSerial()));
	return device->TickImpl();
	}

	void SwapChain::DetachFromSurfaceImpl() {
	if (mApiTexture != nullptr) {
	mApiTexture->APIDestroy();
	mApiTexture = nullptr;
	}

	mDXGISwapChain = nullptr;
	mBuffers.clear();
	}

	}} // namespace dawn_native::d3d12