diff --git a/src/dawn/common/RefBase.h b/src/dawn/common/RefBase.h
index 3601489..9785407 100644
--- a/src/dawn/common/RefBase.h
+++ b/src/dawn/common/RefBase.h
@@ -149,12 +149,25 @@
         return &mValue;
     }
 
+    // Cast operator.
+    template <typename Other>
+    Other Cast() && {
+        Other other;
+        CastImpl(this, &other);
+        return other;
+    }
+
   private:
     // Friend is needed so that instances of RefBase<U> can call Reference and Release on
     // RefBase<T>.
     template <typename U, typename UTraits>
     friend class RefBase;
 
+    template <typename U, typename UTraits, typename = typename std::is_convertible<U, T>::type>
+    static void CastImpl(RefBase<T, Traits>* ref, RefBase<U, UTraits>* other) {
+        other->Acquire(static_cast<U>(ref->Detach()));
+    }
+
     static void Reference(T value) {
         if (value != Traits::kNullValue) {
             Traits::Reference(value);
diff --git a/src/dawn/native/BUILD.gn b/src/dawn/native/BUILD.gn
index 1fa418c..d8c126c 100644
--- a/src/dawn/native/BUILD.gn
+++ b/src/dawn/native/BUILD.gn
@@ -354,6 +354,8 @@
     "SharedBufferMemory.h",
     "SharedFence.cpp",
     "SharedFence.h",
+    "SharedResourceMemory.cpp",
+    "SharedResourceMemory.h",
     "SharedTextureMemory.cpp",
     "SharedTextureMemory.h",
     "Subresource.cpp",
diff --git a/src/dawn/native/Buffer.cpp b/src/dawn/native/Buffer.cpp
index e508ce2..9ce0de9 100644
--- a/src/dawn/native/Buffer.cpp
+++ b/src/dawn/native/Buffer.cpp
@@ -317,7 +317,7 @@
 // Buffer
 
 BufferBase::BufferBase(DeviceBase* device, const UnpackedPtr<BufferDescriptor>& descriptor)
-    : ApiObjectBase(device, descriptor->label),
+    : SharedResource(device, descriptor->label),
       mSize(descriptor->size),
       mUsage(AddInternalUsages(device, descriptor->usage)),
       mState(descriptor.Get<BufferHostMappedPointer>() ? BufferState::HostMappedPersistent
@@ -328,7 +328,7 @@
 BufferBase::BufferBase(DeviceBase* device,
                        const BufferDescriptor* descriptor,
                        ObjectBase::ErrorTag tag)
-    : ApiObjectBase(device, tag, descriptor->label),
+    : SharedResource(device, tag, descriptor->label),
       mSize(descriptor->size),
       mUsage(descriptor->usage),
       mState(descriptor->mappedAtCreation ? BufferState::MappedAtCreation : BufferState::Unmapped) {
@@ -444,7 +444,7 @@
     }
     // Mark the buffer as initialized since we don't want to later clear it using the GPU since that
     // would overwrite what the client wrote using the CPU.
-    SetIsDataInitialized();
+    SetInitialized(true);
 
     return {};
 }
@@ -863,14 +863,6 @@
     return !mIsDataInitialized && GetDevice()->IsToggleEnabled(Toggle::LazyClearResourceOnFirstUse);
 }
 
-bool BufferBase::IsDataInitialized() const {
-    return mIsDataInitialized;
-}
-
-void BufferBase::SetIsDataInitialized() {
-    mIsDataInitialized = true;
-}
-
 void BufferBase::MarkUsedInPendingCommands() {
     ExecutionSerial serial = GetDevice()->GetQueue()->GetPendingCommandSerial();
     DAWN_ASSERT(serial >= mLastUsageSerial);
@@ -885,6 +877,22 @@
     mState = hasAccess ? BufferState::Unmapped : BufferState::SharedMemoryNoAccess;
 }
 
+bool BufferBase::HasAccess() const {
+    return mState != BufferState::SharedMemoryNoAccess;
+}
+
+bool BufferBase::IsDestroyed() const {
+    return mState == BufferState::Destroyed;
+}
+
+void BufferBase::SetInitialized(bool initialized) {
+    mIsDataInitialized = initialized;
+}
+
+bool BufferBase::IsInitialized() const {
+    return mIsDataInitialized;
+}
+
 bool BufferBase::IsFullBufferRange(uint64_t offset, uint64_t size) const {
     return offset == 0 && size == GetSize();
 }
diff --git a/src/dawn/native/Buffer.h b/src/dawn/native/Buffer.h
index 5db99ce..3e755022 100644
--- a/src/dawn/native/Buffer.h
+++ b/src/dawn/native/Buffer.h
@@ -69,7 +69,7 @@
 static constexpr wgpu::BufferUsage kReadOnlyShaderBufferUsages =
     kShaderBufferUsages & kReadOnlyBufferUsages;
 
-class BufferBase : public ApiObjectBase {
+class BufferBase : public SharedResource {
   public:
     enum class BufferState {
         Unmapped,
@@ -101,12 +101,14 @@
 
     bool IsFullBufferRange(uint64_t offset, uint64_t size) const;
     bool NeedsInitialization() const;
-    bool IsDataInitialized() const;
-    void SetIsDataInitialized();
     void MarkUsedInPendingCommands();
 
-    // SetHasAccess determines Dawn's ability to access SharedBufferMemory.
-    void SetHasAccess(bool hasAccess);
+    // SharedResource impl.
+    void SetHasAccess(bool hasAccess) override;
+    bool HasAccess() const override;
+    bool IsDestroyed() const override;
+    void SetInitialized(bool initialized) override;
+    bool IsInitialized() const override;
 
     virtual void* GetMappedPointer() = 0;
     void* GetMappedRange(size_t offset, size_t size, bool writable = true);
@@ -144,9 +146,6 @@
 
     ExecutionSerial mLastUsageSerial = ExecutionSerial(0);
 
-    // The shared buffer memory state the buffer was created from. May be null.
-    Ref<SharedBufferMemoryContents> mSharedBufferMemoryContents;
-
   private:
     std::function<void()> PrepareMappingCallback(MapRequestID mapID,
                                                  WGPUBufferMapAsyncStatus status);
diff --git a/src/dawn/native/CMakeLists.txt b/src/dawn/native/CMakeLists.txt
index 57b6d75..6058500 100644
--- a/src/dawn/native/CMakeLists.txt
+++ b/src/dawn/native/CMakeLists.txt
@@ -213,6 +213,8 @@
     "SharedBufferMemory.h"
     "SharedFence.cpp"
     "SharedFence.h"
+    "SharedResourceMemory.cpp"
+    "SharedResourceMemory.h"
     "SharedTextureMemory.cpp"
     "SharedTextureMemory.h"
     "Subresource.cpp"
diff --git a/src/dawn/native/CommandEncoder.cpp b/src/dawn/native/CommandEncoder.cpp
index cd33fac..be9bc74 100644
--- a/src/dawn/native/CommandEncoder.cpp
+++ b/src/dawn/native/CommandEncoder.cpp
@@ -855,9 +855,9 @@
 
     // In the internal shader to convert timestamps to nanoseconds, we can ensure no uninitialized
     // data will be read and the full buffer range will be filled with valid data.
-    if (!destination->IsDataInitialized() &&
+    if (!destination->IsInitialized() &&
         destination->IsFullBufferRange(firstQuery, sizeof(uint64_t) * queryCount)) {
-        destination->SetIsDataInitialized();
+        destination->SetInitialized(true);
     }
 
     return EncodeConvertTimestampsToNanoseconds(encoder, destination, availabilityBuffer.Get(),
diff --git a/src/dawn/native/ScratchBuffer.cpp b/src/dawn/native/ScratchBuffer.cpp
index 8589a97..4fb1f22 100644
--- a/src/dawn/native/ScratchBuffer.cpp
+++ b/src/dawn/native/ScratchBuffer.cpp
@@ -46,7 +46,7 @@
         descriptor.size = capacity;
         descriptor.usage = mUsage;
         DAWN_TRY_ASSIGN(mBuffer, mDevice->CreateBuffer(&descriptor));
-        mBuffer->SetIsDataInitialized();
+        mBuffer->SetInitialized(true);
     }
     return {};
 }
diff --git a/src/dawn/native/SharedBufferMemory.cpp b/src/dawn/native/SharedBufferMemory.cpp
index 384e290..cc9bded 100644
--- a/src/dawn/native/SharedBufferMemory.cpp
+++ b/src/dawn/native/SharedBufferMemory.cpp
@@ -60,13 +60,13 @@
 SharedBufferMemoryBase::SharedBufferMemoryBase(DeviceBase* device,
                                                const SharedBufferMemoryDescriptor* descriptor,
                                                ObjectBase::ErrorTag tag)
-    : ApiObjectBase(device, tag, descriptor->label),
+    : SharedResourceMemory(device, tag, descriptor->label),
       mProperties{nullptr, wgpu::BufferUsage::None, 0} {}
 
 SharedBufferMemoryBase::SharedBufferMemoryBase(DeviceBase* device,
                                                const char* label,
                                                const SharedBufferMemoryProperties& properties)
-    : ApiObjectBase(device, label), mProperties(properties) {
+    : SharedResourceMemory(device, label), mProperties(properties) {
     GetObjectTrackingList()->Track(this);
 }
 
@@ -74,13 +74,6 @@
     return ObjectType::SharedBufferMemory;
 }
 
-void SharedBufferMemoryBase::DestroyImpl() {}
-
-void SharedBufferMemoryBase::Initialize() {
-    DAWN_ASSERT(!IsError());
-    mContents = CreateContents();
-}
-
 void SharedBufferMemoryBase::APIGetProperties(SharedBufferMemoryProperties* properties) const {
     properties->usage = mProperties.usage;
     properties->size = mProperties.size;
@@ -137,35 +130,6 @@
     return buffer;
 }
 
-Ref<SharedBufferMemoryContents> SharedBufferMemoryBase::CreateContents() {
-    return AcquireRef(new SharedBufferMemoryContents(GetWeakRef(this)));
-}
-
-SharedBufferMemoryContents* SharedBufferMemoryBase::GetContents() const {
-    return mContents.Get();
-}
-
-bool SharedBufferMemoryBase::APIBeginAccess(BufferBase* buffer,
-                                            const BeginAccessDescriptor* descriptor) {
-    return false;
-}
-
-bool SharedBufferMemoryBase::APIEndAccess(BufferBase* buffer, EndAccessState* state) {
-    return false;
-}
-
-bool SharedBufferMemoryBase::APIIsDeviceLost() {
-    return GetDevice()->IsLost();
-}
-
-SharedBufferMemoryContents::SharedBufferMemoryContents(
-    WeakRef<SharedBufferMemoryBase> sharedBufferMemory)
-    : mSharedBufferMemory(std::move(sharedBufferMemory)) {}
-
-const WeakRef<SharedBufferMemoryBase>& SharedBufferMemoryContents::GetSharedBufferMemory() const {
-    return mSharedBufferMemory;
-}
-
 void APISharedBufferMemoryEndAccessStateFreeMembers(WGPUSharedBufferMemoryEndAccessState cState) {
     auto* state = reinterpret_cast<SharedBufferMemoryBase::EndAccessState*>(&cState);
     for (size_t i = 0; i < state->fenceCount; ++i) {
diff --git a/src/dawn/native/SharedBufferMemory.h b/src/dawn/native/SharedBufferMemory.h
index fac946e..64c1731 100644
--- a/src/dawn/native/SharedBufferMemory.h
+++ b/src/dawn/native/SharedBufferMemory.h
@@ -34,44 +34,29 @@
 #include "dawn/native/Forward.h"
 #include "dawn/native/ObjectBase.h"
 #include "dawn/native/SharedFence.h"
+#include "dawn/native/SharedResourceMemory.h"
 #include "dawn/native/dawn_platform.h"
 
 namespace dawn::native {
 
-class SharedBufferMemoryContents;
 struct SharedBufferMemoryDescriptor;
 struct SharedBufferMemoryBeginAccessDescriptor;
 struct SharedBufferMemoryEndAccessState;
 struct SharedBufferMemoryProperties;
 struct BufferDescriptor;
 
-class SharedBufferMemoryBase : public ApiObjectBase, public WeakRefSupport<SharedBufferMemoryBase> {
+class SharedBufferMemoryBase : public SharedResourceMemory {
   public:
     using BeginAccessDescriptor = SharedBufferMemoryBeginAccessDescriptor;
     using EndAccessState = SharedBufferMemoryEndAccessState;
-
     static SharedBufferMemoryBase* MakeError(DeviceBase* device,
                                              const SharedBufferMemoryDescriptor* descriptor);
 
-    void Initialize();
-
     void APIGetProperties(SharedBufferMemoryProperties* properties) const;
     BufferBase* APICreateBuffer(const BufferDescriptor* descriptor);
-    // Returns true if access was acquired. If it returns true, then APIEndAccess must
-    // be called to release access. Other errors may occur even if `true` is returned.
-    // Use an error scope to catch them.
-    bool APIBeginAccess(BufferBase* buffer, const BeginAccessDescriptor* descriptor);
-    // Returns true if access was released.
-    bool APIEndAccess(BufferBase* buffer, EndAccessState* state);
-    // Returns true iff the device passed to this object on creation is now lost.
-    // TODO(crbug.com/1506468): Eliminate this API once Chromium has been
-    // transitioned away from using it in favor of observing device lost events.
-    bool APIIsDeviceLost();
 
     ObjectType GetType() const override;
 
-    SharedBufferMemoryContents* GetContents() const;
-
   protected:
     SharedBufferMemoryBase(DeviceBase* device,
                            const char* label,
@@ -80,29 +65,13 @@
                            const SharedBufferMemoryDescriptor* descriptor,
                            ObjectBase::ErrorTag tag);
 
-    void DestroyImpl() override;
-
     SharedBufferMemoryProperties mProperties;
 
   private:
-    virtual Ref<SharedBufferMemoryContents> CreateContents();
-
     ResultOrError<Ref<BufferBase>> CreateBuffer(const BufferDescriptor* rawDescriptor);
 
     virtual ResultOrError<Ref<BufferBase>> CreateBufferImpl(
         const UnpackedPtr<BufferDescriptor>& descriptor) = 0;
-
-    Ref<SharedBufferMemoryContents> mContents;
-};
-
-class SharedBufferMemoryContents : public RefCounted {
-  public:
-    explicit SharedBufferMemoryContents(WeakRef<SharedBufferMemoryBase> sharedBufferMemory);
-
-    const WeakRef<SharedBufferMemoryBase>& GetSharedBufferMemory() const;
-
-  private:
-    WeakRef<SharedBufferMemoryBase> mSharedBufferMemory;
 };
 
 }  // namespace dawn::native
diff --git a/src/dawn/native/SharedResourceMemory.cpp b/src/dawn/native/SharedResourceMemory.cpp
new file mode 100644
index 0000000..ade989b
--- /dev/null
+++ b/src/dawn/native/SharedResourceMemory.cpp
@@ -0,0 +1,314 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "dawn/native/SharedResourceMemory.h"
+
+#include <utility>
+
+#include "dawn/native/Buffer.h"
+#include "dawn/native/ChainUtils.h"
+#include "dawn/native/Device.h"
+#include "dawn/native/Queue.h"
+#include "dawn/native/Texture.h"
+
+namespace dawn::native {
+
+SharedResource::~SharedResource() = default;
+
+SharedResourceMemoryContents* SharedResource::GetSharedResourceMemoryContents() const {
+    return mSharedResourceMemoryContents.Get();
+}
+
+SharedResourceMemory::SharedResourceMemory(DeviceBase* device,
+                                           ObjectBase::ErrorTag tag,
+                                           const char* label)
+    : ApiObjectBase(device, tag, label),
+      mContents(new SharedResourceMemoryContents(GetWeakRef(this))) {}
+
+SharedResourceMemory::~SharedResourceMemory() = default;
+
+void SharedResourceMemory::DestroyImpl() {}
+
+bool SharedResourceMemory::HasWriteAccess() const {
+    return mHasWriteAccess;
+}
+
+bool SharedResourceMemory::HasExclusiveReadAccess() const {
+    return mHasExclusiveReadAccess;
+}
+
+int SharedResourceMemory::GetReadAccessCount() const {
+    return mReadAccessCount;
+}
+
+void SharedResourceMemory::Initialize() {
+    DAWN_ASSERT(!IsError());
+    mContents = CreateContents();
+}
+
+Ref<SharedResourceMemoryContents> SharedResourceMemory::CreateContents() {
+    return AcquireRef(new SharedResourceMemoryContents(GetWeakRef(this)));
+}
+
+SharedResourceMemoryContents* SharedResourceMemory::GetContents() const {
+    return mContents.Get();
+}
+
+MaybeError SharedResourceMemory::ValidateResourceCreatedFromSelf(SharedResource* resource) {
+    auto* contents = resource->GetSharedResourceMemoryContents();
+    DAWN_INVALID_IF(contents == nullptr, "%s was not created from %s.", resource, this);
+
+    auto* sharedResourceMemory =
+        resource->GetSharedResourceMemoryContents()->GetSharedResourceMemory().Promote().Get();
+    DAWN_INVALID_IF(sharedResourceMemory != this, "%s created from %s cannot be used with %s.",
+                    resource, sharedResourceMemory, this);
+    return {};
+}
+
+bool SharedResourceMemory::APIBeginAccess(
+    TextureBase* texture,
+    const SharedTextureMemoryBeginAccessDescriptor* descriptor) {
+    return !GetDevice()->ConsumedError(BeginAccess(texture, descriptor),
+                                       "calling %s.BeginAccess(%s).", this, texture);
+}
+
+bool SharedResourceMemory::APIBeginAccess(
+    BufferBase* buffer,
+    const SharedBufferMemoryBeginAccessDescriptor* descriptor) {
+    return !GetDevice()->ConsumedError(BeginAccess(buffer, descriptor),
+                                       "calling %s.BeginAccess(%s).", this, buffer);
+}
+
+template <typename Resource, typename BeginAccessDescriptor>
+MaybeError SharedResourceMemory::BeginAccess(Resource* resource,
+                                             const BeginAccessDescriptor* rawDescriptor) {
+    DAWN_TRY(GetDevice()->ValidateIsAlive());
+    DAWN_TRY(GetDevice()->ValidateObject(resource));
+
+    UnpackedPtr<BeginAccessDescriptor> descriptor;
+    DAWN_TRY_ASSIGN(descriptor, ValidateAndUnpack(rawDescriptor));
+
+    for (size_t i = 0; i < descriptor->fenceCount; ++i) {
+        DAWN_TRY(GetDevice()->ValidateObject(descriptor->fences[i]));
+    }
+
+    DAWN_TRY(ValidateResourceCreatedFromSelf(resource));
+
+    DAWN_INVALID_IF(resource->IsDestroyed(), "%s has been destroyed.", resource);
+    DAWN_INVALID_IF(resource->HasAccess(), "%s is already used to access %s.", resource, this);
+
+    if constexpr (std::is_same_v<Resource, TextureBase>) {
+        DAWN_INVALID_IF(resource->GetFormat().IsMultiPlanar() && !descriptor->initialized,
+                        "%s with multiplanar format (%s) must be initialized.", resource,
+                        resource->GetFormat().format);
+    }
+    DAWN_INVALID_IF(mHasWriteAccess, "%s is currently accessed for writing.", this);
+    DAWN_INVALID_IF(mHasExclusiveReadAccess, "%s is currently accessed for exclusive reading.",
+                    this);
+
+    if constexpr (std::is_same_v<Resource, TextureBase>) {
+        if (static_cast<TextureBase*>(resource)->IsReadOnly()) {
+            if (descriptor->concurrentRead) {
+                DAWN_INVALID_IF(!descriptor->initialized, "Concurrent reading an uninitialized %s.",
+                                resource);
+                ++mReadAccessCount;
+            } else {
+                DAWN_INVALID_IF(
+                    mReadAccessCount != 0,
+                    "Exclusive read access used while %s is currently accessed for reading.", this);
+                mHasExclusiveReadAccess = true;
+            }
+        } else {
+            DAWN_INVALID_IF(descriptor->concurrentRead, "Concurrent reading read-write %s.",
+                            resource);
+            DAWN_INVALID_IF(mReadAccessCount != 0,
+                            "Read-Write access used while %s is currently accessed for reading.",
+                            this);
+            mHasWriteAccess = true;
+        }
+    }
+
+    DAWN_TRY(BeginAccessImpl(resource, descriptor));
+
+    for (size_t i = 0; i < descriptor->fenceCount; ++i) {
+        mContents->mPendingFences->push_back(
+            {descriptor->fences[i], descriptor->signaledValues[i]});
+    }
+
+    DAWN_ASSERT(!resource->IsError());
+    resource->SetHasAccess(true);
+    resource->SetInitialized(descriptor->initialized);
+    return {};
+}
+
+bool SharedResourceMemory::APIEndAccess(TextureBase* texture,
+                                        SharedTextureMemoryEndAccessState* state) {
+    bool didEnd = false;
+    DAWN_UNUSED(GetDevice()->ConsumedError(EndAccess(texture, state, &didEnd),
+                                           "calling %s.EndAccess(%s).", this, texture));
+    return didEnd;
+}
+
+bool SharedResourceMemory::APIEndAccess(BufferBase* buffer,
+                                        SharedBufferMemoryEndAccessState* state) {
+    bool didEnd = false;
+    DAWN_UNUSED(GetDevice()->ConsumedError(EndAccess(buffer, state, &didEnd),
+                                           "calling %s.EndAccess(%s).", this, buffer));
+    return didEnd;
+}
+
+MaybeError SharedResourceMemory::BeginAccessImpl(
+    TextureBase* texture,
+    const UnpackedPtr<SharedTextureMemoryBeginAccessDescriptor>& descriptor) {
+    DAWN_UNREACHABLE();
+}
+
+MaybeError SharedResourceMemory::BeginAccessImpl(
+    BufferBase* buffer,
+    const UnpackedPtr<SharedBufferMemoryBeginAccessDescriptor>& descriptor) {
+    DAWN_UNREACHABLE();
+}
+
+ResultOrError<FenceAndSignalValue> SharedResourceMemory::EndAccessImpl(
+    TextureBase* texture,
+    UnpackedPtr<SharedTextureMemoryEndAccessState>& state) {
+    DAWN_UNREACHABLE();
+}
+
+ResultOrError<FenceAndSignalValue> SharedResourceMemory::EndAccessImpl(
+    BufferBase* buffer,
+    UnpackedPtr<SharedBufferMemoryEndAccessState>& state) {
+    DAWN_UNREACHABLE();
+}
+
+bool SharedResourceMemory::APIIsDeviceLost() const {
+    return GetDevice()->IsLost();
+}
+
+template <typename Resource, typename EndAccessState>
+MaybeError SharedResourceMemory::EndAccess(Resource* resource,
+                                           EndAccessState* state,
+                                           bool* didEnd) {
+    DAWN_TRY(GetDevice()->ValidateObject(resource));
+    DAWN_TRY(ValidateResourceCreatedFromSelf(resource));
+
+    DAWN_INVALID_IF(!resource->HasAccess(), "%s is not currently being accessed.", resource);
+    if constexpr (std::is_same_v<Resource, TextureBase>) {
+        if (static_cast<TextureBase*>(resource)->IsReadOnly()) {
+            DAWN_ASSERT(!mHasWriteAccess);
+            if (mHasExclusiveReadAccess) {
+                DAWN_ASSERT(mReadAccessCount == 0);
+                mHasExclusiveReadAccess = false;
+            } else {
+                DAWN_ASSERT(!mHasExclusiveReadAccess);
+                --mReadAccessCount;
+            }
+        } else {
+            DAWN_ASSERT(mHasWriteAccess);
+            DAWN_ASSERT(!mHasExclusiveReadAccess);
+            DAWN_ASSERT(mReadAccessCount == 0);
+            mHasWriteAccess = false;
+        }
+    }
+
+    PendingFenceList fenceList;
+    mContents->AcquirePendingFences(&fenceList);
+
+    DAWN_ASSERT(!resource->IsError());
+    resource->SetHasAccess(false);
+
+    *didEnd = true;
+
+    // Call the error-generating part of the EndAccess implementation. This is separated out because
+    // writing the output state must happen regardless of whether or not EndAccessInternal
+    // succeeds.
+    MaybeError err;
+    {
+        ResultOrError<FenceAndSignalValue> result = EndAccessInternal(resource, state);
+        if (result.IsSuccess()) {
+            fenceList->push_back(result.AcquireSuccess());
+        } else {
+            err = result.AcquireError();
+        }
+    }
+
+    // Copy the fences to the output state.
+    if (size_t fenceCount = fenceList->size()) {
+        auto* fences = new SharedFenceBase*[fenceCount];
+        uint64_t* signaledValues = new uint64_t[fenceCount];
+        for (size_t i = 0; i < fenceCount; ++i) {
+            fences[i] = ReturnToAPI(std::move(fenceList[i].object));
+            signaledValues[i] = fenceList[i].signaledValue;
+        }
+
+        state->fenceCount = fenceCount;
+        state->fences = fences;
+        state->signaledValues = signaledValues;
+    } else {
+        state->fenceCount = 0;
+        state->fences = nullptr;
+        state->signaledValues = nullptr;
+    }
+    state->initialized = resource->IsInitialized();
+    return err;
+}
+
+template <typename Resource, typename EndAccessState>
+ResultOrError<FenceAndSignalValue> SharedResourceMemory::EndAccessInternal(
+    Resource* resource,
+    EndAccessState* rawState) {
+    UnpackedPtr<EndAccessState> state;
+    DAWN_TRY_ASSIGN(state, ValidateAndUnpack(rawState));
+    // Ensure that commands are submitted before exporting fences with the last usage serial.
+    DAWN_TRY(GetDevice()->GetQueue()->EnsureCommandsFlushed(mContents->GetLastUsageSerial()));
+    return EndAccessImpl(resource, state);
+}
+
+// SharedResourceMemoryContents
+
+SharedResourceMemoryContents::SharedResourceMemoryContents(
+    WeakRef<SharedResourceMemory> sharedResourceMemory)
+    : mSharedResourceMemory(std::move(sharedResourceMemory)) {}
+
+const WeakRef<SharedResourceMemory>& SharedResourceMemoryContents::GetSharedResourceMemory() const {
+    return mSharedResourceMemory;
+}
+
+void SharedResourceMemoryContents::AcquirePendingFences(PendingFenceList* fences) {
+    *fences = mPendingFences;
+    mPendingFences->clear();
+}
+
+void SharedResourceMemoryContents::SetLastUsageSerial(ExecutionSerial lastUsageSerial) {
+    mLastUsageSerial = lastUsageSerial;
+}
+
+ExecutionSerial SharedResourceMemoryContents::GetLastUsageSerial() const {
+    return mLastUsageSerial;
+}
+
+}  // namespace dawn::native
diff --git a/src/dawn/native/SharedResourceMemory.h b/src/dawn/native/SharedResourceMemory.h
new file mode 100644
index 0000000..a587dbe
--- /dev/null
+++ b/src/dawn/native/SharedResourceMemory.h
@@ -0,0 +1,172 @@
+// Copyright 2024 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef SRC_DAWN_NATIVE_SHAREDRESOURCEMEMORY_H_
+#define SRC_DAWN_NATIVE_SHAREDRESOURCEMEMORY_H_
+
+#include "dawn/common/StackContainer.h"
+#include "dawn/common/WeakRef.h"
+#include "dawn/common/WeakRefSupport.h"
+#include "dawn/native/Error.h"
+#include "dawn/native/Forward.h"
+#include "dawn/native/IntegerTypes.h"
+#include "dawn/native/ObjectBase.h"
+#include "dawn/native/SharedFence.h"
+#include "dawn/native/dawn_platform.h"
+
+namespace dawn::native {
+
+class SharedResourceMemoryContents;
+
+class SharedResource : public ApiObjectBase {
+  public:
+    using ApiObjectBase::ApiObjectBase;
+    ~SharedResource() override;
+
+    SharedResourceMemoryContents* GetSharedResourceMemoryContents() const;
+
+    virtual void SetHasAccess(bool hasAccess) = 0;
+    virtual bool HasAccess() const = 0;
+    virtual bool IsDestroyed() const = 0;
+    virtual void SetInitialized(bool initialized) = 0;
+    virtual bool IsInitialized() const = 0;
+
+  protected:
+    // The shared contents the resource was created from. May be null.
+    Ref<SharedResourceMemoryContents> mSharedResourceMemoryContents;
+};
+
+class SharedResourceMemory : public ApiObjectBase, public WeakRefSupport<SharedResourceMemory> {
+  public:
+    using PendingFenceList = StackVector<FenceAndSignalValue, 1>;
+
+    ~SharedResourceMemory() override;
+    void Initialize();
+    void DestroyImpl() override;
+
+    // Returns true if access was acquired. If it returns true, then APIEndAccess must
+    // be called to release access. Other errors may occur even if `true` is returned.
+    // Use an error scope to catch them.
+    bool APIBeginAccess(TextureBase* texture,
+                        const SharedTextureMemoryBeginAccessDescriptor* descriptor);
+    // Returns true if access was released.
+    bool APIEndAccess(TextureBase* texture, SharedTextureMemoryEndAccessState* state);
+
+    // Returns true if access was acquired. If it returns true, then APIEndAccess must
+    // be called to release access. Other errors may occur even if `true` is returned.
+    // Use an error scope to catch them.
+    bool APIBeginAccess(BufferBase* buffer,
+                        const SharedBufferMemoryBeginAccessDescriptor* descriptor);
+    // Returns true if access was released.
+    bool APIEndAccess(BufferBase* buffer, SharedBufferMemoryEndAccessState* state);
+
+    // Returns true iff the device passed to this object on creation is now lost.
+    // TODO(crbug.com/1506468): Eliminate this API once Chromium has been
+    // transitioned away from using it in favor of observing device lost events.
+    bool APIIsDeviceLost() const;
+
+    SharedResourceMemoryContents* GetContents() const;
+
+    // Validate that the resource was created from this SharedResourceMemory.
+    MaybeError ValidateResourceCreatedFromSelf(SharedResource* resource);
+
+  protected:
+    SharedResourceMemory(DeviceBase* device, ObjectBase::ErrorTag, const char* label);
+    using ApiObjectBase::ApiObjectBase;
+
+    bool HasWriteAccess() const;
+    bool HasExclusiveReadAccess() const;
+    int GetReadAccessCount() const;
+
+  private:
+    virtual Ref<SharedResourceMemoryContents> CreateContents();
+
+    template <typename Resource, typename BeginAccessDescriptor>
+    MaybeError BeginAccess(Resource* resource, const BeginAccessDescriptor* rawDescriptor);
+
+    template <typename Resource, typename EndAccessState>
+    MaybeError EndAccess(Resource* resource, EndAccessState* state, bool* didEnd);
+
+    template <typename Resource, typename EndAccessState>
+    ResultOrError<FenceAndSignalValue> EndAccessInternal(Resource* resource,
+                                                         EndAccessState* rawState);
+
+    // BeginAccessImpl validates the operation is valid on the backend, and performs any
+    // backend specific operations. It does NOT need to acquire begin fences; that is done in the
+    // frontend in BeginAccess.
+    virtual MaybeError BeginAccessImpl(
+        TextureBase* texture,
+        const UnpackedPtr<SharedTextureMemoryBeginAccessDescriptor>& descriptor);
+    virtual MaybeError BeginAccessImpl(
+        BufferBase* buffer,
+        const UnpackedPtr<SharedBufferMemoryBeginAccessDescriptor>& descriptor);
+    // EndAccessImpl validates the operation is valid on the backend, and returns the end fence.
+    // It should also write out any backend specific state in chained out structs of EndAccessState.
+    virtual ResultOrError<FenceAndSignalValue> EndAccessImpl(
+        TextureBase* texture,
+        UnpackedPtr<SharedTextureMemoryEndAccessState>& state);
+    virtual ResultOrError<FenceAndSignalValue> EndAccessImpl(
+        BufferBase* buffer,
+        UnpackedPtr<SharedBufferMemoryEndAccessState>& state);
+
+    bool mHasWriteAccess = false;
+    bool mHasExclusiveReadAccess = false;
+    int mReadAccessCount = 0;
+    Ref<SharedResourceMemoryContents> mContents;
+};
+
+// SharedResourceMemoryContents is a separate object because it needs to live as long as
+// the SharedResourceMemory or any resources created from the SharedResourceMemory. This
+// allows state and objects needed by the resource to persist after the
+// SharedResourceMemory itself has been dropped.
+class SharedResourceMemoryContents : public RefCounted {
+  public:
+    using PendingFenceList = SharedResourceMemory::PendingFenceList;
+
+    explicit SharedResourceMemoryContents(WeakRef<SharedResourceMemory> sharedResourceMemory);
+
+    void AcquirePendingFences(PendingFenceList* fences);
+
+    // Set the last usage serial. This indicates when the SharedFence exported
+    // from APIEndAccess will complete.
+    void SetLastUsageSerial(ExecutionSerial lastUsageSerial);
+    ExecutionSerial GetLastUsageSerial() const;
+
+    const WeakRef<SharedResourceMemory>& GetSharedResourceMemory() const;
+
+  private:
+    friend class SharedResourceMemory;
+
+    PendingFenceList mPendingFences;
+    ExecutionSerial mLastUsageSerial{0};
+
+    WeakRef<SharedResourceMemory> mSharedResourceMemory;
+};
+
+}  // namespace dawn::native
+
+#endif  // SRC_DAWN_NATIVE_SHAREDRESOURCEMEMORY_H_
diff --git a/src/dawn/native/SharedTextureMemory.cpp b/src/dawn/native/SharedTextureMemory.cpp
index 90e1098..01f84e1 100644
--- a/src/dawn/native/SharedTextureMemory.cpp
+++ b/src/dawn/native/SharedTextureMemory.cpp
@@ -44,7 +44,7 @@
     ErrorSharedTextureMemory(DeviceBase* device, const SharedTextureMemoryDescriptor* descriptor)
         : SharedTextureMemoryBase(device, descriptor, ObjectBase::kError) {}
 
-    Ref<SharedTextureMemoryContents> CreateContents() override { DAWN_UNREACHABLE(); }
+    Ref<SharedResourceMemoryContents> CreateContents() override { DAWN_UNREACHABLE(); }
     ResultOrError<Ref<TextureBase>> CreateTextureImpl(
         const UnpackedPtr<TextureDescriptor>& descriptor) override {
         DAWN_UNREACHABLE();
@@ -57,6 +57,7 @@
                                                      UnpackedPtr<EndAccessState>& state) override {
         DAWN_UNREACHABLE();
     }
+    void DestroyImpl() override {}
 };
 
 }  // namespace
@@ -71,19 +72,18 @@
 SharedTextureMemoryBase::SharedTextureMemoryBase(DeviceBase* device,
                                                  const SharedTextureMemoryDescriptor* descriptor,
                                                  ObjectBase::ErrorTag tag)
-    : ApiObjectBase(device, tag, descriptor->label),
+    : SharedResourceMemory(device, tag, descriptor->label),
       mProperties{
           nullptr,
           wgpu::TextureUsage::None,
           {0, 0, 0},
           wgpu::TextureFormat::Undefined,
-      },
-      mContents(new SharedTextureMemoryContents(GetWeakRef(this))) {}
+      } {}
 
 SharedTextureMemoryBase::SharedTextureMemoryBase(DeviceBase* device,
                                                  const char* label,
                                                  const SharedTextureMemoryProperties& properties)
-    : ApiObjectBase(device, label), mProperties(properties) {
+    : SharedResourceMemory(device, label), mProperties(properties) {
     // Reify properties to ensure we don't expose capabilities not supported by the device.
     const Format& internalFormat = device->GetValidInternalFormat(mProperties.format);
     if (!internalFormat.supportsStorageUsage || internalFormat.IsMultiPlanar()) {
@@ -105,25 +105,6 @@
     return ObjectType::SharedTextureMemory;
 }
 
-void SharedTextureMemoryBase::DestroyImpl() {}
-
-bool SharedTextureMemoryBase::HasWriteAccess() const {
-    return mHasWriteAccess;
-}
-
-bool SharedTextureMemoryBase::HasExclusiveReadAccess() const {
-    return mHasExclusiveReadAccess;
-}
-
-int SharedTextureMemoryBase::GetReadAccessCount() const {
-    return mReadAccessCount;
-}
-
-void SharedTextureMemoryBase::Initialize() {
-    DAWN_ASSERT(!IsError());
-    mContents = CreateContents();
-}
-
 void SharedTextureMemoryBase::APIGetProperties(SharedTextureMemoryProperties* properties) const {
     properties->usage = mProperties.usage;
     properties->size = mProperties.size;
@@ -157,10 +138,6 @@
     return ReturnToAPI(std::move(result));
 }
 
-Ref<SharedTextureMemoryContents> SharedTextureMemoryBase::CreateContents() {
-    return AcquireRef(new SharedTextureMemoryContents(GetWeakRef(this)));
-}
-
 ResultOrError<Ref<TextureBase>> SharedTextureMemoryBase::CreateTexture(
     const TextureDescriptor* rawDescriptor) {
     DAWN_TRY(GetDevice()->ValidateIsAlive());
@@ -205,198 +182,6 @@
     return texture;
 }
 
-SharedTextureMemoryContents* SharedTextureMemoryBase::GetContents() const {
-    return mContents.Get();
-}
-
-MaybeError SharedTextureMemoryBase::ValidateTextureCreatedFromSelf(TextureBase* texture) {
-    auto* contents = texture->GetSharedTextureMemoryContents();
-    DAWN_INVALID_IF(contents == nullptr, "%s was not created from %s.", texture, this);
-
-    auto* sharedTextureMemory =
-        texture->GetSharedTextureMemoryContents()->GetSharedTextureMemory().Promote().Get();
-    DAWN_INVALID_IF(sharedTextureMemory != this, "%s created from %s cannot be used with %s.",
-                    texture, sharedTextureMemory, this);
-    return {};
-}
-
-bool SharedTextureMemoryBase::APIBeginAccess(TextureBase* texture,
-                                             const BeginAccessDescriptor* descriptor) {
-    if (GetDevice()->ConsumedError(BeginAccess(texture, descriptor), "calling %s.BeginAccess(%s).",
-                                   this, texture)) {
-        return false;
-    }
-    return true;
-}
-
-bool SharedTextureMemoryBase::APIIsDeviceLost() {
-    return GetDevice()->IsLost();
-}
-
-MaybeError SharedTextureMemoryBase::BeginAccess(TextureBase* texture,
-                                                const BeginAccessDescriptor* rawDescriptor) {
-    DAWN_TRY(GetDevice()->ValidateIsAlive());
-    DAWN_TRY(GetDevice()->ValidateObject(texture));
-
-    UnpackedPtr<BeginAccessDescriptor> descriptor;
-    DAWN_TRY_ASSIGN(descriptor, ValidateAndUnpack(rawDescriptor));
-
-    for (size_t i = 0; i < descriptor->fenceCount; ++i) {
-        DAWN_TRY(GetDevice()->ValidateObject(descriptor->fences[i]));
-    }
-
-    DAWN_TRY(ValidateTextureCreatedFromSelf(texture));
-
-    DAWN_INVALID_IF(texture->GetFormat().IsMultiPlanar() && !descriptor->initialized,
-                    "%s with multiplanar format (%s) must be initialized.", texture,
-                    texture->GetFormat().format);
-
-    DAWN_INVALID_IF(texture->IsDestroyed(), "%s has been destroyed.", texture);
-    DAWN_INVALID_IF(texture->HasAccess(), "%s is already used to access %s.", texture, this);
-
-    DAWN_INVALID_IF(mHasWriteAccess, "%s is currently accessed for writing.", this);
-    DAWN_INVALID_IF(mHasExclusiveReadAccess, "%s is currently accessed for exclusive reading.",
-                    this);
-
-    if (texture->IsReadOnly()) {
-        if (descriptor->concurrentRead) {
-            DAWN_INVALID_IF(!descriptor->initialized, "Concurrent reading an uninitialized %s.",
-                            texture);
-            ++mReadAccessCount;
-        } else {
-            DAWN_INVALID_IF(
-                mReadAccessCount != 0,
-                "Exclusive read access used while %s is currently accessed for reading.", this);
-            mHasExclusiveReadAccess = true;
-        }
-    } else {
-        DAWN_INVALID_IF(descriptor->concurrentRead, "Concurrent reading read-write %s.", texture);
-        DAWN_INVALID_IF(mReadAccessCount != 0,
-                        "Read-Write access used while %s is currently accessed for reading.", this);
-        mHasWriteAccess = true;
-    }
-
-    DAWN_TRY(BeginAccessImpl(texture, descriptor));
-
-    for (size_t i = 0; i < descriptor->fenceCount; ++i) {
-        mContents->mPendingFences->push_back(
-            {descriptor->fences[i], descriptor->signaledValues[i]});
-    }
-
-    DAWN_ASSERT(!texture->IsError());
-    texture->SetHasAccess(true);
-    texture->SetIsSubresourceContentInitialized(descriptor->initialized,
-                                                texture->GetAllSubresources());
-    return {};
-}
-
-bool SharedTextureMemoryBase::APIEndAccess(TextureBase* texture, EndAccessState* state) {
-    bool didEnd = false;
-    DAWN_UNUSED(GetDevice()->ConsumedError(EndAccess(texture, state, &didEnd),
-                                           "calling %s.EndAccess(%s).", this, texture));
-    return didEnd;
-}
-
-MaybeError SharedTextureMemoryBase::EndAccess(TextureBase* texture,
-                                              EndAccessState* state,
-                                              bool* didEnd) {
-    DAWN_TRY(GetDevice()->ValidateObject(texture));
-    DAWN_TRY(ValidateTextureCreatedFromSelf(texture));
-
-    DAWN_INVALID_IF(!texture->HasAccess(), "%s is not currently being accessed.", texture);
-
-    if (texture->IsReadOnly()) {
-        DAWN_ASSERT(!mHasWriteAccess);
-        if (mHasExclusiveReadAccess) {
-            DAWN_ASSERT(mReadAccessCount == 0);
-            mHasExclusiveReadAccess = false;
-        } else {
-            DAWN_ASSERT(!mHasExclusiveReadAccess);
-            --mReadAccessCount;
-        }
-    } else {
-        DAWN_ASSERT(mHasWriteAccess);
-        DAWN_ASSERT(!mHasExclusiveReadAccess);
-        DAWN_ASSERT(mReadAccessCount == 0);
-        mHasWriteAccess = false;
-    }
-
-    PendingFenceList fenceList;
-    mContents->AcquirePendingFences(&fenceList);
-
-    DAWN_ASSERT(!texture->IsError());
-    texture->SetHasAccess(false);
-
-    *didEnd = true;
-
-    // Call the error-generating part of the EndAccess implementation. This is separated out because
-    // writing the output state must happen regardless of whether or not EndAccessInternal
-    // succeeds.
-    MaybeError err;
-    {
-        ResultOrError<FenceAndSignalValue> result = EndAccessInternal(texture, state);
-        if (result.IsSuccess()) {
-            fenceList->push_back(result.AcquireSuccess());
-        } else {
-            err = result.AcquireError();
-        }
-    }
-
-    // Copy the fences to the output state.
-    if (size_t fenceCount = fenceList->size()) {
-        auto* fences = new SharedFenceBase*[fenceCount];
-        uint64_t* signaledValues = new uint64_t[fenceCount];
-        for (size_t i = 0; i < fenceCount; ++i) {
-            fences[i] = ReturnToAPI(std::move(fenceList[i].object));
-            signaledValues[i] = fenceList[i].signaledValue;
-        }
-
-        state->fenceCount = fenceCount;
-        state->fences = fences;
-        state->signaledValues = signaledValues;
-    } else {
-        state->fenceCount = 0;
-        state->fences = nullptr;
-        state->signaledValues = nullptr;
-    }
-    state->initialized = texture->IsSubresourceContentInitialized(texture->GetAllSubresources());
-    return err;
-}
-
-ResultOrError<FenceAndSignalValue> SharedTextureMemoryBase::EndAccessInternal(
-    TextureBase* texture,
-    EndAccessState* rawState) {
-    UnpackedPtr<EndAccessState> state;
-    DAWN_TRY_ASSIGN(state, ValidateAndUnpack(rawState));
-    // Ensure that commands are submitted before exporting fences with the last usage serial.
-    DAWN_TRY(GetDevice()->GetQueue()->EnsureCommandsFlushed(mContents->GetLastUsageSerial()));
-    return EndAccessImpl(texture, state);
-}
-
-// SharedTextureMemoryContents
-
-SharedTextureMemoryContents::SharedTextureMemoryContents(
-    WeakRef<SharedTextureMemoryBase> sharedTextureMemory)
-    : mSharedTextureMemory(std::move(sharedTextureMemory)) {}
-
-const WeakRef<SharedTextureMemoryBase>& SharedTextureMemoryContents::GetSharedTextureMemory()
-    const {
-    return mSharedTextureMemory;
-}
-
-void SharedTextureMemoryContents::AcquirePendingFences(PendingFenceList* fences) {
-    *fences = mPendingFences;
-    mPendingFences->clear();
-}
-
-void SharedTextureMemoryContents::SetLastUsageSerial(ExecutionSerial lastUsageSerial) {
-    mLastUsageSerial = lastUsageSerial;
-}
-
-ExecutionSerial SharedTextureMemoryContents::GetLastUsageSerial() const {
-    return mLastUsageSerial;
-}
-
 void APISharedTextureMemoryEndAccessStateFreeMembers(WGPUSharedTextureMemoryEndAccessState cState) {
     auto* state = reinterpret_cast<SharedTextureMemoryBase::EndAccessState*>(&cState);
     for (size_t i = 0; i < state->fenceCount; ++i) {
diff --git a/src/dawn/native/SharedTextureMemory.h b/src/dawn/native/SharedTextureMemory.h
index be34418..7751b34 100644
--- a/src/dawn/native/SharedTextureMemory.h
+++ b/src/dawn/native/SharedTextureMemory.h
@@ -36,49 +36,31 @@
 #include "dawn/native/IntegerTypes.h"
 #include "dawn/native/ObjectBase.h"
 #include "dawn/native/SharedFence.h"
+#include "dawn/native/SharedResourceMemory.h"
 #include "dawn/native/dawn_platform.h"
 
 namespace dawn::native {
 
-class SharedTextureMemoryContents;
+class SharedResourceMemoryContents;
 struct SharedTextureMemoryDescriptor;
 struct SharedTextureMemoryBeginAccessDescriptor;
 struct SharedTextureMemoryEndAccessState;
 struct SharedTextureMemoryProperties;
 struct TextureDescriptor;
 
-class SharedTextureMemoryBase : public ApiObjectBase,
-                                public WeakRefSupport<SharedTextureMemoryBase> {
+class SharedTextureMemoryBase : public SharedResourceMemory {
   public:
     using BeginAccessDescriptor = SharedTextureMemoryBeginAccessDescriptor;
     using EndAccessState = SharedTextureMemoryEndAccessState;
-    using PendingFenceList = StackVector<FenceAndSignalValue, 1>;
 
     static Ref<SharedTextureMemoryBase> MakeError(DeviceBase* device,
                                                   const SharedTextureMemoryDescriptor* descriptor);
 
-    void Initialize();
-
     void APIGetProperties(SharedTextureMemoryProperties* properties) const;
     TextureBase* APICreateTexture(const TextureDescriptor* descriptor);
-    // Returns true if access was acquired. If it returns true, then APIEndAccess must
-    // be called to release access. Other errors may occur even if `true` is returned.
-    // Use an error scope to catch them.
-    bool APIBeginAccess(TextureBase* texture, const BeginAccessDescriptor* descriptor);
-    // Returns true if access was released.
-    bool APIEndAccess(TextureBase* texture, EndAccessState* state);
-    // Returns true iff the device passed to this object on creation is now lost.
-    // TODO(crbug.com/1506468): Eliminate this API once Chromium has been
-    // transitioned away from using it in favor of observing device lost events.
-    bool APIIsDeviceLost();
 
     ObjectType GetType() const override;
 
-    SharedTextureMemoryContents* GetContents() const;
-
-    // Validate that the texture was created from this SharedTextureMemory.
-    MaybeError ValidateTextureCreatedFromSelf(TextureBase* texture);
-
   protected:
     SharedTextureMemoryBase(DeviceBase* device,
                             const char* label,
@@ -87,68 +69,13 @@
                             const SharedTextureMemoryDescriptor* descriptor,
                             ObjectBase::ErrorTag tag);
 
-    void DestroyImpl() override;
-
-    bool HasWriteAccess() const;
-    bool HasExclusiveReadAccess() const;
-    int GetReadAccessCount() const;
-
   private:
-    virtual Ref<SharedTextureMemoryContents> CreateContents();
-
     ResultOrError<Ref<TextureBase>> CreateTexture(const TextureDescriptor* rawDescriptor);
-    MaybeError BeginAccess(TextureBase* texture, const BeginAccessDescriptor* rawDescriptor);
-    MaybeError EndAccess(TextureBase* texture, EndAccessState* state, bool* didEnd);
-    ResultOrError<FenceAndSignalValue> EndAccessInternal(TextureBase* texture,
-                                                         EndAccessState* rawState);
 
     virtual ResultOrError<Ref<TextureBase>> CreateTextureImpl(
         const UnpackedPtr<TextureDescriptor>& descriptor) = 0;
 
-    // BeginAccessImpl validates the operation is valid on the backend, and performs any
-    // backend specific operations. It does NOT need to acquire begin fences; that is done in the
-    // frontend in BeginAccess.
-    virtual MaybeError BeginAccessImpl(TextureBase* texture,
-                                       const UnpackedPtr<BeginAccessDescriptor>& descriptor) = 0;
-    // EndAccessImpl validates the operation is valid on the backend, and returns the end fence.
-    // It should also write out any backend specific state in chained out structs of EndAccessState.
-    virtual ResultOrError<FenceAndSignalValue> EndAccessImpl(
-        TextureBase* texture,
-        UnpackedPtr<EndAccessState>& state) = 0;
-
     SharedTextureMemoryProperties mProperties;
-    bool mHasWriteAccess = false;
-    bool mHasExclusiveReadAccess = false;
-    int mReadAccessCount = 0;
-    Ref<SharedTextureMemoryContents> mContents;
-};
-
-// SharedTextureMemoryContents is a separate object because it needs to live as long as
-// the SharedTextureMemory or any textures created from the SharedTextureMemory. This
-// allows state and objects needed by the texture to persist after the
-// SharedTextureMemory itself has been dropped.
-class SharedTextureMemoryContents : public RefCounted {
-  public:
-    using PendingFenceList = SharedTextureMemoryBase::PendingFenceList;
-
-    explicit SharedTextureMemoryContents(WeakRef<SharedTextureMemoryBase> sharedTextureMemory);
-
-    void AcquirePendingFences(PendingFenceList* fences);
-
-    // Set the last usage serial. This indicates when the SharedFence exported
-    // from APIEndAccess will complete.
-    void SetLastUsageSerial(ExecutionSerial lastUsageSerial);
-    ExecutionSerial GetLastUsageSerial() const;
-
-    const WeakRef<SharedTextureMemoryBase>& GetSharedTextureMemory() const;
-
-  private:
-    friend class SharedTextureMemoryBase;
-
-    PendingFenceList mPendingFences;
-    ExecutionSerial mLastUsageSerial{0};
-
-    WeakRef<SharedTextureMemoryBase> mSharedTextureMemory;
 };
 
 }  // namespace dawn::native
diff --git a/src/dawn/native/Texture.cpp b/src/dawn/native/Texture.cpp
index 1dbb297..b15bbe8 100644
--- a/src/dawn/native/Texture.cpp
+++ b/src/dawn/native/Texture.cpp
@@ -725,7 +725,7 @@
 TextureBase::TextureState::TextureState() : hasAccess(true), destroyed(false) {}
 
 TextureBase::TextureBase(DeviceBase* device, const UnpackedPtr<TextureDescriptor>& descriptor)
-    : ApiObjectBase(device, descriptor->label),
+    : SharedResource(device, descriptor->label),
       mDimension(descriptor->dimension),
       mCompatibilityTextureBindingViewDimension(
           ResolveDefaultCompatiblityTextureBindingViewDimension(device, descriptor)),
@@ -787,7 +787,7 @@
 TextureBase::TextureBase(DeviceBase* device,
                          const TextureDescriptor* descriptor,
                          ObjectBase::ErrorTag tag)
-    : ApiObjectBase(device, tag, descriptor->label),
+    : SharedResource(device, tag, descriptor->label),
       mDimension(descriptor->dimension),
       mCompatibilityTextureBindingViewDimension(
           ResolveDefaultCompatiblityTextureBindingViewDimension(device, Unpack(descriptor))),
@@ -973,6 +973,14 @@
     return mState.destroyed;
 }
 
+bool TextureBase::IsInitialized() const {
+    return IsSubresourceContentInitialized(GetAllSubresources());
+}
+
+void TextureBase::SetInitialized(bool initialized) {
+    SetIsSubresourceContentInitialized(initialized, GetAllSubresources());
+}
+
 void TextureBase::SetHasAccess(bool hasAccess) {
     DAWN_ASSERT(!IsError());
     mState.hasAccess = hasAccess;
@@ -1029,8 +1037,11 @@
     if (DAWN_UNLIKELY(mState.destroyed || !mState.hasAccess)) {
         DAWN_INVALID_IF(mState.destroyed, "Destroyed texture %s used in a submit.", this);
         if (DAWN_UNLIKELY(!mState.hasAccess)) {
-            if (mSharedTextureMemoryContents != nullptr) {
-                auto memory = mSharedTextureMemoryContents->GetSharedTextureMemory().Promote();
+            if (mSharedResourceMemoryContents != nullptr) {
+                Ref<SharedTextureMemoryBase> memory =
+                    mSharedResourceMemoryContents->GetSharedResourceMemory()
+                        .Promote()
+                        .Cast<Ref<SharedTextureMemoryBase>>();
                 if (memory != nullptr) {
                     return DAWN_VALIDATION_ERROR("%s used in a submit without current access to %s",
                                                  this, memory.Get());
@@ -1164,10 +1175,6 @@
     return (GetUsage() & wgpu::TextureUsage::TextureBinding) != 0;
 }
 
-SharedTextureMemoryContents* TextureBase::GetSharedTextureMemoryContents() const {
-    return mSharedTextureMemoryContents.Get();
-}
-
 void TextureBase::APIDestroy() {
     Destroy();
 }
diff --git a/src/dawn/native/Texture.h b/src/dawn/native/Texture.h
index 4ca39f6..3180200 100644
--- a/src/dawn/native/Texture.h
+++ b/src/dawn/native/Texture.h
@@ -78,7 +78,7 @@
     wgpu::TextureUsage::TextureBinding | kReadOnlyStorageTexture |
     wgpu::TextureUsage::StorageBinding | kWriteOnlyStorageTexture;
 
-class TextureBase : public ApiObjectBase {
+class TextureBase : public SharedResource {
   public:
     enum class ClearValue { Zero, NonZero };
 
@@ -112,9 +112,14 @@
     wgpu::TextureUsage GetUsage() const;
     wgpu::TextureUsage GetInternalUsage() const;
 
-    bool IsDestroyed() const;
-    void SetHasAccess(bool hasAccess);
-    bool HasAccess() const;
+    // SharedResource implementation
+    void SetHasAccess(bool hasAccess) override;
+    bool HasAccess() const override;
+    bool IsDestroyed() const override;
+    bool IsInitialized() const override;
+    void SetInitialized(bool initialized) override;
+
+    bool IsReadOnly() const;
     uint32_t GetSubresourceIndex(uint32_t mipLevel, uint32_t arraySlice, Aspect aspect) const;
     bool IsSubresourceContentInitialized(const SubresourceRange& range) const;
     void SetIsSubresourceContentInitialized(bool isInitialized, const SubresourceRange& range);
@@ -122,7 +127,6 @@
     MaybeError ValidateCanUseInSubmitNow() const;
 
     bool IsMultisampledTexture() const;
-    bool IsReadOnly() const;
 
     // Returns true if the size covers the whole subresource.
     bool CoversFullSubresource(uint32_t mipLevel, Aspect aspect, const Extent3D& size) const;
@@ -149,8 +153,6 @@
 
     bool IsImplicitMSAARenderTextureViewSupported() const;
 
-    SharedTextureMemoryContents* GetSharedTextureMemoryContents() const;
-
     // Dawn API
     TextureViewBase* APICreateView(const TextureViewDescriptor* descriptor = nullptr);
     TextureViewBase* APICreateErrorView(const TextureViewDescriptor* descriptor = nullptr);
@@ -171,9 +173,6 @@
     void DestroyImpl() override;
     void AddInternalUsage(wgpu::TextureUsage usage);
 
-    // The shared texture memory state the texture was created from. May be null.
-    Ref<SharedTextureMemoryContents> mSharedTextureMemoryContents;
-
   private:
     struct TextureState {
         TextureState();
diff --git a/src/dawn/native/d3d/SharedTextureMemoryD3D.cpp b/src/dawn/native/d3d/SharedTextureMemoryD3D.cpp
index d83751f..16e49df 100644
--- a/src/dawn/native/d3d/SharedTextureMemoryD3D.cpp
+++ b/src/dawn/native/d3d/SharedTextureMemoryD3D.cpp
@@ -79,7 +79,7 @@
 
     return FenceAndSignalValue{
         std::move(sharedFence),
-        static_cast<uint64_t>(texture->GetSharedTextureMemoryContents()->GetLastUsageSerial())};
+        static_cast<uint64_t>(texture->GetSharedResourceMemoryContents()->GetLastUsageSerial())};
 }
 
 }  // namespace dawn::native::d3d
diff --git a/src/dawn/native/d3d11/BufferD3D11.cpp b/src/dawn/native/d3d11/BufferD3D11.cpp
index a571a37..f8b2395 100644
--- a/src/dawn/native/d3d11/BufferD3D11.cpp
+++ b/src/dawn/native/d3d11/BufferD3D11.cpp
@@ -381,7 +381,7 @@
     }
 
     if (IsFullBufferRange(offset, size)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return {};
     }
 
@@ -397,7 +397,7 @@
     }
 
     if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
     } else {
         DAWN_TRY(InitializeToZero(commandContext));
     }
@@ -409,7 +409,7 @@
     DAWN_ASSERT(NeedsInitialization());
 
     DAWN_TRY(ClearInternal(commandContext, uint8_t(0u)));
-    SetIsDataInitialized();
+    SetInitialized(true);
     GetDevice()->IncrementLazyClearCountForTesting();
 
     return {};
diff --git a/src/dawn/native/d3d11/TextureD3D11.cpp b/src/dawn/native/d3d11/TextureD3D11.cpp
index 0ead78c..62107d1 100644
--- a/src/dawn/native/d3d11/TextureD3D11.cpp
+++ b/src/dawn/native/d3d11/TextureD3D11.cpp
@@ -267,7 +267,7 @@
     Ref<Texture> texture = AcquireRef(new Texture(device, descriptor, Kind::Normal));
     DAWN_TRY(
         texture->InitializeAsExternalTexture(memory->GetD3DResource(), memory->GetKeyedMutex()));
-    texture->mSharedTextureMemoryContents = memory->GetContents();
+    texture->mSharedResourceMemoryContents = memory->GetContents();
     return texture;
 }
 
@@ -502,7 +502,7 @@
 
 MaybeError Texture::SynchronizeTextureBeforeUse(
     const ScopedCommandRecordingContext* commandContext) {
-    if (auto* contents = GetSharedTextureMemoryContents()) {
+    if (auto* contents = GetSharedResourceMemoryContents()) {
         SharedTextureMemoryBase::PendingFenceList fences;
         contents->AcquirePendingFences(&fences);
         contents->SetLastUsageSerial(GetDevice()->GetQueue()->GetPendingCommandSerial());
diff --git a/src/dawn/native/d3d12/BufferD3D12.cpp b/src/dawn/native/d3d12/BufferD3D12.cpp
index fc1ad9b..a8075ba 100644
--- a/src/dawn/native/d3d12/BufferD3D12.cpp
+++ b/src/dawn/native/d3d12/BufferD3D12.cpp
@@ -138,7 +138,7 @@
     Device* device = ToBackend(memory->GetDevice());
     Ref<Buffer> buffer = AcquireRef(new Buffer(device, descriptor));
     DAWN_TRY(buffer->InitializeAsExternalBuffer(memory->GetD3DResource(), descriptor));
-    buffer->mSharedBufferMemoryContents = memory->GetContents();
+    buffer->mSharedResourceMemoryContents = memory->GetContents();
     return buffer;
 }
 
@@ -299,7 +299,7 @@
     SetLabelImpl();
 
     // Assume the data is initialized since an external pointer was provided.
-    SetIsDataInitialized();
+    SetInitialized(true);
     return {};
 }
 
@@ -571,7 +571,7 @@
     }
 
     if (IsFullBufferRange(offset, size)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return {false};
     }
 
@@ -586,7 +586,7 @@
     }
 
     if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
     } else {
         DAWN_TRY(InitializeToZero(commandContext));
     }
@@ -605,7 +605,7 @@
     // TODO(crbug.com/dawn/484): skip initializing the buffer when it is created on a heap
     // that has already been zero initialized.
     DAWN_TRY(ClearBuffer(commandContext, uint8_t(0u)));
-    SetIsDataInitialized();
+    SetInitialized(true);
     GetDevice()->IncrementLazyClearCountForTesting();
 
     return {};
diff --git a/src/dawn/native/d3d12/DeviceD3D12.cpp b/src/dawn/native/d3d12/DeviceD3D12.cpp
index 977b13b..e91368f 100644
--- a/src/dawn/native/d3d12/DeviceD3D12.cpp
+++ b/src/dawn/native/d3d12/DeviceD3D12.cpp
@@ -300,7 +300,7 @@
     // the allocation of the staging buffer causes various end2end tests that monitor heap usage
     // to fail if it's done during device creation. Perhaps ClearUnorderedAccessView*() can be
     // used to avoid that.
-    if (!mZeroBuffer->IsDataInitialized()) {
+    if (!mZeroBuffer->IsInitialized()) {
         DynamicUploader* uploader = GetDynamicUploader();
         UploadHandle uploadHandle;
         DAWN_TRY_ASSIGN(uploadHandle,
@@ -313,7 +313,7 @@
                                       uploadHandle.startOffset, mZeroBuffer.Get(), 0,
                                       kZeroBufferSize);
 
-        mZeroBuffer->SetIsDataInitialized();
+        mZeroBuffer->SetInitialized(true);
     }
 
     Buffer* dstBuffer = ToBackend(destination);
diff --git a/src/dawn/native/d3d12/TextureD3D12.cpp b/src/dawn/native/d3d12/TextureD3D12.cpp
index ff0f67a..8267cd8 100644
--- a/src/dawn/native/d3d12/TextureD3D12.cpp
+++ b/src/dawn/native/d3d12/TextureD3D12.cpp
@@ -237,7 +237,7 @@
     Ref<Texture> texture = AcquireRef(new Texture(device, descriptor));
     DAWN_TRY(texture->InitializeAsExternalTexture(memory->GetD3DResource(), memory->GetKeyedMutex(),
                                                   {}, false));
-    texture->mSharedTextureMemoryContents = memory->GetContents();
+    texture->mSharedResourceMemoryContents = memory->GetContents();
     return texture;
 }
 
@@ -438,7 +438,7 @@
     // Perform the wait only on the first call.
     std::vector<FenceAndSignalValue> waitFences = std::move(mWaitFences);
 
-    if (SharedTextureMemoryContents* contents = GetSharedTextureMemoryContents()) {
+    if (SharedResourceMemoryContents* contents = GetSharedResourceMemoryContents()) {
         SharedTextureMemoryBase::PendingFenceList fences;
         contents->AcquirePendingFences(&fences);
         waitFences.insert(waitFences.end(), std::make_move_iterator(fences->begin()),
@@ -577,7 +577,7 @@
         }
     }
 
-    if (mSharedTextureMemoryContents) {
+    if (mSharedResourceMemoryContents) {
         // SharedTextureMemory supports concurrent reads of the underlying D3D12
         // texture via multiple TextureD3D12 instances created from a single
         // SharedTextureMemory instance. Concurrent read access requires that the
diff --git a/src/dawn/native/metal/BufferMTL.mm b/src/dawn/native/metal/BufferMTL.mm
index d9d0eb4..2403e90 100644
--- a/src/dawn/native/metal/BufferMTL.mm
+++ b/src/dawn/native/metal/BufferMTL.mm
@@ -176,7 +176,7 @@
     }
 
     // Data is assumed to be initialized since it is externally allocated.
-    SetIsDataInitialized();
+    SetInitialized(true);
     SetLabelImpl();
     return {};
 }
@@ -245,7 +245,7 @@
     }
 
     if (IsFullBufferRange(offset, size)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return false;
     }
 
@@ -260,7 +260,7 @@
     }
 
     if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return false;
     }
 
@@ -273,7 +273,7 @@
 
     ClearBuffer(commandContext, uint8_t(0u));
 
-    SetIsDataInitialized();
+    SetInitialized(true);
     GetDevice()->IncrementLazyClearCountForTesting();
 }
 
diff --git a/src/dawn/native/metal/SharedTextureMemoryMTL.mm b/src/dawn/native/metal/SharedTextureMemoryMTL.mm
index e9c291a..c0c08ba 100644
--- a/src/dawn/native/metal/SharedTextureMemoryMTL.mm
+++ b/src/dawn/native/metal/SharedTextureMemoryMTL.mm
@@ -209,7 +209,8 @@
 
         return FenceAndSignalValue{
             std::move(fence),
-            static_cast<uint64_t>(texture->GetSharedTextureMemoryContents()->GetLastUsageSerial())};
+            static_cast<uint64_t>(
+                texture->GetSharedResourceMemoryContents()->GetLastUsageSerial())};
     }
     DAWN_UNREACHABLE();
 }
diff --git a/src/dawn/native/metal/TextureMTL.mm b/src/dawn/native/metal/TextureMTL.mm
index 0b1cec6..1538de0 100644
--- a/src/dawn/native/metal/TextureMTL.mm
+++ b/src/dawn/native/metal/TextureMTL.mm
@@ -321,7 +321,7 @@
     Device* device = ToBackend(memory->GetDevice());
     Ref<Texture> texture = AcquireRef(new Texture(device, descriptor));
     DAWN_TRY(texture->InitializeFromSharedTextureMemory(memory, descriptor));
-    texture->mSharedTextureMemoryContents = memory->GetContents();
+    texture->mSharedResourceMemoryContents = memory->GetContents();
     return texture;
 }
 
