diff --git a/src/dawn/native/d3d11/BindGroupTrackerD3D11.cpp b/src/dawn/native/d3d11/BindGroupTrackerD3D11.cpp
index 8629f34..ba2cfbd 100644
--- a/src/dawn/native/d3d11/BindGroupTrackerD3D11.cpp
+++ b/src/dawn/native/d3d11/BindGroupTrackerD3D11.cpp
@@ -190,10 +190,9 @@
                                     bindingInfo.visibility,
                                     wgpu::ShaderStage::Fragment | wgpu::ShaderStage::Compute));
                                 ComPtr<ID3D11UnorderedAccessView> d3d11UAV;
-                                DAWN_TRY_ASSIGN(d3d11UAV, ToGPUOnlyBuffer(binding.buffer)
-                                                              ->CreateD3D11UnorderedAccessView1(
-                                                                  offset, binding.size));
-                                ToGPUOnlyBuffer(binding.buffer)->MarkMutated();
+                                DAWN_TRY_ASSIGN(d3d11UAV, ToGPUUsableBuffer(binding.buffer)
+                                                              ->UseAsUAV(mCommandContext, offset,
+                                                                         binding.size));
                                 uavsInBindGroup.insert(uavsInBindGroup.begin(),
                                                        std::move(d3d11UAV));
                                 break;
@@ -309,10 +308,9 @@
 
                 switch (layout.type) {
                     case wgpu::BufferBindingType::Uniform: {
-                        ToGPUOnlyBuffer(binding.buffer)
-                            ->EnsureConstantBufferIsUpdated(mCommandContext);
-                        ID3D11Buffer* d3d11Buffer =
-                            ToGPUOnlyBuffer(binding.buffer)->GetD3D11ConstantBuffer();
+                        ID3D11Buffer* d3d11Buffer;
+                        DAWN_TRY_ASSIGN(d3d11Buffer, ToGPUUsableBuffer(binding.buffer)
+                                                         ->GetD3D11ConstantBuffer(mCommandContext));
                         // https://learn.microsoft.com/en-us/windows/win32/api/d3d11_1/nf-d3d11_1-id3d11devicecontext1-vssetconstantbuffers1
                         // Offset and size are measured in shader constants, which are 16 bytes
                         // (4*32-bit components). And the offsets and counts must be multiples
@@ -346,10 +344,9 @@
                                      wgpu::ShaderStage::Fragment | wgpu::ShaderStage::Compute));
                         if (bindingVisibility & wgpu::ShaderStage::Compute) {
                             ComPtr<ID3D11UnorderedAccessView> d3d11UAV;
-                            DAWN_TRY_ASSIGN(d3d11UAV, ToGPUOnlyBuffer(binding.buffer)
-                                                          ->CreateD3D11UnorderedAccessView1(
-                                                              offset, binding.size));
-                            ToGPUOnlyBuffer(binding.buffer)->MarkMutated();
+                            DAWN_TRY_ASSIGN(d3d11UAV,
+                                            ToGPUUsableBuffer(binding.buffer)
+                                                ->UseAsUAV(mCommandContext, offset, binding.size));
                             deviceContext->CSSetUnorderedAccessViews(
                                 bindingSlot, 1, d3d11UAV.GetAddressOf(), nullptr);
                         }
