diff --git a/src/dawn_native/BindGroupLayout.cpp b/src/dawn_native/BindGroupLayout.cpp
index 5c2ea42..f047692 100644
--- a/src/dawn_native/BindGroupLayout.cpp
+++ b/src/dawn_native/BindGroupLayout.cpp
@@ -360,7 +360,8 @@
 
     BindGroupLayoutBase::BindGroupLayoutBase(DeviceBase* device,
                                              const BindGroupLayoutDescriptor* descriptor,
-                                             PipelineCompatibilityToken pipelineCompatibilityToken)
+                                             PipelineCompatibilityToken pipelineCompatibilityToken,
+                                             ApiObjectBase::UntrackedByDeviceTag tag)
         : ApiObjectBase(device, kLabelNotImplemented),
           mBindingInfo(BindingIndex(descriptor->entryCount)),
           mPipelineCompatibilityToken(pipelineCompatibilityToken) {
@@ -387,15 +388,31 @@
         ASSERT(mBindingInfo.size() <= kMaxBindingsPerPipelineLayoutTyped);
     }
 
+    BindGroupLayoutBase::BindGroupLayoutBase(DeviceBase* device,
+                                             const BindGroupLayoutDescriptor* descriptor,
+                                             PipelineCompatibilityToken pipelineCompatibilityToken)
+        : BindGroupLayoutBase(device, descriptor, pipelineCompatibilityToken, kUntrackedByDevice) {
+        TrackInDevice();
+    }
+
     BindGroupLayoutBase::BindGroupLayoutBase(DeviceBase* device, ObjectBase::ErrorTag tag)
         : ApiObjectBase(device, tag) {
     }
 
