diff --git a/src/dawn_native/Instance.cpp b/src/dawn_native/Instance.cpp
index b0886ba..9458dbf 100644
--- a/src/dawn_native/Instance.cpp
+++ b/src/dawn_native/Instance.cpp
@@ -73,7 +73,15 @@
                "Clears texture to full 1 bits as soon as they are created, but doesn't update "
                "the tracking state of the texture. This way we can test the logic of clearing "
                "textures that use recycled memory.",
-               "https://bugs.chromium.org/p/dawn/issues/detail?id=145"}}}};
+               "https://bugs.chromium.org/p/dawn/issues/detail?id=145"}},
+             {Toggle::AlwaysResolveIntoZeroLevelAndLayer,
+              {"always_resolve_into_zero_level_and_layer",
+               "When the resolve target is a texture view that is created on the non-zero level or "
+               "layer of a texture, we first resolve into a temporarily 2D texture with only one "
+               "mipmap level and one array layer, and copy the result of MSAA resolve into the "
+               "true resolve target. This workaround is enabled by default on the Metal drivers "
+               "that have bugs when setting non-zero resolveLevel or resolveSlice.",
+               "https://bugs.chromium.org/p/dawn/issues/detail?id=56"}}}};
 
     }  // anonymous namespace
 
diff --git a/src/dawn_native/Toggles.h b/src/dawn_native/Toggles.h
index c60f5f9..4ff15c1 100644
--- a/src/dawn_native/Toggles.h
+++ b/src/dawn_native/Toggles.h
@@ -24,6 +24,7 @@
     enum class Toggle {
         EmulateStoreAndMSAAResolve,
         NonzeroClearResourcesOnCreationForTesting,
+        AlwaysResolveIntoZeroLevelAndLayer,
 
         EnumCount,
         InvalidEnum = EnumCount,
diff --git a/src/dawn_native/metal/CommandBufferMTL.h b/src/dawn_native/metal/CommandBufferMTL.h
index 4b08a9f..a127c51 100644
--- a/src/dawn_native/metal/CommandBufferMTL.h
+++ b/src/dawn_native/metal/CommandBufferMTL.h
@@ -21,7 +21,6 @@
 #import <Metal/Metal.h>
 
 namespace dawn_native {
-    struct BeginRenderPassCmd;
     class CommandEncoderBase;
 }
 
diff --git a/src/dawn_native/metal/CommandBufferMTL.mm b/src/dawn_native/metal/CommandBufferMTL.mm
index 505cd85..d44740e 100644
--- a/src/dawn_native/metal/CommandBufferMTL.mm
+++ b/src/dawn_native/metal/CommandBufferMTL.mm
@@ -119,6 +119,7 @@
             return descriptor;
         }
 
+        // Helper function for Toggle EmulateStoreAndMSAAResolve
         void ResolveInAnotherRenderPass(
             id<MTLCommandBuffer> commandBuffer,
             const MTLRenderPassDescriptor* mtlRenderPass,
@@ -147,6 +148,48 @@
             [encoder endEncoding];
         }
 
+        // Helper functions for Toggle AlwaysResolveIntoZeroLevelAndLayer
+        id<MTLTexture> CreateResolveTextureForWorkaround(Device* device,
+                                                         MTLPixelFormat mtlFormat,
+                                                         uint32_t width,
+                                                         uint32_t height) {
+            MTLTextureDescriptor* mtlDesc = [MTLTextureDescriptor new];
+            mtlDesc.textureType = MTLTextureType2D;
+            mtlDesc.usage = MTLTextureUsageRenderTarget;
+            mtlDesc.pixelFormat = mtlFormat;
+            mtlDesc.width = width;
+            mtlDesc.height = height;
+            mtlDesc.depth = 1;
+            mtlDesc.mipmapLevelCount = 1;
+            mtlDesc.arrayLength = 1;
+            mtlDesc.storageMode = MTLStorageModePrivate;
+            mtlDesc.sampleCount = 1;
+            id<MTLTexture> resolveTexture =
+                [device->GetMTLDevice() newTextureWithDescriptor:mtlDesc];
+            [mtlDesc release];
+            return resolveTexture;
+        }
+
+        void CopyIntoTrueResolveTarget(id<MTLCommandBuffer> commandBuffer,
+                                       id<MTLTexture> mtlTrueResolveTexture,
+                                       uint32_t trueResolveLevel,
+                                       uint32_t trueResolveSlice,
+                                       id<MTLTexture> temporaryResolveTexture,
+                                       uint32_t width,
+                                       uint32_t height,
+                                       GlobalEncoders* encoders) {
+            encoders->EnsureBlit(commandBuffer);
+            [encoders->blit copyFromTexture:temporaryResolveTexture
+                                sourceSlice:0
+                                sourceLevel:0
+                               sourceOrigin:MTLOriginMake(0, 0, 0)
+                                 sourceSize:MTLSizeMake(width, height, 1)
+                                  toTexture:mtlTrueResolveTexture
+                           destinationSlice:trueResolveSlice
+                           destinationLevel:trueResolveLevel
+                          destinationOrigin:MTLOriginMake(0, 0, 0)];
+        }
+
         // Handles a call to SetBindGroup, directing the commands to the correct encoder.
         // There is a single function that takes both encoders to factor code. Other approaches like
         // templates wouldn't work because the name of methods are different between the two encoder
@@ -627,6 +670,61 @@
 
         Device* device = ToBackend(GetDevice());
 