@@ -358,8 +355,8 @@
                     case wgpu::BufferBindingType::ReadOnlyStorage: {
                         ComPtr<ID3D11ShaderResourceView> d3d11SRV;
                         DAWN_TRY_ASSIGN(d3d11SRV,
-                                        ToGPUOnlyBuffer(binding.buffer)
-                                            ->CreateD3D11ShaderResourceView(offset, binding.size));
+                                        ToGPUUsableBuffer(binding.buffer)
+                                            ->UseAsSRV(mCommandContext, offset, binding.size));
                         if (bindingVisibility & wgpu::ShaderStage::Vertex) {
                             deviceContext->VSSetShaderResources(bindingSlot, 1,
                                                                 d3d11SRV.GetAddressOf());
diff --git a/src/dawn/native/d3d11/BufferD3D11.cpp b/src/dawn/native/d3d11/BufferD3D11.cpp
index 3401b6b..307e905 100644
--- a/src/dawn/native/d3d11/BufferD3D11.cpp
+++ b/src/dawn/native/d3d11/BufferD3D11.cpp
@@ -52,11 +52,13 @@
 
 namespace {
 
-constexpr wgpu::BufferUsage kD3D11AllowedUniformBufferUsages =
+constexpr wgpu::BufferUsage kD3D11GPUOnlyUniformBufferUsages =
     wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::CopySrc;
 
 constexpr wgpu::BufferUsage kCopyUsages = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
 
+constexpr wgpu::BufferUsage kStagingUsages = kMappableBufferUsages | kCopyUsages;
+
 // Resource usage    Default    Dynamic   Immutable   Staging
 // ------------------------------------------------------------
 //  GPU-read         Yes        Yes       Yes         Yes[1]
@@ -78,7 +80,7 @@
 
 bool IsStaging(wgpu::BufferUsage usage) {
     // Must have at least MapWrite or MapRead bit
-    return IsMappable(usage) && IsSubset(usage, kMappableBufferUsages | kCopyUsages);
+    return IsMappable(usage) && IsSubset(usage, kStagingUsages);
 }
 
 UINT D3D11BufferBindFlags(wgpu::BufferUsage usage) {
@@ -94,6 +96,7 @@
         bindFlags |= D3D11_BIND_CONSTANT_BUFFER;
     }
     if (usage & (wgpu::BufferUsage::Storage | kInternalStorageBuffer)) {
+        DAWN_ASSERT(!IsMappable(usage));
         bindFlags |= D3D11_BIND_UNORDERED_ACCESS;
     }
     if (usage & kReadOnlyStorageBuffer) {
@@ -113,7 +116,7 @@
 
 UINT D3D11BufferMiscFlags(wgpu::BufferUsage usage) {
     UINT miscFlags = 0;
-    if (usage & (wgpu::BufferUsage::Storage | kInternalStorageBuffer)) {
+    if (usage & (wgpu::BufferUsage::Storage | kInternalStorageBuffer | kReadOnlyStorageBuffer)) {
         miscFlags |= D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS;
     }
     if (usage & wgpu::BufferUsage::Indirect) {
@@ -144,9 +147,14 @@
 // For CPU-to-GPU upload buffers(CopySrc|MapWrite), they can be emulated in the system memory, and
 // then written into the dest GPU buffer via ID3D11DeviceContext::UpdateSubresource.
 class UploadBuffer final : public Buffer {
-    using Buffer::Buffer;
+  public:
+    UploadBuffer(DeviceBase* device, const UnpackedPtr<BufferDescriptor>& descriptor)
+        : Buffer(device,
+                 descriptor,
+                 /*internalMappableFlags=*/kMappableBufferUsages) {}
     ~UploadBuffer() override = default;
 
+  private:
     MaybeError InitializeInternal() override {
         mUploadData = std::unique_ptr<uint8_t[]>(AllocNoThrow<uint8_t>(GetAllocatedSize()));
         if (mUploadData == nullptr) {
@@ -155,7 +163,8 @@
         return {};
     }
 
-    MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext) override {
+    MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext,
+                           wgpu::MapMode) override {
         mMappedData = mUploadData.get();
         return {};
     }
@@ -205,8 +214,11 @@
 
 // Buffer that supports mapping and copying.
 class StagingBuffer final : public Buffer {
-    using Buffer::Buffer;
+  public:
+    StagingBuffer(DeviceBase* device, const UnpackedPtr<BufferDescriptor>& descriptor)
+        : Buffer(device, descriptor, /*internalMappableFlags=*/kMappableBufferUsages) {}
 
+  private:
     void DestroyImpl() override {
         // TODO(crbug.com/dawn/831): DestroyImpl is called from two places.
         // - It may be called if the buffer is explicitly destroyed with APIDestroy.
@@ -251,7 +263,8 @@
         return {};
     }
 
-    MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext) override {
+    MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext,
+                           wgpu::MapMode) override {
         DAWN_ASSERT(IsMappable(GetUsage()));
         DAWN_ASSERT(!mMappedData);
 
@@ -317,7 +330,7 @@
         }
 
         ScopedMap scopedMap;
-        DAWN_TRY_ASSIGN(scopedMap, ScopedMap::Create(commandContext, this));
+        DAWN_TRY_ASSIGN(scopedMap, ScopedMap::Create(commandContext, this, wgpu::MapMode::Write));
 
         DAWN_ASSERT(scopedMap.GetMappedData());
         memcpy(scopedMap.GetMappedData() + offset, data, size);
@@ -328,6 +341,65 @@
     ComPtr<ID3D11Buffer> mD3d11Buffer;
 };
 
+// Buffer that can only be written/read by GPU.
+class GPUOnlyBuffer final : public GPUUsableBuffer {
+  public:
+    GPUOnlyBuffer(DeviceBase* device, const UnpackedPtr<BufferDescriptor>& descriptor)
+        : GPUUsableBuffer(device, descriptor, /*internalMappableFlags=*/wgpu::BufferUsage::None) {}
+
+    ResultOrError<ID3D11Buffer*> GetD3D11ConstantBuffer(
+        const ScopedCommandRecordingContext* commandContext) override;
+    ResultOrError<ID3D11Buffer*> GetD3D11NonConstantBuffer(
+        const ScopedCommandRecordingContext* commandContext) override;
+
+    ResultOrError<ComPtr<ID3D11ShaderResourceView>> UseAsSRV(
+        const ScopedCommandRecordingContext* commandContext,
+        uint64_t offset,
+        uint64_t size) override;
+    ResultOrError<ComPtr<ID3D11UnorderedAccessView1>> UseAsUAV(
+        const ScopedCommandRecordingContext* commandContext,
+        uint64_t offset,
+        uint64_t size) override;
+
+    MaybeError PredicatedClear(const ScopedSwapStateCommandRecordingContext* commandContext,
+                               ID3D11Predicate* predicate,
+                               uint8_t clearValue,
+                               uint64_t offset,
+                               uint64_t size) override;
+
+  private:
+    // Dawn API
+    void DestroyImpl() override;
+    void SetLabelImpl() override;
+
+    MaybeError InitializeInternal() override;
+
+    MaybeError CopyToInternal(const ScopedCommandRecordingContext* commandContext,
+                              uint64_t sourceOffset,
+                              size_t size,
+                              Buffer* destination,
+                              uint64_t destinationOffset) override;
+    MaybeError CopyFromD3DInternal(const ScopedCommandRecordingContext* commandContext,
+                                   ID3D11Buffer* srcD3D11Buffer,
+                                   uint64_t sourceOffset,
+                                   size_t size,
+                                   uint64_t destinationOffset) override;
+
+    MaybeError WriteInternal(const ScopedCommandRecordingContext* commandContext,
+                             uint64_t bufferOffset,
+                             const void* data,
+                             size_t size) override;
+
+    MaybeError ClearPaddingInternal(const ScopedCommandRecordingContext* commandContext) override;
+
+    // The buffer object for constant buffer usage.
+    ComPtr<ID3D11Buffer> mD3d11ConstantBuffer;
+    // The buffer object for non-constant buffer usages(e.g. storage buffer, vertex buffer, etc.)
+    ComPtr<ID3D11Buffer> mD3d11NonConstantBuffer;
+
+    bool mConstantBufferIsUpdated = true;
+};
+
 // static
 ResultOrError<Ref<Buffer>> Buffer::Create(Device* device,
                                           const UnpackedPtr<BufferDescriptor>& descriptor,
@@ -349,6 +421,11 @@
     return buffer;
 }
 
+Buffer::Buffer(DeviceBase* device,
+               const UnpackedPtr<BufferDescriptor>& descriptor,
+               wgpu::BufferUsage internalMappableFlags)
+    : BufferBase(device, descriptor), mInternalMappableFlags(internalMappableFlags) {}
+
 MaybeError Buffer::Initialize(bool mappedAtCreation,
                               const ScopedCommandRecordingContext* commandContext) {
     // TODO(dawn:1705): handle mappedAtCreation for NonzeroClearResourcesOnCreationForTesting
@@ -373,14 +450,14 @@
     SetLabelImpl();
 
     if (!mappedAtCreation) {
-            if (commandContext) {
-                DAWN_TRY(ClearInitialResource(commandContext));
-            } else {
-                auto tmpCommandContext =
-                    ToBackend(GetDevice()->GetQueue())
-                        ->GetScopedPendingCommandContext(QueueBase::SubmitMode::Normal);
-                DAWN_TRY(ClearInitialResource(&tmpCommandContext));
-            }
+        if (commandContext) {
+            DAWN_TRY(ClearInitialResource(commandContext));
+        } else {
+            auto tmpCommandContext =
+                ToBackend(GetDevice()->GetQueue())
+                    ->GetScopedPendingCommandContext(QueueBase::SubmitMode::Normal);
+            DAWN_TRY(ClearInitialResource(&tmpCommandContext));
+        }
     }
 
     return {};
@@ -401,18 +478,38 @@
 Buffer::~Buffer() = default;
 
 bool Buffer::IsCPUWritableAtCreation() const {
-    return IsMappable(GetUsage());
+    return IsCPUWritable();
+}
+
+bool Buffer::IsCPUWritable() const {
+    return mInternalMappableFlags & wgpu::BufferUsage::MapWrite;
+}
+
+bool Buffer::IsCPUReadable() const {
+    return mInternalMappableFlags & wgpu::BufferUsage::MapRead;
 }
 
 MaybeError Buffer::MapAtCreationImpl() {
-    DAWN_ASSERT(IsMappable(GetUsage()));
+    DAWN_ASSERT(IsCPUWritable());
     auto commandContext = ToBackend(GetDevice()->GetQueue())
                               ->GetScopedPendingCommandContext(QueueBase::SubmitMode::Normal);
-    return MapInternal(&commandContext);
+    return MapInternal(&commandContext, wgpu::MapMode::Write);
+}
+
+MaybeError Buffer::MapInternal(const ScopedCommandRecordingContext* commandContext,
+                               wgpu::MapMode mode) {
+    DAWN_UNREACHABLE();
+
+    return {};
+}
+
+void Buffer::UnmapInternal(const ScopedCommandRecordingContext* commandContext) {
+    DAWN_UNREACHABLE();
 }
 
 MaybeError Buffer::MapAsyncImpl(wgpu::MapMode mode, size_t offset, size_t size) {
-    DAWN_ASSERT(IsMappable(GetUsage()));
+    DAWN_ASSERT((mode == wgpu::MapMode::Write && IsCPUWritable()) ||
+                (mode == wgpu::MapMode::Read && IsCPUReadable()));
 
     mMapReadySerial = mLastUsageSerial;
     const ExecutionSerial completedSerial = GetDevice()->GetQueue()->GetCompletedCommandSerial();
@@ -420,22 +517,23 @@
     // commands. To avoid that, instead we ask Queue to do the map later when mLastUsageSerial has
     // passed.
     if (mMapReadySerial > completedSerial) {
-        ToBackend(GetDevice()->GetQueue())->TrackPendingMapBuffer({this}, mMapReadySerial);
+        ToBackend(GetDevice()->GetQueue())->TrackPendingMapBuffer({this}, mode, mMapReadySerial);
     } else {
         auto commandContext = ToBackend(GetDevice()->GetQueue())
                                   ->GetScopedPendingCommandContext(QueueBase::SubmitMode::Normal);
-        DAWN_TRY(FinalizeMap(&commandContext, completedSerial));
+        DAWN_TRY(FinalizeMap(&commandContext, completedSerial, mode));
     }
 
     return {};
 }
 
 MaybeError Buffer::FinalizeMap(ScopedCommandRecordingContext* commandContext,
-                               ExecutionSerial completedSerial) {
+                               ExecutionSerial completedSerial,
+                               wgpu::MapMode mode) {
     // Needn't map the buffer if this is for a previous mapAsync that was cancelled.
     if (completedSerial >= mMapReadySerial) {
         // TODO(dawn:1705): make sure the map call is not blocked by the GPU operations.
-        DAWN_TRY(MapInternal(commandContext));
+        DAWN_TRY(MapInternal(commandContext, mode));
 
         DAWN_TRY(EnsureDataInitialized(commandContext));
     }
@@ -525,6 +623,15 @@
     return {};
 }
 
+MaybeError Buffer::PredicatedClear(const ScopedSwapStateCommandRecordingContext* commandContext,
+                                   ID3D11Predicate* predicate,
+                                   uint8_t clearValue,
+                                   uint64_t offset,
+                                   uint64_t size) {
+    DAWN_UNREACHABLE();
+    return {};
+}
+
 MaybeError Buffer::Clear(const ScopedCommandRecordingContext* commandContext,
                          uint8_t clearValue,
                          uint64_t offset,
@@ -538,7 +645,7 @@
     // Map the buffer if it is possible, so EnsureDataInitializedAsDestination() and ClearInternal()
     // can write the mapped memory directly.
     ScopedMap scopedMap;
-    DAWN_TRY_ASSIGN(scopedMap, ScopedMap::Create(commandContext, this));
+    DAWN_TRY_ASSIGN(scopedMap, ScopedMap::Create(commandContext, this, wgpu::MapMode::Write));
 
     // For non-staging buffers, we can use UpdateSubresource to write the data.
     DAWN_TRY(EnsureDataInitializedAsDestination(commandContext, offset, size));
@@ -584,7 +691,7 @@
     // Map the buffer if it is possible, so EnsureDataInitializedAsDestination() and WriteInternal()
     // can write the mapped memory directly.
     ScopedMap scopedMap;
-    DAWN_TRY_ASSIGN(scopedMap, ScopedMap::Create(commandContext, this));
+    DAWN_TRY_ASSIGN(scopedMap, ScopedMap::Create(commandContext, this, wgpu::MapMode::Write));
 
     // For non-staging buffers, we can use UpdateSubresource to write the data.
     DAWN_TRY(EnsureDataInitializedAsDestination(commandContext, offset, size));
@@ -609,8 +716,12 @@
 
 ResultOrError<Buffer::ScopedMap> Buffer::ScopedMap::Create(
     const ScopedCommandRecordingContext* commandContext,
-    Buffer* buffer) {
-    if (!IsMappable(buffer->GetUsage())) {
+    Buffer* buffer,
+    wgpu::MapMode mode) {
+    if (mode == wgpu::MapMode::Write && !buffer->IsCPUWritable()) {
+        return ScopedMap();
+    }
+    if (mode == wgpu::MapMode::Read && !buffer->IsCPUReadable()) {
         return ScopedMap();
     }
 
@@ -618,7 +729,7 @@
         return ScopedMap(commandContext, buffer, /*needsUnmap=*/false);
     }
 
-    DAWN_TRY(buffer->MapInternal(commandContext));
+    DAWN_TRY(buffer->MapInternal(commandContext, mode));
     return ScopedMap(commandContext, buffer, /*needsUnmap=*/true);
 }
 
@@ -661,6 +772,153 @@
     return mBuffer ? mBuffer->mMappedData.get() : nullptr;
 }
 
+// GPUUsableBuffer
+ID3D11Buffer* GPUUsableBuffer::GetD3D11ConstantBufferForTesting() {
+    ID3D11Buffer* buffer;
+    if (GetDevice()->ConsumedError(GetD3D11ConstantBuffer(nullptr), &buffer)) {
+        return nullptr;
+    }
+
+    return buffer;
+}
+
+ID3D11Buffer* GPUUsableBuffer::GetD3D11NonConstantBufferForTesting() {
+    ID3D11Buffer* buffer;
+    if (GetDevice()->ConsumedError(GetD3D11NonConstantBuffer(nullptr), &buffer)) {
+        return nullptr;
+    }
+
+    return buffer;
+}
+
+ResultOrError<ComPtr<ID3D11ShaderResourceView>>
+GPUUsableBuffer::CreateD3D11ShaderResourceViewFromD3DBuffer(ID3D11Buffer* d3d11Buffer,
+                                                            uint64_t offset,
+                                                            uint64_t size) {
+    DAWN_ASSERT(IsAligned(offset, 4u));
+    DAWN_ASSERT(IsAligned(size, 4u));
+    UINT firstElement = static_cast<UINT>(offset / 4);
+    UINT numElements = static_cast<UINT>(size / 4);
+
+    D3D11_SHADER_RESOURCE_VIEW_DESC desc;
+    desc.Format = DXGI_FORMAT_R32_TYPELESS;
+    desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
+    desc.BufferEx.FirstElement = firstElement;
+    desc.BufferEx.NumElements = numElements;
+    desc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW;
+    ComPtr<ID3D11ShaderResourceView> srv;
+    DAWN_TRY(CheckHRESULT(ToBackend(GetDevice())
+                              ->GetD3D11Device()
+                              ->CreateShaderResourceView(d3d11Buffer, &desc, &srv),
+                          "ShaderResourceView creation"));
+
+    return srv;
+}
+
+ResultOrError<ComPtr<ID3D11UnorderedAccessView1>>
+GPUUsableBuffer::CreateD3D11UnorderedAccessViewFromD3DBuffer(ID3D11Buffer* d3d11Buffer,
+                                                             uint64_t offset,
+                                                             uint64_t size) {
+    DAWN_ASSERT(IsAligned(offset, 4u));
+    DAWN_ASSERT(IsAligned(size, 4u));
+
+    UINT firstElement = static_cast<UINT>(offset / 4);
+    UINT numElements = static_cast<UINT>(size / 4);
+
+    D3D11_UNORDERED_ACCESS_VIEW_DESC1 desc;
+    desc.Format = DXGI_FORMAT_R32_TYPELESS;
+    desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
+    desc.Buffer.FirstElement = firstElement;
+    desc.Buffer.NumElements = numElements;
+    desc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_RAW;
+
+    ComPtr<ID3D11UnorderedAccessView1> uav;
+    DAWN_TRY(CheckHRESULT(ToBackend(GetDevice())
+                              ->GetD3D11Device5()
+                              ->CreateUnorderedAccessView1(d3d11Buffer, &desc, &uav),
+                          "UnorderedAccessView creation"));
+
+    return uav;
+}
+
+MaybeError GPUUsableBuffer::UpdateD3D11ConstantBuffer(
+    const ScopedCommandRecordingContext* commandContext,
+    ID3D11Buffer* d3d11Buffer,
+    bool firstTimeUpdate,
+    uint64_t offset,
+    const void* data,
+    size_t size) {
+    DAWN_ASSERT(size > 0);
+
+    // For a full size write, UpdateSubresource1(D3D11_COPY_DISCARD) can be used to update
+    // constant buffer.
+    // WriteInternal() can be called with GetAllocatedSize(). We treat it as a full buffer write as
+    // well.
+    bool fullSizeUpdate = size >= GetSize() && offset == 0;
+    if (fullSizeUpdate || firstTimeUpdate) {
+        // Offset and size must be aligned with 16 for using UpdateSubresource1() on constant
+        // buffer.
+        size_t alignedOffset;
+        if (offset < kConstantBufferUpdateAlignment - 1) {
+            alignedOffset = 0;
+        } else {
+            // For offset we align to value <= offset.
+            alignedOffset = Align(offset - (kConstantBufferUpdateAlignment - 1),
+                                  kConstantBufferUpdateAlignment);
+        }
+        size_t alignedEnd = Align(offset + size, kConstantBufferUpdateAlignment);
+        size_t alignedSize = alignedEnd - alignedOffset;
+
+        DAWN_ASSERT((alignedSize % kConstantBufferUpdateAlignment) == 0);
+        DAWN_ASSERT(alignedSize <= GetAllocatedSize());
+        DAWN_ASSERT(offset >= alignedOffset);
+
+        // Extra bytes on the left of offset we could write to. This is only valid if
+        // firstTimeUpdate = true.
+        size_t leftExtraBytes = offset - alignedOffset;
+        DAWN_ASSERT(leftExtraBytes == 0 || firstTimeUpdate);
+
+        // The layout of the buffer is like this:
+        // |..........................| leftExtraBytes |     data   | ............... |
+        // |<----------------- offset ---------------->|<-- size -->|
+        // |<----- alignedOffset ---->|<--------- alignedSize --------->|
+        std::unique_ptr<uint8_t[]> alignedBuffer;
+        if (size != alignedSize) {
+            alignedBuffer.reset(new uint8_t[alignedSize]);
+            std::memcpy(alignedBuffer.get() + leftExtraBytes, data, size);
+            data = alignedBuffer.get();
+        }
+
+        D3D11_BOX dstBox;
+        dstBox.left = static_cast<UINT>(alignedOffset);
+        dstBox.top = 0;
+        dstBox.front = 0;
+        dstBox.right = static_cast<UINT>(alignedOffset + alignedSize);
+        dstBox.bottom = 1;
+        dstBox.back = 1;
+        // For full buffer write, D3D11_COPY_DISCARD is used to avoid GPU CPU synchronization.
+        commandContext->UpdateSubresource1(d3d11Buffer, /*DstSubresource=*/0, &dstBox, data,
+                                           /*SrcRowPitch=*/0,
+                                           /*SrcDepthPitch=*/0,
+                                           /*CopyFlags=*/D3D11_COPY_DISCARD);
+        return {};
+    }
+
+    // If copy offset and size are not 16 bytes aligned, we have to create a staging buffer for
+    // transfer the data to constant buffer.
+    Ref<BufferBase> stagingBuffer;
+    DAWN_TRY_ASSIGN(stagingBuffer, ToBackend(GetDevice())->GetStagingBuffer(commandContext, size));
+    stagingBuffer->MarkUsedInPendingCommands();
+    DAWN_TRY(ToBackend(stagingBuffer)->WriteInternal(commandContext, 0, data, size));
+    DAWN_TRY(ToBackend(stagingBuffer.Get())
+                 ->CopyToInternal(commandContext,
+                                  /*sourceOffset=*/0,
+                                  /*size=*/size, this, offset));
+    ToBackend(GetDevice())->ReturnStagingBuffer(std::move(stagingBuffer));
+
+    return {};
+}
+
 // GPUOnlyBuffer
 void GPUOnlyBuffer::DestroyImpl() {
     // TODO(crbug.com/dawn/831): DestroyImpl is called from two places.
@@ -670,7 +928,7 @@
     // - It may be called when the last ref to the buffer is dropped and the buffer
     //   is implicitly destroyed. This case is thread-safe because there are no
     //   other threads using the buffer since there are no other live refs.
-    Buffer::DestroyImpl();
+    GPUUsableBuffer::DestroyImpl();
 
     mD3d11ConstantBuffer = nullptr;
     mD3d11NonConstantBuffer = nullptr;
@@ -687,7 +945,7 @@
 
     bool needsConstantBuffer = GetUsage() & wgpu::BufferUsage::Uniform;
     bool onlyNeedsConstantBuffer =
-        needsConstantBuffer && IsSubset(GetUsage(), kD3D11AllowedUniformBufferUsages);
+        needsConstantBuffer && IsSubset(GetUsage(), kD3D11GPUOnlyUniformBufferUsages);
 
     if (!onlyNeedsConstantBuffer) {
         // Create mD3d11NonConstantBuffer
@@ -729,78 +987,60 @@
     return {};
 }
 
-MaybeError GPUOnlyBuffer::MapInternal(const ScopedCommandRecordingContext* commandContext) {
-    DAWN_UNREACHABLE();
-
-    return {};
+MaybeError GPUOnlyBuffer::PredicatedClear(
+    const ScopedSwapStateCommandRecordingContext* commandContext,
+    ID3D11Predicate* predicate,
+    uint8_t clearValue,
+    uint64_t offset,
+    uint64_t size) {
+    // The clear will *NOT* be performed if the predicate's data is false.
+    commandContext->GetD3D11DeviceContext4()->SetPredication(predicate, false);
+    auto result = Clear(commandContext, clearValue, offset, size);
+    commandContext->GetD3D11DeviceContext4()->SetPredication(nullptr, false);
+    return result;
 }
 
-void GPUOnlyBuffer::UnmapInternal(const ScopedCommandRecordingContext* commandContext) {
-    DAWN_UNREACHABLE();
-}
-
-void GPUOnlyBuffer::MarkMutated() {
-    mConstantBufferIsUpdated = false;
-}
-
-void GPUOnlyBuffer::EnsureConstantBufferIsUpdated(
+ResultOrError<ID3D11Buffer*> GPUOnlyBuffer::GetD3D11ConstantBuffer(
     const ScopedCommandRecordingContext* commandContext) {
     if (mConstantBufferIsUpdated) {
-        return;
+        return mD3d11ConstantBuffer.Get();
     }
 
     DAWN_ASSERT(mD3d11NonConstantBuffer);
     DAWN_ASSERT(mD3d11ConstantBuffer);
-    commandContext->CopyResource(mD3d11ConstantBuffer.Get(), mD3d11NonConstantBuffer.Get());
+    if (commandContext) {
+        commandContext->CopyResource(mD3d11ConstantBuffer.Get(), mD3d11NonConstantBuffer.Get());
+    } else {
+        auto tempCommandContext =
+            ToBackend(GetDevice()->GetQueue())
+                ->GetScopedPendingCommandContext(QueueBase::SubmitMode::Normal);
+        tempCommandContext.CopyResource(mD3d11ConstantBuffer.Get(), mD3d11NonConstantBuffer.Get());
+    }
     mConstantBufferIsUpdated = true;
+
+    return mD3d11ConstantBuffer.Get();
 }
 
-ResultOrError<ComPtr<ID3D11ShaderResourceView>> GPUOnlyBuffer::CreateD3D11ShaderResourceView(
-    uint64_t offset,
-    uint64_t size) const {
-    DAWN_ASSERT(IsAligned(offset, 4u));
-    DAWN_ASSERT(IsAligned(size, 4u));
-    UINT firstElement = static_cast<UINT>(offset / 4);
-    UINT numElements = static_cast<UINT>(size / 4);
-
-    D3D11_SHADER_RESOURCE_VIEW_DESC desc;
-    desc.Format = DXGI_FORMAT_R32_TYPELESS;
-    desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
-    desc.BufferEx.FirstElement = firstElement;
-    desc.BufferEx.NumElements = numElements;
-    desc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW;
-    ComPtr<ID3D11ShaderResourceView> srv;
-    DAWN_TRY(
-        CheckHRESULT(ToBackend(GetDevice())
-                         ->GetD3D11Device()
-                         ->CreateShaderResourceView(mD3d11NonConstantBuffer.Get(), &desc, &srv),
-                     "ShaderResourceView creation"));
-
-    return srv;
+ResultOrError<ID3D11Buffer*> GPUOnlyBuffer::GetD3D11NonConstantBuffer(
+    const ScopedCommandRecordingContext*) {
+    return mD3d11NonConstantBuffer.Get();
 }
 
-ResultOrError<ComPtr<ID3D11UnorderedAccessView1>> GPUOnlyBuffer::CreateD3D11UnorderedAccessView1(
-    uint64_t offset,
-    uint64_t size) const {
-    DAWN_ASSERT(IsAligned(offset, 4u));
-    DAWN_ASSERT(IsAligned(size, 4u));
+ResultOrError<ComPtr<ID3D11ShaderResourceView>>
+GPUOnlyBuffer::UseAsSRV(const ScopedCommandRecordingContext*, uint64_t offset, uint64_t size) {
+    return CreateD3D11ShaderResourceViewFromD3DBuffer(mD3d11NonConstantBuffer.Get(), offset, size);
+}
 
-    UINT firstElement = static_cast<UINT>(offset / 4);
-    UINT numElements = static_cast<UINT>(size / 4);
-
-    D3D11_UNORDERED_ACCESS_VIEW_DESC1 desc;
-    desc.Format = DXGI_FORMAT_R32_TYPELESS;
-    desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
-    desc.Buffer.FirstElement = firstElement;
-    desc.Buffer.NumElements = numElements;
-    desc.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_RAW;
-
+ResultOrError<ComPtr<ID3D11UnorderedAccessView1>>
+GPUOnlyBuffer::UseAsUAV(const ScopedCommandRecordingContext*, uint64_t offset, uint64_t size) {
     ComPtr<ID3D11UnorderedAccessView1> uav;
-    DAWN_TRY(
-        CheckHRESULT(ToBackend(GetDevice())
-                         ->GetD3D11Device5()
-                         ->CreateUnorderedAccessView1(mD3d11NonConstantBuffer.Get(), &desc, &uav),
-                     "UnorderedAccessView creation"));
+    DAWN_TRY_ASSIGN(uav, CreateD3D11UnorderedAccessViewFromD3DBuffer(mD3d11NonConstantBuffer.Get(),
+                                                                     offset, size));
+
+    // Since UAV will modify the non-constant buffer's content, the constant buffer's content would
+    // also need to be updated afterwards.
+    mConstantBufferIsUpdated = false;
+
     return uav;
 }
 
@@ -846,52 +1086,8 @@
 
     DAWN_ASSERT(mD3d11ConstantBuffer);
 
-    // For a full size write, UpdateSubresource1(D3D11_COPY_DISCARD) can be used to update
-    // mD3d11ConstantBuffer.
-    // WriteInternal() can be called with GetAllocatedSize(). We treat it as a full buffer write as
-    // well.
-    if (size >= GetSize() && offset == 0) {
-        // Offset and size must be aligned with 16 for using UpdateSubresource1() on constant
-        // buffer.
-        size_t alignedSize = Align(size, kConstantBufferUpdateAlignment);
-        DAWN_ASSERT(alignedSize <= GetAllocatedSize());
-        std::unique_ptr<uint8_t[]> alignedBuffer;
-        if (size != alignedSize) {
-            alignedBuffer.reset(new uint8_t[alignedSize]);
-            std::memcpy(alignedBuffer.get(), data, size);
-            data = alignedBuffer.get();
-        }
-
-        D3D11_BOX dstBox;
-        dstBox.left = 0;
-        dstBox.top = 0;
-        dstBox.front = 0;
-        dstBox.right = static_cast<UINT>(alignedSize);
-        dstBox.bottom = 1;
-        dstBox.back = 1;
-        // For full buffer write, D3D11_COPY_DISCARD is used to avoid GPU CPU synchronization.
-        commandContext->UpdateSubresource1(mD3d11ConstantBuffer.Get(), /*DstSubresource=*/0,
-                                           &dstBox, data,
-                                           /*SrcRowPitch=*/0,
-                                           /*SrcDepthPitch=*/0,
-                                           /*CopyFlags=*/D3D11_COPY_DISCARD);
-        return {};
-    }
-
-    // If the mD3d11NonConstantBuffer is null and copy offset and size are not 16 bytes
-    // aligned, we have to create a staging buffer for transfer the data to
-    // mD3d11ConstantBuffer.
-    Ref<BufferBase> stagingBuffer;
-    DAWN_TRY_ASSIGN(stagingBuffer, ToBackend(GetDevice())->GetStagingBuffer(commandContext, size));
-    stagingBuffer->MarkUsedInPendingCommands();
-    DAWN_TRY(ToBackend(stagingBuffer)->WriteInternal(commandContext, 0, data, size));
-    DAWN_TRY(ToBackend(stagingBuffer.Get())
-                 ->CopyToInternal(commandContext,
-                                  /*sourceOffset=*/0,
-                                  /*size=*/size, this, offset));
-    ToBackend(GetDevice())->ReturnStagingBuffer(std::move(stagingBuffer));
-
-    return {};
+    return UpdateD3D11ConstantBuffer(commandContext, mD3d11ConstantBuffer.Get(),
+                                     /*firstUpdate=*/false, offset, data, size);
 }
 
 MaybeError GPUOnlyBuffer::CopyToInternal(const ScopedCommandRecordingContext* commandContext,
@@ -956,26 +1152,16 @@
     uint64_t clearOffset = GetSize();
     // 'UpdateSubresource1' is more preferable for updating uniform buffers, as it incurs no
     // GPU stall.
-    if (GetUsage() & wgpu::BufferUsage::Uniform && !GetD3D11NonConstantBuffer()) {
+    if (mD3d11ConstantBuffer && !mD3d11NonConstantBuffer) {
         clearSize = Align(paddingBytes, kConstantBufferUpdateAlignment);
         clearOffset = GetAllocatedSize() - clearSize;
 
-        D3D11_BOX dstBox;
-        dstBox.left = clearOffset;
-        dstBox.top = 0;
-        dstBox.front = 0;
-        dstBox.right = GetAllocatedSize();
-        dstBox.bottom = 1;
-        dstBox.back = 1;
-
         std::vector<uint8_t> clearData(clearSize, 0);
-        commandContext->UpdateSubresource1(GetD3D11ConstantBuffer(),
-                                           /*DstSubresource=*/0, &dstBox, clearData.data(),
-                                           /*SrcRowPitch=*/0,
-                                           /*SrcDepthPitch=*/0,
-                                           /*CopyFlags=*/D3D11_COPY_DISCARD);
+        DAWN_TRY(UpdateD3D11ConstantBuffer(commandContext, mD3d11ConstantBuffer.Get(),
+                                           /*firstTimeUpdate=*/true, clearOffset, clearData.data(),
+                                           clearSize));
     } else {
-        DAWN_TRY(ClearInternal(commandContext, 0, clearOffset, clearSize));
+        DAWN_TRY(ClearInternal(commandContext, 0, clearOffset, paddingBytes));
     }
 
     return {};
diff --git a/src/dawn/native/d3d11/BufferD3D11.h b/src/dawn/native/d3d11/BufferD3D11.h
index f8e1175..268ebbd9 100644
--- a/src/dawn/native/d3d11/BufferD3D11.h
+++ b/src/dawn/native/d3d11/BufferD3D11.h
@@ -41,6 +41,7 @@
 
 class Device;
 class ScopedCommandRecordingContext;
+class ScopedSwapStateCommandRecordingContext;
 
 class Buffer : public BufferBase {
   public:
@@ -76,7 +77,19 @@
 
     // Actually map the buffer when its last usage serial has passed.
     MaybeError FinalizeMap(ScopedCommandRecordingContext* commandContext,
-                           ExecutionSerial completedSerial);
+                           ExecutionSerial completedSerial,
+                           wgpu::MapMode mode);
+
+    bool IsCPUWritable() const;
+    bool IsCPUReadable() const;
+
+    // This performs GPU Clear. Unlike Clear(), this will always be affected by ID3D11Predicate.
+    // Whereas Clear() might be unaffected by ID3D11Predicate if it's pure CPU clear.
+    virtual MaybeError PredicatedClear(const ScopedSwapStateCommandRecordingContext* commandContext,
+                                       ID3D11Predicate* predicate,
+                                       uint8_t clearValue,
+                                       uint64_t offset,
+                                       uint64_t size);
 
     // Write the buffer without checking if the buffer is initialized.
     virtual MaybeError WriteInternal(const ScopedCommandRecordingContext* commandContext,
@@ -101,7 +114,8 @@
         // Map buffer and return a ScopedMap object. If the buffer is not mappable,
         // scopedMap.GetMappedData() will return nullptr.
         static ResultOrError<ScopedMap> Create(const ScopedCommandRecordingContext* commandContext,
-                                               Buffer* buffer);
+                                               Buffer* buffer,
+                                               wgpu::MapMode mode);
 
         ScopedMap();
         ~ScopedMap();
@@ -125,16 +139,18 @@
     };
 
   protected:
-    using BufferBase::BufferBase;
-
+    Buffer(DeviceBase* device,
+           const UnpackedPtr<BufferDescriptor>& descriptor,
+           wgpu::BufferUsage internalMappableFlags);
     ~Buffer() override;
 
     void DestroyImpl() override;
 
     virtual MaybeError InitializeInternal() = 0;
 
-    virtual MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext) = 0;
-    virtual void UnmapInternal(const ScopedCommandRecordingContext* commandContext) = 0;
+    virtual MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext,
+                                   wgpu::MapMode mode);
+    virtual void UnmapInternal(const ScopedCommandRecordingContext* commandContext);
 
     // Clear the buffer without checking if the buffer is initialized.
     MaybeError ClearWholeBuffer(const ScopedCommandRecordingContext* commandContext,
@@ -160,69 +176,58 @@
 
     MaybeError InitializeToZero(const ScopedCommandRecordingContext* commandContext);
 
+    // Internal usage indicating the native buffer supports mapping for read and/or write or not.
+    const wgpu::BufferUsage mInternalMappableFlags;
     ExecutionSerial mMapReadySerial = kMaxExecutionSerial;
 };
 
-// Buffer that doesn't support mapping.
-class GPUOnlyBuffer final : public Buffer {
+// Buffer that can be used by GPU.
+class GPUUsableBuffer : public Buffer {
   public:
-    ID3D11Buffer* GetD3D11ConstantBuffer() const { return mD3d11ConstantBuffer.Get(); }
-    ID3D11Buffer* GetD3D11NonConstantBuffer() const { return mD3d11NonConstantBuffer.Get(); }
+    virtual ResultOrError<ID3D11Buffer*> GetD3D11ConstantBuffer(
+        const ScopedCommandRecordingContext* commandContext) = 0;
+    virtual ResultOrError<ID3D11Buffer*> GetD3D11NonConstantBuffer(
+        const ScopedCommandRecordingContext* commandContext) = 0;
+    ID3D11Buffer* GetD3D11ConstantBufferForTesting();
+    ID3D11Buffer* GetD3D11NonConstantBufferForTesting();
 
-    // Mark the mD3d11NonConstantBuffer is mutated by shaders, if mD3d11ConstantBuffer exists,
-    // it will be synced with mD3d11NonConstantBuffer before binding it to the constant buffer slot.
-    void MarkMutated();
-    // Update content of the mD3d11ConstantBuffer from mD3d11NonConstantBuffer if needed.
-    void EnsureConstantBufferIsUpdated(const ScopedCommandRecordingContext* commandContext);
-    ResultOrError<ComPtr<ID3D11ShaderResourceView>> CreateD3D11ShaderResourceView(
+    virtual ResultOrError<ComPtr<ID3D11ShaderResourceView>> UseAsSRV(
+        const ScopedCommandRecordingContext* commandContext,
         uint64_t offset,
-        uint64_t size) const;
-    ResultOrError<ComPtr<ID3D11UnorderedAccessView1>> CreateD3D11UnorderedAccessView1(
-        uint64_t offset,
-        uint64_t size) const;
+        uint64_t size) = 0;
 
-  private:
+    // Use this buffer as UAV and mark it as being mutated by shader.
+    virtual ResultOrError<ComPtr<ID3D11UnorderedAccessView1>> UseAsUAV(
+        const ScopedCommandRecordingContext* commandContext,
+        uint64_t offset,
+        uint64_t size) = 0;
+
+  protected:
     using Buffer::Buffer;
 
-    // Dawn API
-    void DestroyImpl() override;
-    void SetLabelImpl() override;
+    ResultOrError<ComPtr<ID3D11ShaderResourceView>> CreateD3D11ShaderResourceViewFromD3DBuffer(
+        ID3D11Buffer* d3d11Buffer,
+        uint64_t offset,
+        uint64_t size);
+    ResultOrError<ComPtr<ID3D11UnorderedAccessView1>> CreateD3D11UnorderedAccessViewFromD3DBuffer(
+        ID3D11Buffer* d3d11Buffer,
+        uint64_t offset,
+        uint64_t size);
 
-    // The buffer object for constant buffer usage.
-    ComPtr<ID3D11Buffer> mD3d11ConstantBuffer;
-    // The buffer object for non-constant buffer usages(e.g. storage buffer, vertex buffer, etc.)
-    ComPtr<ID3D11Buffer> mD3d11NonConstantBuffer;
-
-    MaybeError InitializeInternal() override;
-    MaybeError MapInternal(const ScopedCommandRecordingContext* commandContext) override;
-    void UnmapInternal(const ScopedCommandRecordingContext* commandContext) override;
-    MaybeError CopyToInternal(const ScopedCommandRecordingContext* commandContext,
-                              uint64_t sourceOffset,
-                              size_t size,
-                              Buffer* destination,
-                              uint64_t destinationOffset) override;
-    MaybeError CopyFromD3DInternal(const ScopedCommandRecordingContext* commandContext,
-                                   ID3D11Buffer* srcD3D11Buffer,
-                                   uint64_t sourceOffset,
-                                   size_t size,
-                                   uint64_t destinationOffset) override;
-
-    MaybeError WriteInternal(const ScopedCommandRecordingContext* commandContext,
-                             uint64_t bufferOffset,
-                             const void* data,
-                             size_t size) override;
-
-    MaybeError ClearPaddingInternal(const ScopedCommandRecordingContext* commandContext) override;
-
-    bool mConstantBufferIsUpdated = true;
+    MaybeError UpdateD3D11ConstantBuffer(const ScopedCommandRecordingContext* commandContext,
+                                         ID3D11Buffer* d3d11Buffer,
+                                         bool firstTimeUpdate,
+                                         uint64_t bufferOffset,
+                                         const void* data,
+                                         size_t size);
 };
 
-static inline GPUOnlyBuffer* ToGPUOnlyBuffer(BufferBase* buffer) {
-    return static_cast<GPUOnlyBuffer*>(ToBackend(buffer));
+static inline GPUUsableBuffer* ToGPUUsableBuffer(BufferBase* buffer) {
+    return static_cast<GPUUsableBuffer*>(ToBackend(buffer));
 }
 
-static inline Ref<GPUOnlyBuffer> ToGPUOnlyBuffer(Ref<BufferBase>&& buffer) {
-    return std::move(buffer).Cast<Ref<GPUOnlyBuffer>>();
+static inline Ref<GPUUsableBuffer> ToGPUUsableBuffer(Ref<BufferBase>&& buffer) {
+    return std::move(buffer).Cast<Ref<GPUUsableBuffer>>();
 }
 
 }  // namespace dawn::native::d3d11
diff --git a/src/dawn/native/d3d11/CommandBufferD3D11.cpp b/src/dawn/native/d3d11/CommandBufferD3D11.cpp
index 4cee230..571289d 100644
--- a/src/dawn/native/d3d11/CommandBufferD3D11.cpp
+++ b/src/dawn/native/d3d11/CommandBufferD3D11.cpp
@@ -315,7 +315,7 @@
                 Ref<BufferBase> stagingBuffer;
                 // If the buffer is not mappable, we need to create a staging buffer and copy the
                 // data from the buffer to the staging buffer.
-                if (!(buffer->GetUsage() & kMappableBufferUsages)) {
+                if (!buffer->IsCPUReadable()) {
                     const TexelBlockInfo& blockInfo =
                         ToBackend(dst.texture)->GetFormat().GetAspectInfo(dst.aspect).block;
                     // TODO(dawn:1768): use compute shader to copy data from buffer to texture.
@@ -335,7 +335,8 @@
                 }
 
                 Buffer::ScopedMap scopedMap;
-                DAWN_TRY_ASSIGN(scopedMap, Buffer::ScopedMap::Create(commandContext, buffer));
+                DAWN_TRY_ASSIGN(scopedMap, Buffer::ScopedMap::Create(commandContext, buffer,
+                                                                     wgpu::MapMode::Read));
                 DAWN_TRY(buffer->EnsureDataInitialized(commandContext));
 
                 Texture* texture = ToBackend(dst.texture.Get());
@@ -370,7 +371,8 @@
 
                 Buffer* buffer = ToBackend(dst.buffer.Get());
                 Buffer::ScopedMap scopedDstMap;
-                DAWN_TRY_ASSIGN(scopedDstMap, Buffer::ScopedMap::Create(commandContext, buffer));
+                DAWN_TRY_ASSIGN(scopedDstMap, Buffer::ScopedMap::Create(commandContext, buffer,
+                                                                        wgpu::MapMode::Write));
 
                 DAWN_TRY(buffer->EnsureDataInitializedAsDestination(commandContext, copy));
 
@@ -495,7 +497,7 @@
 
                 DAWN_TRY(bindGroupTracker.Apply());
 
-                auto* indirectBuffer = ToGPUOnlyBuffer(dispatch->indirectBuffer.Get());
+                auto* indirectBuffer = ToGPUUsableBuffer(dispatch->indirectBuffer.Get());
 
                 if (lastPipeline->UsesNumWorkgroups()) {
                     // Copy indirect args into the uniform buffer for built-in workgroup variables.
@@ -504,9 +506,11 @@
                                           0));
                 }
 
+                ID3D11Buffer* d3dBuffer;
+                DAWN_TRY_ASSIGN(d3dBuffer,
+                                indirectBuffer->GetD3D11NonConstantBuffer(commandContext));
                 commandContext->GetD3D11DeviceContext4()->DispatchIndirect(
-                    indirectBuffer->GetD3D11NonConstantBuffer(), dispatch->indirectOffset);
-
+                    d3dBuffer, dispatch->indirectOffset);
                 break;
             }
 
@@ -667,7 +671,7 @@
             case Command::DrawIndirect: {
                 DrawIndirectCmd* draw = iter->NextCommand<DrawIndirectCmd>();
 
-                auto* indirectBuffer = ToGPUOnlyBuffer(draw->indirectBuffer.Get());
+                auto* indirectBuffer = ToGPUUsableBuffer(draw->indirectBuffer.Get());
                 DAWN_ASSERT(indirectBuffer != nullptr);
 
                 DAWN_TRY(bindGroupTracker.Apply());
@@ -684,8 +688,11 @@
                                           0));
                 }
 
+                ID3D11Buffer* d3dBuffer;
+                DAWN_TRY_ASSIGN(d3dBuffer,
+                                indirectBuffer->GetD3D11NonConstantBuffer(commandContext));
                 commandContext->GetD3D11DeviceContext4()->DrawInstancedIndirect(
-                    indirectBuffer->GetD3D11NonConstantBuffer(), draw->indirectOffset);
+                    d3dBuffer, draw->indirectOffset);
 
                 break;
             }
@@ -693,7 +700,7 @@
             case Command::DrawIndexedIndirect: {
                 DrawIndexedIndirectCmd* draw = iter->NextCommand<DrawIndexedIndirectCmd>();
 
-                auto* indirectBuffer = ToGPUOnlyBuffer(draw->indirectBuffer.Get());
+                auto* indirectBuffer = ToGPUUsableBuffer(draw->indirectBuffer.Get());
                 DAWN_ASSERT(indirectBuffer != nullptr);
 
                 DAWN_TRY(bindGroupTracker.Apply());
@@ -710,8 +717,11 @@
                                           0));
                 }
 
+                ID3D11Buffer* d3dBuffer;
+                DAWN_TRY_ASSIGN(d3dBuffer,
+                                indirectBuffer->GetD3D11NonConstantBuffer(commandContext));
                 commandContext->GetD3D11DeviceContext4()->DrawIndexedInstancedIndirect(
-                    indirectBuffer->GetD3D11NonConstantBuffer(), draw->indirectOffset);
+                    d3dBuffer, draw->indirectOffset);
 
                 break;
             }
@@ -745,18 +755,21 @@
                 UINT indexBufferBaseOffset = cmd->offset;
                 DXGI_FORMAT indexBufferFormat = DXGIIndexFormat(cmd->format);
 
+                ID3D11Buffer* d3dBuffer;
+                DAWN_TRY_ASSIGN(d3dBuffer, ToGPUUsableBuffer(cmd->buffer.Get())
+                                               ->GetD3D11NonConstantBuffer(commandContext));
                 commandContext->GetD3D11DeviceContext4()->IASetIndexBuffer(
-                    ToGPUOnlyBuffer(cmd->buffer.Get())->GetD3D11NonConstantBuffer(),
-                    indexBufferFormat, indexBufferBaseOffset);
+                    d3dBuffer, indexBufferFormat, indexBufferBaseOffset);
 
                 break;
             }
 
             case Command::SetVertexBuffer: {
                 SetVertexBufferCmd* cmd = iter->NextCommand<SetVertexBufferCmd>();
-                ID3D11Buffer* buffer =
-                    ToGPUOnlyBuffer(cmd->buffer.Get())->GetD3D11NonConstantBuffer();
-                vertexBufferTracker.OnSetVertexBuffer(cmd->slot, buffer, cmd->offset);
+                ID3D11Buffer* d3dBuffer;
+                DAWN_TRY_ASSIGN(d3dBuffer, ToGPUUsableBuffer(cmd->buffer.Get())
+                                               ->GetD3D11NonConstantBuffer(commandContext));
+                vertexBufferTracker.OnSetVertexBuffer(cmd->slot, d3dBuffer, cmd->offset);
                 break;
             }
 