@@ -414,7 +414,7 @@
 void Texture::SynchronizeTextureBeforeUse(CommandRecordingContext* commandContext) {
     if (@available(macOS 10.14, iOS 12.0, *)) {
         SharedTextureMemoryBase::PendingFenceList fences;
-        SharedTextureMemoryContents* contents = GetSharedTextureMemoryContents();
+        SharedResourceMemoryContents* contents = GetSharedResourceMemoryContents();
         if (contents != nullptr) {
             contents->AcquirePendingFences(&fences);
             contents->SetLastUsageSerial(GetDevice()->GetQueue()->GetPendingCommandSerial());
diff --git a/src/dawn/native/null/DeviceNull.cpp b/src/dawn/native/null/DeviceNull.cpp
index eeb8a16..db54784 100644
--- a/src/dawn/native/null/DeviceNull.cpp
+++ b/src/dawn/native/null/DeviceNull.cpp
@@ -270,7 +270,7 @@
                                                uint64_t destinationOffset,
                                                uint64_t size) {
     if (IsToggleEnabled(Toggle::LazyClearResourceOnFirstUse)) {
-        destination->SetIsDataInitialized();
+        destination->SetInitialized(true);
     }
 
     auto operation = std::make_unique<CopyFromStagingToBufferOperation>();
diff --git a/src/dawn/native/opengl/BufferGL.cpp b/src/dawn/native/opengl/BufferGL.cpp
index d19f011..6c8eacb 100644
--- a/src/dawn/native/opengl/BufferGL.cpp
+++ b/src/dawn/native/opengl/BufferGL.cpp
@@ -80,7 +80,7 @@
                bool shouldLazyClear)
     : Buffer(device, descriptor) {
     if (!shouldLazyClear) {
-        SetIsDataInitialized();
+        SetInitialized(true);
     }
 }
 
@@ -105,7 +105,7 @@
     }
 
     if (IsFullBufferRange(offset, size)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return false;
     }
 
@@ -119,7 +119,7 @@
     }
 
     if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return false;
     }
 