+        // Handle Toggle AlwaysResolveIntoZeroLevelAndLayer. We must handle this before applying
+        // the store + MSAA resolve workaround, otherwise this toggle will never be handled because
+        // the resolve texture is removed when applying the store + MSAA resolve workaround.
+        if (device->IsToggleEnabled(Toggle::AlwaysResolveIntoZeroLevelAndLayer)) {
+            std::array<id<MTLTexture>, kMaxColorAttachments> trueResolveTextures = {};
+            std::array<uint32_t, kMaxColorAttachments> trueResolveLevels = {};
+            std::array<uint32_t, kMaxColorAttachments> trueResolveSlices = {};
+
+            // Use temporary resolve texture on the resolve targets with non-zero resolveLevel or
+            // resolveSlice.
+            bool useTemporaryResolveTexture = false;
+            std::array<id<MTLTexture>, kMaxColorAttachments> temporaryResolveTextures = {};
+            for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
+                if (mtlRenderPass.colorAttachments[i].resolveTexture == nil) {
+                    continue;
+                }
+
+                if (mtlRenderPass.colorAttachments[i].resolveLevel == 0 &&
+                    mtlRenderPass.colorAttachments[i].resolveSlice == 0) {
+                    continue;
+                }
+
+                trueResolveTextures[i] = mtlRenderPass.colorAttachments[i].resolveTexture;
+                trueResolveLevels[i] = mtlRenderPass.colorAttachments[i].resolveLevel;
+                trueResolveSlices[i] = mtlRenderPass.colorAttachments[i].resolveSlice;
+
+                const MTLPixelFormat mtlFormat = trueResolveTextures[i].pixelFormat;
+                temporaryResolveTextures[i] =
+                    CreateResolveTextureForWorkaround(device, mtlFormat, width, height);
+
+                mtlRenderPass.colorAttachments[i].resolveTexture = temporaryResolveTextures[i];
+                mtlRenderPass.colorAttachments[i].resolveLevel = 0;
+                mtlRenderPass.colorAttachments[i].resolveSlice = 0;
+                useTemporaryResolveTexture = true;
+            }
+
+            // If we need to use a temporary resolve texture we need to copy the result of MSAA
+            // resolve back to the true resolve targets.
+            if (useTemporaryResolveTexture) {
+                EncodeRenderPass(commandBuffer, mtlRenderPass, globalEncoders, width, height);
+                for (uint32_t i = 0; i < kMaxColorAttachments; ++i) {
+                    if (trueResolveTextures[i] == nil) {
+                        continue;
+                    }
+
+                    ASSERT(temporaryResolveTextures[i] != nil);
+                    CopyIntoTrueResolveTarget(commandBuffer, trueResolveTextures[i],
+                                              trueResolveLevels[i], trueResolveSlices[i],
+                                              temporaryResolveTextures[i], width, height,
+                                              globalEncoders);
+                }
+                return;
+            }
+        }
+
         // Handle Store + MSAA resolve workaround (Toggle EmulateStoreAndMSAAResolve).
         if (device->IsToggleEnabled(Toggle::EmulateStoreAndMSAAResolve)) {
             bool hasStoreAndMSAAResolve = false;
diff --git a/src/dawn_native/metal/DeviceMTL.mm b/src/dawn_native/metal/DeviceMTL.mm
index e38d423..d0b58ee 100644
--- a/src/dawn_native/metal/DeviceMTL.mm
+++ b/src/dawn_native/metal/DeviceMTL.mm
@@ -79,6 +79,9 @@
         bool emulateStoreAndMSAAResolve =
             ![mMtlDevice supportsFeatureSet:MTLFeatureSet_macOS_GPUFamily1_v2];
         SetToggle(Toggle::EmulateStoreAndMSAAResolve, emulateStoreAndMSAAResolve);
+
+        // TODO(jiawei.shao@intel.com): tighten this workaround when the driver bug is fixed.
+        SetToggle(Toggle::AlwaysResolveIntoZeroLevelAndLayer, true);
     }
 
     ResultOrError<BindGroupBase*> Device::CreateBindGroupImpl(
diff --git a/src/tests/end2end/MultisampledRenderingTests.cpp b/src/tests/end2end/MultisampledRenderingTests.cpp
index ff66ed0..0f1806d 100644
--- a/src/tests/end2end/MultisampledRenderingTests.cpp
+++ b/src/tests/end2end/MultisampledRenderingTests.cpp
@@ -410,8 +410,6 @@
 
 // Test using a layer of a 2D texture as resolve target works correctly.
 TEST_P(MultisampledRenderingTest, ResolveIntoOneMipmapLevelOf2DTexture) {
-    // TODO(jiawei.shao@intel.com): investigate why this case fails on Intel and Nvidia.
-    DAWN_SKIP_TEST_IF(IsMetal() && (IsIntel() || IsNvidia()));
     constexpr uint32_t kBaseMipLevel = 2;
 
     dawn::TextureViewDescriptor textureViewDescriptor;
@@ -450,8 +448,6 @@
 
 // Test using a level or a layer of a 2D array texture as resolve target works correctly.
 TEST_P(MultisampledRenderingTest, ResolveInto2DArrayTexture) {
-    // TODO(jiawei.shao@intel.com): investigate why this case fails on Intel and Nvidia.
-    DAWN_SKIP_TEST_IF(IsMetal() && (IsIntel() || IsNvidia()));
     dawn::TextureView multisampledColorView2 =
         CreateTextureForOutputAttachment(kColorFormat, kSampleCount).CreateDefaultView();
 
@@ -515,4 +511,5 @@
                       MetalBackend,
                       OpenGLBackend,
                       VulkanBackend,
-                      ForceWorkaround(MetalBackend, "emulate_store_and_msaa_resolve"));
+                      ForceWorkaround(MetalBackend, "emulate_store_and_msaa_resolve"),
+                      ForceWorkaround(MetalBackend, "always_resolve_into_zero_level_and_layer"));