diff --git a/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp b/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp
index 2c7e400..130e7ae 100644
--- a/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp
+++ b/src/dawn/native/d3d11/CommandRecordingContextD3D11.cpp
@@ -260,16 +260,19 @@
     return device->CreateBuffer(&descriptor);
 }
 
-void CommandRecordingContext::SetInternalUniformBuffer(Ref<BufferBase> uniformBuffer) {
-    mUniformBuffer = ToGPUOnlyBuffer(std::move(uniformBuffer));
+MaybeError CommandRecordingContext::SetInternalUniformBuffer(Ref<BufferBase> uniformBuffer) {
+    mUniformBuffer = ToGPUUsableBuffer(std::move(uniformBuffer));
 
     // Always bind the uniform buffer to the reserved slot for all pipelines.
     // This buffer will be updated with the correct values before each draw or dispatch call.
-    ID3D11Buffer* bufferPtr = mUniformBuffer->GetD3D11ConstantBuffer();
+    ID3D11Buffer* bufferPtr;
+    DAWN_TRY_ASSIGN(bufferPtr, mUniformBuffer->GetD3D11ConstantBuffer(nullptr));
     mD3D11DeviceContext4->VSSetConstantBuffers(PipelineLayout::kReservedConstantBufferSlot, 1,
                                                &bufferPtr);
     mD3D11DeviceContext4->CSSetConstantBuffers(PipelineLayout::kReservedConstantBufferSlot, 1,
                                                &bufferPtr);
+
+    return {};
 }
 
 void CommandRecordingContext::ReleaseKeyedMutexes() {
diff --git a/src/dawn/native/d3d11/CommandRecordingContextD3D11.h b/src/dawn/native/d3d11/CommandRecordingContextD3D11.h
index 40370a2..6b4f2c9 100644
--- a/src/dawn/native/d3d11/CommandRecordingContextD3D11.h
+++ b/src/dawn/native/d3d11/CommandRecordingContextD3D11.h
@@ -40,7 +40,7 @@
 
 class CommandAllocatorManager;
 class Buffer;
-class GPUOnlyBuffer;
+class GPUUsableBuffer;
 class Device;
 
 class CommandRecordingContext;
@@ -84,7 +84,7 @@
     void Destroy();
 
     static ResultOrError<Ref<BufferBase>> CreateInternalUniformBuffer(DeviceBase* device);
-    void SetInternalUniformBuffer(Ref<BufferBase> uniformBuffer);
+    MaybeError SetInternalUniformBuffer(Ref<BufferBase> uniformBuffer);
 
     void ReleaseKeyedMutexes();
 
@@ -107,7 +107,7 @@
     // The maximum number of builtin elements is 4 (vec4). It must be multiple of 4.
     static constexpr size_t kMaxNumBuiltinElements = 4;
     // The uniform buffer for built-in variables.
-    Ref<GPUOnlyBuffer> mUniformBuffer;
+    Ref<GPUUsableBuffer> mUniformBuffer;
     std::array<uint32_t, kMaxNumBuiltinElements> mUniformBufferData;
     bool mUniformBufferDirty = true;
 
diff --git a/src/dawn/native/d3d11/QuerySetD3D11.cpp b/src/dawn/native/d3d11/QuerySetD3D11.cpp
index 38cddce..2948277 100644
--- a/src/dawn/native/d3d11/QuerySetD3D11.cpp
+++ b/src/dawn/native/d3d11/QuerySetD3D11.cpp
@@ -93,15 +93,12 @@
                              uint64_t offset) {
     DAWN_TRY(destination->Clear(commandContext, 0, offset, queryCount * sizeof(uint64_t)));
     const auto& queryAvailability = GetQueryAvailability();
-    ID3D11DeviceContext* d3d11DeviceContext = commandContext->GetD3D11DeviceContext4();
     for (uint32_t i = 0; i < queryCount; ++i) {
         uint32_t queryIndex = i + firstQuery;
         if (queryAvailability[queryIndex]) {
             auto& predicate = mPredicates[queryIndex];
-            d3d11DeviceContext->SetPredication(predicate.Get(), false);
-            DAWN_TRY(destination->Clear(commandContext, 1, offset + i * sizeof(uint64_t),
-                                        sizeof(uint64_t)));
-            d3d11DeviceContext->SetPredication(nullptr, false);
+            DAWN_TRY(destination->PredicatedClear(commandContext, predicate.Get(), 1,
+                                                  offset + i * sizeof(uint64_t), sizeof(uint64_t)));
         }
     }
     return {};
diff --git a/src/dawn/native/d3d11/QueueD3D11.cpp b/src/dawn/native/d3d11/QueueD3D11.cpp
index e0ac29a..0b83880 100644
--- a/src/dawn/native/d3d11/QueueD3D11.cpp
+++ b/src/dawn/native/d3d11/QueueD3D11.cpp
@@ -144,7 +144,7 @@
     Ref<BufferBase> uniformBuffer;
     DAWN_TRY_ASSIGN(uniformBuffer,
                     CommandRecordingContext::CreateInternalUniformBuffer(GetDevice()));
-    mPendingCommands->SetInternalUniformBuffer(std::move(uniformBuffer));
+    DAWN_TRY(mPendingCommands->SetInternalUniformBuffer(std::move(uniformBuffer)));
 
     return {};
 }
@@ -219,15 +219,18 @@
 
 MaybeError Queue::CheckAndMapReadyBuffers(ExecutionSerial completedSerial) {
     auto commandContext = GetScopedPendingCommandContext(QueueBase::SubmitMode::Passive);
-    for (auto buffer : mPendingMapBuffers.IterateUpTo(completedSerial)) {
-        DAWN_TRY(buffer->FinalizeMap(&commandContext, completedSerial));
+    for (const auto& bufferEntry : mPendingMapBuffers.IterateUpTo(completedSerial)) {
+        DAWN_TRY(
+            bufferEntry.buffer->FinalizeMap(&commandContext, completedSerial, bufferEntry.mode));
     }
     mPendingMapBuffers.ClearUpTo(completedSerial);
     return {};
 }
 
-void Queue::TrackPendingMapBuffer(Ref<Buffer>&& buffer, ExecutionSerial readySerial) {
-    mPendingMapBuffers.Enqueue(buffer, readySerial);
+void Queue::TrackPendingMapBuffer(Ref<Buffer>&& buffer,
+                                  wgpu::MapMode mode,
+                                  ExecutionSerial readySerial) {
+    mPendingMapBuffers.Enqueue({buffer, mode}, readySerial);
 }
 
 MaybeError Queue::WriteBufferImpl(BufferBase* buffer,
diff --git a/src/dawn/native/d3d11/QueueD3D11.h b/src/dawn/native/d3d11/QueueD3D11.h
index 657e5ad..3c8bb0e 100644
--- a/src/dawn/native/d3d11/QueueD3D11.h
+++ b/src/dawn/native/d3d11/QueueD3D11.h
@@ -54,7 +54,9 @@
     MaybeError InitializePendingContext();
 
     // Register the pending map buffer to be checked.
-    void TrackPendingMapBuffer(Ref<Buffer>&& buffer, ExecutionSerial readySerial);
+    void TrackPendingMapBuffer(Ref<Buffer>&& buffer,
+                               wgpu::MapMode mode,
+                               ExecutionSerial readySerial);
 
   protected:
     using d3d::Queue::Queue;
@@ -88,7 +90,12 @@
     Ref<SharedFence> mSharedFence;
     MutexProtected<CommandRecordingContext, CommandRecordingContextGuard> mPendingCommands;
     std::atomic<bool> mPendingCommandsNeedSubmit = false;
-    SerialMap<ExecutionSerial, Ref<Buffer>> mPendingMapBuffers;
+
+    struct BufferMapEntry {
+        Ref<Buffer> buffer;
+        wgpu::MapMode mode;
+    };
+    SerialMap<ExecutionSerial, BufferMapEntry> mPendingMapBuffers;
 };
 
 }  // namespace dawn::native::d3d11
diff --git a/src/dawn/tests/white_box/D3D11BufferTests.cpp b/src/dawn/tests/white_box/D3D11BufferTests.cpp
index eb21c0a..8b19545 100644
--- a/src/dawn/tests/white_box/D3D11BufferTests.cpp
+++ b/src/dawn/tests/white_box/D3D11BufferTests.cpp
@@ -109,66 +109,66 @@
     {
         wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_EQ(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_EQ(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
     {
         wgpu::BufferUsage usage =
             wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::CopySrc;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_EQ(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_EQ(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
     {
         wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Vertex;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
     {
         wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Index;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
     {
         wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Indirect;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
     {
         wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Storage;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
     {
         wgpu::BufferUsage usage = wgpu::BufferUsage::Storage;
         wgpu::Buffer buffer = CreateBuffer(4, usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_EQ(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_EQ(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
     }
 }
 
@@ -179,34 +179,34 @@
         wgpu::BufferUsage usage =
             wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::CopySrc;
         wgpu::Buffer buffer = CreateBuffer(data.size(), usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_EQ(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_EQ(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
 
         queue.WriteBuffer(buffer, 0, data.data(), data.size());
         EXPECT_BUFFER_U8_RANGE_EQ(data.data(), buffer, 0, data.size());
 
-        CheckBuffer(d3d11Buffer->GetD3D11ConstantBuffer(), data);
+        CheckBuffer(d3d11Buffer->GetD3D11ConstantBufferForTesting(), data);
     }
     {
         std::vector<uint8_t> data = {0x12, 0x34, 0x56, 0x78};
         wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Vertex |
                                   wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::CopySrc;
         wgpu::Buffer buffer = CreateBuffer(data.size(), usage);
-        native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-            native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+        native::d3d11::GPUUsableBuffer* d3d11Buffer =
+            native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+        EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
 
         queue.WriteBuffer(buffer, 0, data.data(), data.size());
         EXPECT_BUFFER_U8_RANGE_EQ(data.data(), buffer, 0, data.size());
 
         // both buffers should be updated.
-        CheckBuffer(d3d11Buffer->GetD3D11NonConstantBuffer(), data);
-        CheckBuffer(d3d11Buffer->GetD3D11ConstantBuffer(), data);
+        CheckBuffer(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), data);
+        CheckBuffer(d3d11Buffer->GetD3D11ConstantBufferForTesting(), data);
     }
 }
 
@@ -218,17 +218,17 @@
     wgpu::BufferUsage usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::Storage |
                               wgpu::BufferUsage::CopyDst | wgpu::BufferUsage::CopySrc;
     wgpu::Buffer buffer = CreateBuffer(bufferSize, usage);
-    native::d3d11::GPUOnlyBuffer* d3d11Buffer =
-        native::d3d11::ToGPUOnlyBuffer(native::FromAPI(buffer.Get()));
+    native::d3d11::GPUUsableBuffer* d3d11Buffer =
+        native::d3d11::ToGPUUsableBuffer(native::FromAPI(buffer.Get()));
 
-    EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBuffer(), nullptr);
-    EXPECT_NE(d3d11Buffer->GetD3D11ConstantBuffer(), nullptr);
+    EXPECT_NE(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), nullptr);
+    EXPECT_NE(d3d11Buffer->GetD3D11ConstantBufferForTesting(), nullptr);
 
     queue.WriteBuffer(buffer, 0, data.data(), bufferSize);
     EXPECT_BUFFER_U32_RANGE_EQ(data.data(), buffer, 0, data.size());
 
-    CheckBuffer(d3d11Buffer->GetD3D11NonConstantBuffer(), data);
-    CheckBuffer(d3d11Buffer->GetD3D11ConstantBuffer(), data);
+    CheckBuffer(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), data);
+    CheckBuffer(d3d11Buffer->GetD3D11ConstantBufferForTesting(), data);
 
     // Fill the buffer with 0x11223344 with a compute shader
     {
@@ -268,9 +268,9 @@
         std::vector<uint32_t> expectedData(kNumValues, 0x11223344);
         EXPECT_BUFFER_U32_RANGE_EQ(expectedData.data(), buffer, 0, expectedData.size());
         // The non-constant buffer should be updated.
-        CheckBuffer(d3d11Buffer->GetD3D11NonConstantBuffer(), expectedData);
-        // The constant buffer should not be updated, until the constant buffer is used a pipeline
-        CheckBuffer(d3d11Buffer->GetD3D11ConstantBuffer(), data);
+        CheckBuffer(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), expectedData);
+        // The constant buffer should be updated too.
+        CheckBuffer(d3d11Buffer->GetD3D11ConstantBufferForTesting(), expectedData);
     }
 
     // Copy the uniform buffer content to a new buffer with Compute shader
@@ -316,9 +316,9 @@
         EXPECT_BUFFER_U32_RANGE_EQ(expectedData.data(), newBuffer, 0, expectedData.size());
 
         // The non-constant buffer should be updated.
-        CheckBuffer(d3d11Buffer->GetD3D11NonConstantBuffer(), expectedData);
+        CheckBuffer(d3d11Buffer->GetD3D11NonConstantBufferForTesting(), expectedData);
         // The constant buffer should be updated too.
-        CheckBuffer(d3d11Buffer->GetD3D11ConstantBuffer(), expectedData);
+        CheckBuffer(d3d11Buffer->GetD3D11ConstantBufferForTesting(), expectedData);
     }
 }