@@ -140,7 +140,7 @@
     device->IncrementLazyClearCountForTesting();
 
     TrackUsage();
-    SetIsDataInitialized();
+    SetInitialized(true);
 }
 
 bool Buffer::IsCPUWritableAtCreation() const {
diff --git a/src/dawn/native/vulkan/BufferVk.cpp b/src/dawn/native/vulkan/BufferVk.cpp
index d0ac815..65fdeb9 100644
--- a/src/dawn/native/vulkan/BufferVk.cpp
+++ b/src/dawn/native/vulkan/BufferVk.cpp
@@ -362,7 +362,7 @@
     SetLabelImpl();
 
     // Assume the data is initialized since an external pointer was provided.
-    SetIsDataInitialized();
+    SetInitialized(true);
     return {};
 }
 
@@ -599,7 +599,7 @@
     }
 
     if (IsFullBufferRange(offset, size)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return false;
     }
 
@@ -614,7 +614,7 @@
     }
 
     if (IsFullBufferOverwrittenInTextureToBufferCopy(copy)) {
-        SetIsDataInitialized();
+        SetInitialized(true);
         return false;
     }
 
@@ -668,7 +668,7 @@
 
     ClearBuffer(recordingContext, 0u);
     GetDevice()->IncrementLazyClearCountForTesting();