-    BindGroupLayoutBase::~BindGroupLayoutBase() {
-        // Do not uncache the actual cached object if we are a blueprint
-        if (IsCachedReference()) {
-            GetDevice()->UncacheBindGroupLayout(this);
+    BindGroupLayoutBase::BindGroupLayoutBase(DeviceBase* device)
+        : ApiObjectBase(device, kLabelNotImplemented) {
+        TrackInDevice();
+    }
+
+    bool BindGroupLayoutBase::DestroyApiObject() {
+        bool wasDestroyed = ApiObjectBase::DestroyApiObject();
+        if (wasDestroyed) {
+            // Do not uncache the actual cached object if we are a blueprint
+            if (IsCachedReference()) {
+                GetDevice()->UncacheBindGroupLayout(this);
+            }
         }
+        return wasDestroyed;
     }
 
     // static
diff --git a/src/dawn_native/BindGroupLayout.h b/src/dawn_native/BindGroupLayout.h
index 5f75eb6..61b811f 100644
--- a/src/dawn_native/BindGroupLayout.h
+++ b/src/dawn_native/BindGroupLayout.h
@@ -44,11 +44,15 @@
       public:
         BindGroupLayoutBase(DeviceBase* device,
                             const BindGroupLayoutDescriptor* descriptor,
+                            PipelineCompatibilityToken pipelineCompatibilityToken,
+                            ApiObjectBase::UntrackedByDeviceTag tag);
+        BindGroupLayoutBase(DeviceBase* device,
+                            const BindGroupLayoutDescriptor* descriptor,
                             PipelineCompatibilityToken pipelineCompatibilityToken);
-        ~BindGroupLayoutBase() override;
 
         static BindGroupLayoutBase* MakeError(DeviceBase* device);
 
+        bool DestroyApiObject() override;
         ObjectType GetType() const override;
 
         // A map from the BindingNumber to its packed BindingIndex.
@@ -85,7 +89,6 @@
         // ignoring their compatibility groups.
         bool IsLayoutEqual(const BindGroupLayoutBase* other,
                            bool excludePipelineCompatibiltyToken = false) const;
-
         PipelineCompatibilityToken GetPipelineCompatibilityToken() const;
 
         struct BufferBindingData {
@@ -110,6 +113,9 @@
         BindingDataPointers ComputeBindingDataPointers(void* dataStart) const;
 
       protected:
+        // Constructor used only for mocking and testing.
+        BindGroupLayoutBase(DeviceBase* device);
+
         template <typename BindGroup>
         SlabAllocator<BindGroup> MakeFrontendBindGroupAllocator(size_t size) {
             return SlabAllocator<BindGroup>(
diff --git a/src/dawn_native/Device.cpp b/src/dawn_native/Device.cpp
index bc6f6a8..a867110 100644
--- a/src/dawn_native/Device.cpp
+++ b/src/dawn_native/Device.cpp
@@ -200,6 +200,10 @@
         }
     }
 
+    DeviceBase::DeviceBase() : mState(State::Alive) {
+        mCaches = std::make_unique<DeviceBase::Caches>();
+    }
+
     DeviceBase::~DeviceBase() = default;
 
     MaybeError DeviceBase::Initialize(QueueBase* defaultQueue) {
@@ -270,7 +274,9 @@
         // that this only considers the immediate frontend dependencies, while backend objects could
         // add complications and extra dependencies.
         // TODO(dawn/628) Add types into the array as they are implemented.
-        static constexpr std::array<ObjectType, 0> kObjectTypeDependencyOrder = {};
+        static constexpr std::array<ObjectType, 1> kObjectTypeDependencyOrder = {
+            ObjectType::BindGroupLayout,
+        };
 
         // We first move all objects out from the tracking list into a separate list so that we can
         // avoid locking the same mutex twice. We can then iterate across the separate list to call
@@ -631,7 +637,8 @@
     ResultOrError<Ref<BindGroupLayoutBase>> DeviceBase::GetOrCreateBindGroupLayout(
         const BindGroupLayoutDescriptor* descriptor,
         PipelineCompatibilityToken pipelineCompatibilityToken) {
-        BindGroupLayoutBase blueprint(this, descriptor, pipelineCompatibilityToken);
+        BindGroupLayoutBase blueprint(this, descriptor, pipelineCompatibilityToken,
+                                      ApiObjectBase::kUntrackedByDevice);
 
         const size_t blueprintHash = blueprint.ComputeContentHash();
         blueprint.SetContentHash(blueprintHash);
diff --git a/src/dawn_native/Device.h b/src/dawn_native/Device.h
index 5d51096..c2969c3 100644
--- a/src/dawn_native/Device.h
+++ b/src/dawn_native/Device.h
@@ -23,6 +23,7 @@
 #include "dawn_native/Limits.h"
 #include "dawn_native/ObjectBase.h"
 #include "dawn_native/ObjectType_autogen.h"
+#include "dawn_native/RenderPipeline.h"
 #include "dawn_native/StagingBuffer.h"
 #include "dawn_native/Toggles.h"
 
@@ -354,6 +355,9 @@
         void APISetLabel(const char* label);
 
       protected:
+        // Constructor used only for mocking and testing.
+        DeviceBase();
+
         void SetToggle(Toggle toggle, bool isEnabled);
         void ForceSetToggle(Toggle toggle, bool isEnabled);
 
diff --git a/src/dawn_native/Error.h b/src/dawn_native/Error.h
index f5ed5a9..7e6726e 100644
--- a/src/dawn_native/Error.h
+++ b/src/dawn_native/Error.h
@@ -135,13 +135,52 @@
 
     // DAWN_TRY_ASSIGN is the same as DAWN_TRY for ResultOrError and assigns the success value, if
     // any, to VAR.
-#define DAWN_TRY_ASSIGN(VAR, EXPR)                                            \
+#define DAWN_TRY_ASSIGN(VAR, EXPR) DAWN_TRY_ASSIGN_WITH_CLEANUP(VAR, EXPR, {})
+
+    // Argument helpers are used to determine which macro implementations should be called when
+    // overloading with different number of variables.
+#define DAWN_ERROR_UNIMPLEMENTED_MACRO_(...) UNREACHABLE()
+#define DAWN_ERROR_GET_5TH_ARG_HELPER_(_1, _2, _3, _4, NAME, ...) NAME
+#define DAWN_ERROR_GET_5TH_ARG_(args) DAWN_ERROR_GET_5TH_ARG_HELPER_ args
+
+    // DAWN_TRY_ASSIGN_WITH_CLEANUP is overloaded with 2 version so that users can override the
+    // return value of the macro when necessary. This is particularly useful if the function
+    // calling the macro may want to return void instead of the error, i.e. in a test where we may
+    // just want to assert and fail if the assign cannot go through. In both the cleanup and return
+    // clauses, users can use the `error` variable to access the pointer to the acquired error.
+    //
+    // Example usages:
+    //     3 Argument Case:
+    //          Result res;
+    //          DAWN_TRY_ASSIGN_WITH_CLEANUP(
+    //              res, GetResultOrErrorFunction(), { AddAdditionalErrorInformation(error.get()); }
+    //          );
+    //
+    //     4 Argument Case:
+    //          bool FunctionThatReturnsBool() {
+    //              DAWN_TRY_ASSIGN_WITH_CLEANUP(
+    //                  res, GetResultOrErrorFunction(),
+    //                  { AddAdditionalErrorInformation(error.get()); },
+    //                  false
+    //              );
+    //          }
+#define DAWN_TRY_ASSIGN_WITH_CLEANUP(...)                                       \
+    DAWN_ERROR_GET_5TH_ARG_((__VA_ARGS__, DAWN_TRY_ASSIGN_WITH_CLEANUP_IMPL_4_, \
+                             DAWN_TRY_ASSIGN_WITH_CLEANUP_IMPL_3_,              \
+                             DAWN_ERROR_UNIMPLEMENTED_MACRO_))                  \
+    (__VA_ARGS__)
+
+#define DAWN_TRY_ASSIGN_WITH_CLEANUP_IMPL_3_(VAR, EXPR, BODY) \
+    DAWN_TRY_ASSIGN_WITH_CLEANUP_IMPL_4_(VAR, EXPR, BODY, std::move(error))
+
+#define DAWN_TRY_ASSIGN_WITH_CLEANUP_IMPL_4_(VAR, EXPR, BODY, RET)            \
     {                                                                         \
         auto DAWN_LOCAL_VAR = EXPR;                                           \
         if (DAWN_UNLIKELY(DAWN_LOCAL_VAR.IsError())) {                        \
             std::unique_ptr<ErrorData> error = DAWN_LOCAL_VAR.AcquireError(); \
+            {BODY} /* comment to force the formatter to insert a newline */   \
             error->AppendBacktrace(__FILE__, __func__, __LINE__);             \
-            return {std::move(error)};                                        \
+            return (RET);                                                     \
         }                                                                     \
         VAR = DAWN_LOCAL_VAR.AcquireSuccess();                                \
     }                                                                         \
diff --git a/src/dawn_native/ObjectBase.h b/src/dawn_native/ObjectBase.h
index 8b14b77..6dd1824 100644
--- a/src/dawn_native/ObjectBase.h
+++ b/src/dawn_native/ObjectBase.h
@@ -45,6 +45,8 @@
       public:
         struct LabelNotImplementedTag {};
         static constexpr LabelNotImplementedTag kLabelNotImplemented = {};
+        struct UntrackedByDeviceTag {};
+        static constexpr UntrackedByDeviceTag kUntrackedByDevice = {};
 
         ApiObjectBase(DeviceBase* device, LabelNotImplementedTag tag);
         ApiObjectBase(DeviceBase* device, const char* label);
diff --git a/src/dawn_native/d3d12/BindGroupLayoutD3D12.cpp b/src/dawn_native/d3d12/BindGroupLayoutD3D12.cpp
index 761b8f7..02fb9f1 100644
--- a/src/dawn_native/d3d12/BindGroupLayoutD3D12.cpp
+++ b/src/dawn_native/d3d12/BindGroupLayoutD3D12.cpp
@@ -131,6 +131,10 @@
             device->GetSamplerStagingDescriptorAllocator(GetSamplerDescriptorCount());
     }
 
+    BindGroupLayout::~BindGroupLayout() {
+        DestroyApiObject();
+    }
+
     ResultOrError<Ref<BindGroup>> BindGroupLayout::AllocateBindGroup(
         Device* device,
         const BindGroupDescriptor* descriptor) {
diff --git a/src/dawn_native/d3d12/BindGroupLayoutD3D12.h b/src/dawn_native/d3d12/BindGroupLayoutD3D12.h
index abf6702..e55c3df 100644
--- a/src/dawn_native/d3d12/BindGroupLayoutD3D12.h
+++ b/src/dawn_native/d3d12/BindGroupLayoutD3D12.h
@@ -64,7 +64,7 @@
         BindGroupLayout(Device* device,
                         const BindGroupLayoutDescriptor* descriptor,
                         PipelineCompatibilityToken pipelineCompatibilityToken);
-        ~BindGroupLayout() override = default;
+        ~BindGroupLayout() override;
 
         // Contains the offset into the descriptor heap for the given resource view. Samplers and
         // non-samplers are stored in separate descriptor heaps, so the offsets should be unique
diff --git a/src/dawn_native/metal/BindGroupLayoutMTL.h b/src/dawn_native/metal/BindGroupLayoutMTL.h
index 1d2c2a9..bbbc959 100644
--- a/src/dawn_native/metal/BindGroupLayoutMTL.h
+++ b/src/dawn_native/metal/BindGroupLayoutMTL.h
@@ -36,7 +36,7 @@
         BindGroupLayout(DeviceBase* device,
                         const BindGroupLayoutDescriptor* descriptor,
                         PipelineCompatibilityToken pipelineCompatibilityToken);
-        ~BindGroupLayout() override = default;
+        ~BindGroupLayout() override;
 
         SlabAllocator<BindGroup> mBindGroupAllocator;
     };
diff --git a/src/dawn_native/metal/BindGroupLayoutMTL.mm b/src/dawn_native/metal/BindGroupLayoutMTL.mm
index 5d748c1..a1c8255 100644
--- a/src/dawn_native/metal/BindGroupLayoutMTL.mm
+++ b/src/dawn_native/metal/BindGroupLayoutMTL.mm
@@ -33,6 +33,10 @@
           mBindGroupAllocator(MakeFrontendBindGroupAllocator<BindGroup>(4096)) {
     }
 
+    BindGroupLayout::~BindGroupLayout() {
+        DestroyApiObject();
+    }
+
     Ref<BindGroup> BindGroupLayout::AllocateBindGroup(Device* device,
                                                       const BindGroupDescriptor* descriptor) {
         return AcquireRef(mBindGroupAllocator.Allocate(device, descriptor));
diff --git a/src/dawn_native/null/DeviceNull.cpp b/src/dawn_native/null/DeviceNull.cpp
index 4f08b1b..17030dd 100644
--- a/src/dawn_native/null/DeviceNull.cpp
+++ b/src/dawn_native/null/DeviceNull.cpp
@@ -263,6 +263,18 @@
           BindGroupBase(device, descriptor, mBindingDataAllocation) {
     }
 
+    // BindGroupLayout
+
+    BindGroupLayout::BindGroupLayout(DeviceBase* device,
+                                     const BindGroupLayoutDescriptor* descriptor,
+                                     PipelineCompatibilityToken pipelineCompatibilityToken)
+        : BindGroupLayoutBase(device, descriptor, pipelineCompatibilityToken) {
+    }
+
+    BindGroupLayout::~BindGroupLayout() {
+        DestroyApiObject();
+    }
+
     // Buffer
 
     Buffer::Buffer(Device* device, const BufferDescriptor* descriptor)
diff --git a/src/dawn_native/null/DeviceNull.h b/src/dawn_native/null/DeviceNull.h
index be1c613..0f29139 100644
--- a/src/dawn_native/null/DeviceNull.h
+++ b/src/dawn_native/null/DeviceNull.h
@@ -40,7 +40,7 @@
 
     class Adapter;
     class BindGroup;
-    using BindGroupLayout = BindGroupLayoutBase;
+    class BindGroupLayout;
     class Buffer;
     class CommandBuffer;
     using ComputePipeline = ComputePipelineBase;
@@ -200,6 +200,16 @@
         ~BindGroup() override = default;
     };
 
+    class BindGroupLayout final : public BindGroupLayoutBase {
+      public:
+        BindGroupLayout(DeviceBase* device,
+                        const BindGroupLayoutDescriptor* descriptor,
+                        PipelineCompatibilityToken pipelineCompatibilityToken);
+
+      private:
+        ~BindGroupLayout() override;
+    };
+
     class Buffer final : public BufferBase {
       public:
         Buffer(Device* device, const BufferDescriptor* descriptor);
diff --git a/src/dawn_native/opengl/BindGroupLayoutGL.cpp b/src/dawn_native/opengl/BindGroupLayoutGL.cpp
index d008b1d..99cd5c23 100644
--- a/src/dawn_native/opengl/BindGroupLayoutGL.cpp
+++ b/src/dawn_native/opengl/BindGroupLayoutGL.cpp
@@ -25,6 +25,10 @@
           mBindGroupAllocator(MakeFrontendBindGroupAllocator<BindGroup>(4096)) {
     }
 
+    BindGroupLayout::~BindGroupLayout() {
+        DestroyApiObject();
+    }
+
     Ref<BindGroup> BindGroupLayout::AllocateBindGroup(Device* device,
                                                       const BindGroupDescriptor* descriptor) {
         return AcquireRef(mBindGroupAllocator.Allocate(device, descriptor));
diff --git a/src/dawn_native/opengl/BindGroupLayoutGL.h b/src/dawn_native/opengl/BindGroupLayoutGL.h
index 136bd0a..5061b02 100644
--- a/src/dawn_native/opengl/BindGroupLayoutGL.h
+++ b/src/dawn_native/opengl/BindGroupLayoutGL.h
@@ -33,7 +33,7 @@
         void DeallocateBindGroup(BindGroup* bindGroup);
 
       private:
-        ~BindGroupLayout() override = default;
+        ~BindGroupLayout() override;
         SlabAllocator<BindGroup> mBindGroupAllocator;
     };
 
diff --git a/src/dawn_native/vulkan/BindGroupLayoutVk.cpp b/src/dawn_native/vulkan/BindGroupLayoutVk.cpp
index b464758..eb52822 100644
--- a/src/dawn_native/vulkan/BindGroupLayoutVk.cpp
+++ b/src/dawn_native/vulkan/BindGroupLayoutVk.cpp
@@ -161,6 +161,7 @@
             device->fn.DestroyDescriptorSetLayout(device->GetVkDevice(), mHandle, nullptr);
             mHandle = VK_NULL_HANDLE;
         }
+        DestroyApiObject();
     }
 
     VkDescriptorSetLayout BindGroupLayout::GetHandle() const {
diff --git a/src/tests/BUILD.gn b/src/tests/BUILD.gn
index 84a74f5..6105fb1 100644
--- a/src/tests/BUILD.gn
+++ b/src/tests/BUILD.gn
@@ -126,10 +126,29 @@
   ]
 }
 
+# Source code for mocks used for unit testing are separated from the rest of
+# sources so that they aren't included in non-test builds.
+source_set("dawn_native_mocks_sources") {
+  testonly = true
+
+  deps = [
+    ":gmock_and_gtest",
+    "${dawn_root}/src/dawn_native:dawn_native_sources",
+    "${dawn_root}/src/dawn_native:dawn_native_static",
+    "${dawn_root}/src/utils:dawn_utils",
+  ]
+
+  sources = [
+    "unittests/native/mocks/BindGroupLayoutMock.h",
+    "unittests/native/mocks/DeviceMock.h",
+  ]
+}
+
 test("dawn_unittests") {
   configs += [ "${dawn_root}/src/common:dawn_internal" ]
 
   deps = [
+    ":dawn_native_mocks_sources",
     ":gmock_and_gtest",
     ":mock_webgpu_gen",
     "${dawn_root}/src/common",
@@ -150,6 +169,8 @@
     "${dawn_root}/src/dawn_wire/client/ClientMemoryTransferService_mock.h",
     "${dawn_root}/src/dawn_wire/server/ServerMemoryTransferService_mock.cpp",
     "${dawn_root}/src/dawn_wire/server/ServerMemoryTransferService_mock.h",
+    "DawnNativeTest.cpp",
+    "DawnNativeTest.h",
     "MockCallback.h",
     "ToggleParser.cpp",
     "ToggleParser.h",
@@ -188,6 +209,7 @@
     "unittests/SystemUtilsTests.cpp",
     "unittests/ToBackendTests.cpp",
     "unittests/TypedIntegerTests.cpp",
+    "unittests/native/DestroyObjectTests.cpp",
     "unittests/validation/BindGroupValidationTests.cpp",
     "unittests/validation/BufferValidationTests.cpp",
     "unittests/validation/CommandBufferValidationTests.cpp",
diff --git a/src/tests/DawnNativeTest.cpp b/src/tests/DawnNativeTest.cpp
new file mode 100644
index 0000000..d39c8e0
--- /dev/null
+++ b/src/tests/DawnNativeTest.cpp
@@ -0,0 +1,30 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <gtest/gtest.h>
+
+#include "absl/strings/str_cat.h"
+#include "dawn_native/ErrorData.h"
+
+namespace dawn_native {
+
+    void AddFatalDawnFailure(const char* expression, const ErrorData* error) {
+        const auto& backtrace = error->GetBacktrace();
+        GTEST_MESSAGE_AT_(
+            backtrace.at(0).file, backtrace.at(0).line,
+            absl::StrCat(expression, " returned error: ", error->GetMessage()).c_str(),
+            ::testing::TestPartResult::kFatalFailure);
+    }
+
+}  // namespace dawn_native
diff --git a/src/tests/DawnNativeTest.h b/src/tests/DawnNativeTest.h
new file mode 100644
index 0000000..94fdafb
--- /dev/null
+++ b/src/tests/DawnNativeTest.h
@@ -0,0 +1,32 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef TESTS_DAWNNATIVETEST_H_
+#define TESTS_DAWNNATIVETEST_H_
+
+#include <gtest/gtest.h>
+
+#include "dawn_native/ErrorData.h"
+
+namespace dawn_native {
+
+    // This is similar to DAWN_TRY_ASSIGN but produces a fatal GTest error if EXPR is an error.
+#define DAWN_ASSERT_AND_ASSIGN(VAR, EXPR) \
+    DAWN_TRY_ASSIGN_WITH_CLEANUP(VAR, EXPR, {}, AddFatalDawnFailure(#EXPR, error.get()))
+
+    void AddFatalDawnFailure(const char* expression, const ErrorData* error);
+
+}  // namespace dawn_native
+
+#endif  // TESTS_DAWNNATIVETEST_H_
diff --git a/src/tests/unittests/ErrorTests.cpp b/src/tests/unittests/ErrorTests.cpp
index 042784d..ff7b7fe 100644
--- a/src/tests/unittests/ErrorTests.cpp
+++ b/src/tests/unittests/ErrorTests.cpp
@@ -243,6 +243,78 @@
         ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
     }
 
+    // Check DAWN_TRY_ASSIGN handles successes correctly.
+    TEST(ErrorTests, TRY_RESULT_CLEANUP_Success) {
+        auto ReturnSuccess = []() -> ResultOrError<int*> { return &dummySuccess; };
+
+        // We need to check that DAWN_TRY_ASSIGN_WITH_CLEANUP doesn't return on successes and the
+        // cleanup is not called.
+        bool tryReturned = true;
+        bool tryCleanup = false;
+
+        auto Try = [ReturnSuccess, &tryReturned, &tryCleanup]() -> ResultOrError<int*> {
+            int* result = nullptr;
+            DAWN_TRY_ASSIGN_WITH_CLEANUP(result, ReturnSuccess(), { tryCleanup = true; });
+            tryReturned = false;
+
+            EXPECT_EQ(result, &dummySuccess);
+            return result;
+        };
+
+        ResultOrError<int*> result = Try();
+        ASSERT_TRUE(result.IsSuccess());
+        ASSERT_FALSE(tryReturned);
+        ASSERT_FALSE(tryCleanup);
+        ASSERT_EQ(result.AcquireSuccess(), &dummySuccess);
+    }
+
+    // Check DAWN_TRY_ASSIGN handles cleanups.
+    TEST(ErrorTests, TRY_RESULT_CLEANUP_Cleanup) {
+        auto ReturnError = []() -> ResultOrError<int*> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
+
+        // We need to check that DAWN_TRY_ASSIGN_WITH_CLEANUP calls cleanup when error.
+        bool tryCleanup = false;
+
+        auto Try = [ReturnError, &tryCleanup]() -> ResultOrError<int*> {
+            int* result = nullptr;
+            DAWN_TRY_ASSIGN_WITH_CLEANUP(result, ReturnError(), { tryCleanup = true; });
+            DAWN_UNUSED(result);
+
+            // DAWN_TRY_ASSIGN_WITH_CLEANUP should return before this point
+            EXPECT_FALSE(true);
+            return &dummySuccess;
+        };
+
+        ResultOrError<int*> result = Try();
+        ASSERT_TRUE(result.IsError());
+
+        std::unique_ptr<ErrorData> errorData = result.AcquireError();
+        ASSERT_EQ(errorData->GetMessage(), dummyErrorMessage);
+        ASSERT_TRUE(tryCleanup);
+    }
+
+    // Check DAWN_TRY_ASSIGN can override return value when needed.
+    TEST(ErrorTests, TRY_RESULT_CLEANUP_OverrideReturn) {
+        auto ReturnError = []() -> ResultOrError<int*> {
+            return DAWN_VALIDATION_ERROR(dummyErrorMessage);
+        };
+
+        auto Try = [ReturnError]() -> bool {
+            int* result = nullptr;
+            DAWN_TRY_ASSIGN_WITH_CLEANUP(result, ReturnError(), {}, true);
+            DAWN_UNUSED(result);
+
+            // DAWN_TRY_ASSIGN_WITH_CLEANUP should return before this point
+            EXPECT_FALSE(true);
+            return false;
+        };
+
+        bool result = Try();
+        ASSERT_TRUE(result);
+    }
+
     // Check a MaybeError can be DAWN_TRIED in a function that returns an ResultOrError
     // Check DAWN_TRY handles errors correctly.
     TEST(ErrorTests, TRY_ConversionToErrorOrResult) {
diff --git a/src/tests/unittests/native/DestroyObjectTests.cpp b/src/tests/unittests/native/DestroyObjectTests.cpp
new file mode 100644
index 0000000..d197403
--- /dev/null
+++ b/src/tests/unittests/native/DestroyObjectTests.cpp
@@ -0,0 +1,73 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <gtest/gtest.h>
+
+#include "dawn_native/Toggles.h"
+#include "mocks/BindGroupLayoutMock.h"
+#include "mocks/DeviceMock.h"
+#include "tests/DawnNativeTest.h"
+
+namespace dawn_native { namespace {
+
+    using ::testing::ByMove;
+    using ::testing::InSequence;
+    using ::testing::Return;
+
+    TEST(DestroyObjectTests, BindGroupLayout) {
+        // Skipping validation on descriptors as coverage for validation is already present.
+        DeviceMock device;
+        device.SetToggle(Toggle::SkipValidation, true);
+
+        BindGroupLayoutMock* bindGroupLayoutMock = new BindGroupLayoutMock(&device);
+        EXPECT_CALL(*bindGroupLayoutMock, DestroyApiObjectImpl).Times(1);
+
+        BindGroupLayoutDescriptor desc = {};
+        Ref<BindGroupLayoutBase> bindGroupLayout;
+        EXPECT_CALL(device, CreateBindGroupLayoutImpl)
+            .WillOnce(Return(ByMove(AcquireRef(bindGroupLayoutMock))));
+        DAWN_ASSERT_AND_ASSIGN(bindGroupLayout, device.CreateBindGroupLayout(&desc));
+
+        EXPECT_TRUE(bindGroupLayout->IsAlive());
+        EXPECT_TRUE(bindGroupLayout->IsCachedReference());
+
+        bindGroupLayout->DestroyApiObject();
+        EXPECT_FALSE(bindGroupLayout->IsAlive());
+    }
+
+    // Destroying the objects on the device should result in all created objects being destroyed in
+    // order.
+    TEST(DestroyObjectTests, DestroyObjects) {
+        DeviceMock device;
+        device.SetToggle(Toggle::SkipValidation, true);
+
+        BindGroupLayoutMock* bindGroupLayoutMock = new BindGroupLayoutMock(&device);
+        {
+            InSequence seq;
+            EXPECT_CALL(*bindGroupLayoutMock, DestroyApiObjectImpl).Times(1);
+        }
+
+        BindGroupLayoutDescriptor desc = {};
+        Ref<BindGroupLayoutBase> bindGroupLayout;
+        EXPECT_CALL(device, CreateBindGroupLayoutImpl)
+            .WillOnce(Return(ByMove(AcquireRef(bindGroupLayoutMock))));
+        DAWN_ASSERT_AND_ASSIGN(bindGroupLayout, device.CreateBindGroupLayout(&desc));
+        EXPECT_TRUE(bindGroupLayout->IsAlive());
+        EXPECT_TRUE(bindGroupLayout->IsCachedReference());
+
+        device.DestroyObjects();
+        EXPECT_FALSE(bindGroupLayout->IsAlive());
+    }
+
+}}  // namespace dawn_native::
diff --git a/src/tests/unittests/native/mocks/BindGroupLayoutMock.h b/src/tests/unittests/native/mocks/BindGroupLayoutMock.h
new file mode 100644
index 0000000..6f8dba5
--- /dev/null
+++ b/src/tests/unittests/native/mocks/BindGroupLayoutMock.h
@@ -0,0 +1,38 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef TESTS_UNITTESTS_NATIVE_MOCKS_BINDGROUPLAYOUT_MOCK_H_
+#define TESTS_UNITTESTS_NATIVE_MOCKS_BINDGROUPLAYOUT_MOCK_H_
+
+#include "dawn_native/BindGroupLayout.h"
+#include "dawn_native/Device.h"
+
+#include <gmock/gmock.h>
+
+namespace dawn_native {
+
+    class BindGroupLayoutMock final : public BindGroupLayoutBase {
+      public:
+        BindGroupLayoutMock(DeviceBase* device) : BindGroupLayoutBase(device) {
+        }
+        ~BindGroupLayoutMock() override {
+            DestroyApiObject();
+        }
+
+        MOCK_METHOD(void, DestroyApiObjectImpl, (), (override));
+    };
+
+}  // namespace dawn_native
+
+#endif  // TESTS_UNITTESTS_NATIVE_MOCKS_BINDGROUPLAYOUT_MOCK_H_
diff --git a/src/tests/unittests/native/mocks/DeviceMock.h b/src/tests/unittests/native/mocks/DeviceMock.h
new file mode 100644
index 0000000..e83e37a
--- /dev/null
+++ b/src/tests/unittests/native/mocks/DeviceMock.h
@@ -0,0 +1,116 @@
+// Copyright 2021 The Dawn Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef TESTS_UNITTESTS_NATIVE_MOCKS_DEVICE_MOCK_H_
+#define TESTS_UNITTESTS_NATIVE_MOCKS_DEVICE_MOCK_H_
+
+#include "dawn_native/Device.h"
+
+#include <gmock/gmock.h>
+
+namespace dawn_native {
+
+    class DeviceMock : public DeviceBase {
+      public:
+        // Exposes some protected functions for testing purposes.
+        using DeviceBase::DestroyObjects;
+        using DeviceBase::SetToggle;
+
+        MOCK_METHOD(ResultOrError<Ref<CommandBufferBase>>,
+                    CreateCommandBuffer,
+                    (CommandEncoder*, const CommandBufferDescriptor*),
+                    (override));
+
+        MOCK_METHOD(ResultOrError<std::unique_ptr<StagingBufferBase>>,
+                    CreateStagingBuffer,
+                    (size_t),
+                    (override));
+        MOCK_METHOD(MaybeError,
+                    CopyFromStagingToBuffer,
+                    (StagingBufferBase*, uint64_t, BufferBase*, uint64_t, uint64_t),
+                    (override));
+        MOCK_METHOD(
+            MaybeError,
+            CopyFromStagingToTexture,
+            (const StagingBufferBase*, const TextureDataLayout&, TextureCopy*, const Extent3D&),
+            (override));
+
+        MOCK_METHOD(uint32_t, GetOptimalBytesPerRowAlignment, (), (const, override));
+        MOCK_METHOD(uint64_t, GetOptimalBufferToTextureCopyOffsetAlignment, (), (const, override));
+
+        MOCK_METHOD(float, GetTimestampPeriodInNS, (), (const, override));
+
+        MOCK_METHOD(ResultOrError<Ref<BindGroupBase>>,
+                    CreateBindGroupImpl,
+                    (const BindGroupDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<BindGroupLayoutBase>>,
+                    CreateBindGroupLayoutImpl,
+                    (const BindGroupLayoutDescriptor*, PipelineCompatibilityToken),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<BufferBase>>,
+                    CreateBufferImpl,
+                    (const BufferDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<ComputePipelineBase>>,
+                    CreateComputePipelineImpl,
+                    (const ComputePipelineDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<PipelineLayoutBase>>,
+                    CreatePipelineLayoutImpl,
+                    (const PipelineLayoutDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<QuerySetBase>>,
+                    CreateQuerySetImpl,
+                    (const QuerySetDescriptor*),
+                    (override));
+        MOCK_METHOD(Ref<RenderPipelineBase>,
+                    CreateUninitializedRenderPipelineImpl,
+                    (const RenderPipelineDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<SamplerBase>>,
+                    CreateSamplerImpl,
+                    (const SamplerDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<ShaderModuleBase>>,
+                    CreateShaderModuleImpl,
+                    (const ShaderModuleDescriptor*, ShaderModuleParseResult*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<SwapChainBase>>,
+                    CreateSwapChainImpl,
+                    (const SwapChainDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<NewSwapChainBase>>,
+                    CreateSwapChainImpl,
+                    (Surface*, NewSwapChainBase*, const SwapChainDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<TextureBase>>,
+                    CreateTextureImpl,
+                    (const TextureDescriptor*),
+                    (override));
+        MOCK_METHOD(ResultOrError<Ref<TextureViewBase>>,
+                    CreateTextureViewImpl,
+                    (TextureBase*, const TextureViewDescriptor*),
+                    (override));
+
+        MOCK_METHOD(MaybeError, TickImpl, (), (override));
+
+        MOCK_METHOD(ResultOrError<ExecutionSerial>, CheckAndUpdateCompletedSerials, (), (override));
+        MOCK_METHOD(void, DestroyImpl, (), (override));
+        MOCK_METHOD(MaybeError, WaitForIdleForDestruction, (), (override));
+    };
+
+}  // namespace dawn_native
+
+#endif  // TESTS_UNITTESTS_NATIVE_MOCKS_DEVICE_MOCK_H_