-    SetIsDataInitialized();
+    SetInitialized(true);
 }
 
 void Buffer::ClearBuffer(CommandRecordingContext* recordingContext,
diff --git a/src/dawn/native/vulkan/QueueVk.cpp b/src/dawn/native/vulkan/QueueVk.cpp
index 9e4b0cf..820b93d 100644
--- a/src/dawn/native/vulkan/QueueVk.cpp
+++ b/src/dawn/native/vulkan/QueueVk.cpp
@@ -364,7 +364,7 @@
         mRecordingContext.waitSemaphores.insert(mRecordingContext.waitSemaphores.end(),
                                                 waitRequirements.begin(), waitRequirements.end());
 
-        SharedTextureMemoryContents* contents = texture->GetSharedTextureMemoryContents();
+        SharedResourceMemoryContents* contents = texture->GetSharedResourceMemoryContents();
         if (contents != nullptr) {
             SharedTextureMemoryBase::PendingFenceList fences;
             contents->AcquirePendingFences(&fences);
diff --git a/src/dawn/native/vulkan/TextureVk.cpp b/src/dawn/native/vulkan/TextureVk.cpp
index 90ba5ec..3b331f2 100644
--- a/src/dawn/native/vulkan/TextureVk.cpp
+++ b/src/dawn/native/vulkan/TextureVk.cpp
@@ -783,7 +783,7 @@
     const UnpackedPtr<TextureDescriptor>& textureDescriptor) {
     Ref<Texture> texture =
         AcquireRef(new Texture(ToBackend(memory->GetDevice()), textureDescriptor));
-    texture->mSharedTextureMemoryContents = memory->GetContents();
+    texture->mSharedResourceMemoryContents = memory->GetContents();
     texture->mSharedTextureMemoryObjects = {memory->GetVkImage(), memory->GetVkDeviceMemory()};
     texture->mHandle = texture->mSharedTextureMemoryObjects.vkImage->Get();
     texture->mExternalAllocation = texture->mSharedTextureMemoryObjects.vkDeviceMemory->Get();
@@ -1081,7 +1081,7 @@
 
 void Texture::SetPendingAcquire(VkImageLayout pendingAcquireOldLayout,
                                 VkImageLayout pendingAcquireNewLayout) {
-    DAWN_ASSERT(GetSharedTextureMemoryContents() != nullptr);
+    DAWN_ASSERT(GetSharedResourceMemoryContents() != nullptr);
     mExternalState = ExternalState::PendingAcquire;
     mLastExternalState = ExternalState::PendingAcquire;
 
@@ -1190,7 +1190,7 @@
     // to skip the deallocation of the (absence of) VkDeviceMemory.
     device->GetResourceMemoryAllocator()->Deallocate(&mMemoryAllocation);
 
-    if (mExternalAllocation != VK_NULL_HANDLE && GetSharedTextureMemoryContents() == nullptr) {
+    if (mExternalAllocation != VK_NULL_HANDLE && GetSharedResourceMemoryContents() == nullptr) {
         device->GetFencedDeleter()->DeleteWhenUnused(mExternalAllocation);
     }