diff --git a/src/dawn/native/BindGroup.cpp b/src/dawn/native/BindGroup.cpp
index 8ac9d20..b2d8948 100644
--- a/src/dawn/native/BindGroup.cpp
+++ b/src/dawn/native/BindGroup.cpp
@@ -49,30 +49,6 @@
 
     ASSERT(bindingInfo.bindingType == BindingInfoType::Buffer);
 
-    wgpu::BufferUsage requiredUsage;
-    uint64_t maxBindingSize;
-    uint64_t requiredBindingAlignment;
-    switch (bindingInfo.buffer.type) {
-        case wgpu::BufferBindingType::Uniform:
-            requiredUsage = wgpu::BufferUsage::Uniform;
-            maxBindingSize = device->GetLimits().v1.maxUniformBufferBindingSize;
-            requiredBindingAlignment = device->GetLimits().v1.minUniformBufferOffsetAlignment;
-            break;
-        case wgpu::BufferBindingType::Storage:
-        case wgpu::BufferBindingType::ReadOnlyStorage:
-            requiredUsage = wgpu::BufferUsage::Storage;
-            maxBindingSize = device->GetLimits().v1.maxStorageBufferBindingSize;
-            requiredBindingAlignment = device->GetLimits().v1.minStorageBufferOffsetAlignment;
-            break;
-        case kInternalStorageBufferBinding:
-            requiredUsage = kInternalStorageBuffer;
-            maxBindingSize = device->GetLimits().v1.maxStorageBufferBindingSize;
-            requiredBindingAlignment = device->GetLimits().v1.minStorageBufferOffsetAlignment;
-            break;
-        case wgpu::BufferBindingType::Undefined:
-            UNREACHABLE();
-    }
-
     uint64_t bufferSize = entry.buffer->GetSize();
 
     // Handle wgpu::WholeSize, avoiding overflows.
@@ -95,6 +71,33 @@
                     "Binding range (offset: %u, size: %u) doesn't fit in the size (%u) of %s.",
                     entry.offset, bufferSize, bindingSize, entry.buffer);
 
+    wgpu::BufferUsage requiredUsage;
+    uint64_t maxBindingSize;
+    uint64_t requiredBindingAlignment;
+    switch (bindingInfo.buffer.type) {
+        case wgpu::BufferBindingType::Uniform:
+            requiredUsage = wgpu::BufferUsage::Uniform;
+            maxBindingSize = device->GetLimits().v1.maxUniformBufferBindingSize;
+            requiredBindingAlignment = device->GetLimits().v1.minUniformBufferOffsetAlignment;
+            break;
+        case wgpu::BufferBindingType::Storage:
+        case wgpu::BufferBindingType::ReadOnlyStorage:
+            requiredUsage = wgpu::BufferUsage::Storage;
+            maxBindingSize = device->GetLimits().v1.maxStorageBufferBindingSize;
+            requiredBindingAlignment = device->GetLimits().v1.minStorageBufferOffsetAlignment;
+            DAWN_INVALID_IF(bindingSize % 4 != 0,
+                            "Binding size (%u) isn't a multiple of 4 when binding type is (%s).",
+                            bindingSize, bindingInfo.buffer.type);
+            break;
+        case kInternalStorageBufferBinding:
+            requiredUsage = kInternalStorageBuffer;
+            maxBindingSize = device->GetLimits().v1.maxStorageBufferBindingSize;
+            requiredBindingAlignment = device->GetLimits().v1.minStorageBufferOffsetAlignment;
+            break;
+        case wgpu::BufferBindingType::Undefined:
+            UNREACHABLE();
+    }
+
     DAWN_INVALID_IF(!IsAligned(entry.offset, requiredBindingAlignment),
                     "Offset (%u) does not satisfy the minimum %s alignment (%u).", entry.offset,
                     bindingInfo.buffer.type, requiredBindingAlignment);
diff --git a/src/dawn/tests/unittests/validation/BindGroupValidationTests.cpp b/src/dawn/tests/unittests/validation/BindGroupValidationTests.cpp
index e687209..81886c6 100644
--- a/src/dawn/tests/unittests/validation/BindGroupValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/BindGroupValidationTests.cpp
@@ -1041,7 +1041,7 @@
 
     // Success case, this is one less than the limit (check it is not an alignment constraint)
     utils::MakeBindGroup(device, uniformLayout,
-                         {{0, buffer, 0, supportedLimits.maxStorageBufferBindingSize - 1}});
+                         {{0, buffer, 0, supportedLimits.maxStorageBufferBindingSize - 4}});
 
     wgpu::BindGroupLayout doubleUniformLayout = utils::MakeBindGroupLayout(
         device, {{0, wgpu::ShaderStage::Fragment, wgpu::BufferBindingType::Storage},
@@ -1055,7 +1055,51 @@
 
     // Error case, this is above the limit
     ASSERT_DEVICE_ERROR(utils::MakeBindGroup(
-        device, uniformLayout, {{0, buffer, 0, supportedLimits.maxStorageBufferBindingSize + 1}}));
+        device, uniformLayout, {{0, buffer, 0, supportedLimits.maxStorageBufferBindingSize + 4}}));
+}
+
+// Test constraints to be sure the effective storage and read-only storage buffer binding size must
+// be a multiple of 4.
+TEST_F(BindGroupValidationTest, EffectiveStorageBufferBindingSize) {
+    wgpu::BufferDescriptor descriptor;
+    descriptor.size = 262;
+    descriptor.usage = wgpu::BufferUsage::Storage;
+    wgpu::Buffer buffer = device.CreateBuffer(&descriptor);
+
+    constexpr std::array<wgpu::BufferBindingType, 2> kStorageBufferBindingTypes = {
+        {wgpu::BufferBindingType::Storage, wgpu::BufferBindingType::ReadOnlyStorage}};
+
+    for (wgpu::BufferBindingType bufferBindingType : kStorageBufferBindingTypes) {
+        wgpu::BindGroupLayout layout = utils::MakeBindGroupLayout(
+            device, {{0, wgpu::ShaderStage::Compute, bufferBindingType}});
+
+        // Error case, as the effective buffer binding size (262) isn't a multiple of 4.
+        {
+            constexpr uint32_t kOffset = 0;
+            ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, kOffset}}));
+        }
+
+        // Error case, as the effective buffer binding size (6) isn't a multiple of 4.
+        {
+            constexpr uint32_t kOffset = 256;
+            ASSERT_DEVICE_ERROR(utils::MakeBindGroup(device, layout, {{0, buffer, kOffset}}));
+        }
+
+        // Error case, as the effective buffer binding size (2) isn't a multiple of 4.
+        {
+            constexpr uint32_t kOffset = 0;
+            constexpr uint32_t kBindingSize = 2;
+            ASSERT_DEVICE_ERROR(
+                utils::MakeBindGroup(device, layout, {{0, buffer, kOffset, kBindingSize}}));
+        }
+
+        // Success case, as the effective buffer binding size (4) is a multiple of 4.
+        {
+            constexpr uint32_t kOffset = 0;
+            constexpr uint32_t kBindingSize = 4;
+            utils::MakeBindGroup(device, layout, {{0, buffer, kOffset, kBindingSize}});
+        }
+    }
 }
 
 // Test what happens when the layout is an error.
@@ -1626,7 +1670,7 @@
                                });
 }
 
-constexpr uint32_t kBindingSize = 9;
+constexpr uint32_t kBindingSize = 8;
 
 class SetBindGroupValidationTest : public ValidationTest {
   public:
@@ -1919,17 +1963,19 @@
 
 // Test cases that test dynamic uniform buffer out of bound situation because of binding size.
 TEST_F(SetBindGroupValidationTest, BindingSizeOutOfBoundDynamicUniformBuffer) {
-    // Set up bind group, but binding size is larger than
+    // Set up bind group, but binding size is larger than (mBufferSize - DynamicOffset).
     wgpu::Buffer uniformBuffer = CreateBuffer(mBufferSize, wgpu::BufferUsage::Uniform);
     wgpu::Buffer storageBuffer = CreateBuffer(mBufferSize, wgpu::BufferUsage::Storage);
     wgpu::Buffer readonlyStorageBuffer = CreateBuffer(mBufferSize, wgpu::BufferUsage::Storage);
-    wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, mBindGroupLayout,
-                                                     {{0, uniformBuffer, 0, kBindingSize},
-                                                      {1, uniformBuffer, 0, kBindingSize},
-                                                      {2, storageBuffer, 0, kBindingSize},
-                                                      {3, readonlyStorageBuffer, 0, kBindingSize}});
+    constexpr uint32_t kLargeBindingSize = kBindingSize + 4u;
+    wgpu::BindGroup bindGroup =
+        utils::MakeBindGroup(device, mBindGroupLayout,
+                             {{0, uniformBuffer, 0, kLargeBindingSize},
+                              {1, uniformBuffer, 0, kLargeBindingSize},
+                              {2, storageBuffer, 0, kLargeBindingSize},
+                              {3, readonlyStorageBuffer, 0, kLargeBindingSize}});
 
-    // Dynamic offset + offset isn't larger than buffer size.
+    // c + offset isn't larger than buffer size.
     // But with binding size, it will trigger OOB error.
     std::array<uint32_t, 3> offsets = {768, 256, 0};
 
@@ -1943,11 +1989,13 @@
     wgpu::Buffer uniformBuffer = CreateBuffer(mBufferSize, wgpu::BufferUsage::Uniform);
     wgpu::Buffer storageBuffer = CreateBuffer(mBufferSize, wgpu::BufferUsage::Storage);
     wgpu::Buffer readonlyStorageBuffer = CreateBuffer(mBufferSize, wgpu::BufferUsage::Storage);
-    wgpu::BindGroup bindGroup = utils::MakeBindGroup(device, mBindGroupLayout,
-                                                     {{0, uniformBuffer, 0, kBindingSize},
-                                                      {1, uniformBuffer, 0, kBindingSize},
-                                                      {2, storageBuffer, 0, kBindingSize},
-                                                      {3, readonlyStorageBuffer, 0, kBindingSize}});
+    constexpr uint32_t kLargeBindingSize = kBindingSize + 4u;
+    wgpu::BindGroup bindGroup =
+        utils::MakeBindGroup(device, mBindGroupLayout,
+                             {{0, uniformBuffer, 0, kLargeBindingSize},
+                              {1, uniformBuffer, 0, kLargeBindingSize},
+                              {2, storageBuffer, 0, kLargeBindingSize},
+                              {3, readonlyStorageBuffer, 0, kLargeBindingSize}});
     // Dynamic offset + offset isn't larger than buffer size.
     // But with binding size, it will trigger OOB error.
     std::array<uint32_t, 3> offsets = {0, 256, 768};
@@ -2593,7 +2641,7 @@
 
 // Test that it is invalid to set a pipeline layout that doesn't have all necessary bindings
 // required by the pipeline.
-TEST_F(BindingsValidationTest, PipelineLayoutWithLessBindingsThanPipeline) {
+TEST_F(BindingsValidationTest, PipelineLayoutWithFewerBindingsThanPipeline) {
     // Set up bind group layout.
     wgpu::BindGroupLayout bgl0 = utils::MakeBindGroupLayout(
         device, {{0, wgpu::ShaderStage::Compute | wgpu::ShaderStage::Fragment,
@@ -2672,7 +2720,7 @@
 // Test that it is invalid to set bind groups that don't have all necessary bindings required
 // by the pipeline layout. Note that both pipeline layout and bind group have enough bindings for
 // pipeline in the following test.
-TEST_F(BindingsValidationTest, BindGroupsWithLessBindingsThanPipelineLayout) {
+TEST_F(BindingsValidationTest, BindGroupsWithFewerBindingsThanPipelineLayout) {
     // Set up bind group layouts, buffers, bind groups, pipeline layouts and pipelines.
     std::array<wgpu::BindGroupLayout, kBindingNum> bgl;
     std::array<wgpu::BindGroup, kBindingNum> bg;
diff --git a/src/dawn/tests/unittests/validation/MinimumBufferSizeValidationTests.cpp b/src/dawn/tests/unittests/validation/MinimumBufferSizeValidationTests.cpp
index b8fbcde..dbd07c2 100644
--- a/src/dawn/tests/unittests/validation/MinimumBufferSizeValidationTests.cpp
+++ b/src/dawn/tests/unittests/validation/MinimumBufferSizeValidationTests.cpp
@@ -55,18 +55,19 @@
 template <typename F>
 void CheckSizeBounds(const std::vector<uint64_t>& correctSizes, F func) {
     // To validate size:
-    // Check invalid with bind group with one less
+    // Check invalid with bind group with 4 less (the effective storage / read-only storage buffer
+    // size must be a multiple of 4).
     // Check valid with bind group with correct size
 
-    // Make sure (every size - 1) produces an error
-    WithEachSizeOffsetBy(-1, correctSizes,
+    // Make sure (every size - 4) produces an error
+    WithEachSizeOffsetBy(-4, correctSizes,
                          [&](const std::vector<uint64_t>& sizes) { func(sizes, false); });
 
     // Make sure correct sizes work
     func(correctSizes, true);
 
-    // Make sure (every size + 1) works
-    WithEachSizeOffsetBy(1, correctSizes,
+    // Make sure (every size + 4) works
+    WithEachSizeOffsetBy(4, correctSizes,
                          [&](const std::vector<uint64_t>& sizes) { func(sizes, true); });
 }
 
@@ -324,8 +325,8 @@
 
 // Pipeline can be created if minimum buffer size in layout is specified as 0
 TEST_F(MinBufferSizePipelineCreationTests, ZeroMinBufferSize) {
-    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32,", "f32", "a", 8},
-                                               {0, 1, "c : f32,", "f32", "c", 4}};
+    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32, c : f32", "f32", "a", 12},
+                                               {0, 1, "d : f32, e : f32", "f32", "d", 8}};
 
     std::string computeShader = CreateComputeShaderWithBindings(bindings);
     std::string vertexShader = CreateVertexShaderWithBindings({});
@@ -338,14 +339,14 @@
 
 // Fail if layout given has non-zero minimum sizes smaller than shader requirements
 TEST_F(MinBufferSizePipelineCreationTests, LayoutSizesTooSmall) {
-    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32,", "f32", "a", 8},
-                                               {0, 1, "c : f32,", "f32", "c", 4}};
+    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32, c: f32", "f32", "a", 12},
+                                               {0, 1, "d : f32, e : f32", "f32", "d", 8}};
 
     std::string computeShader = CreateComputeShaderWithBindings(bindings);
     std::string vertexShader = CreateVertexShaderWithBindings({});
     std::string fragShader = CreateFragmentShaderWithBindings(bindings);
 
-    CheckSizeBounds({8, 4}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
+    CheckSizeBounds({12, 8}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
         wgpu::BindGroupLayout layout = CreateBindGroupLayout(bindings, sizes);
         if (expectation) {
             CreateRenderPipeline({layout}, vertexShader, fragShader);
@@ -359,18 +360,19 @@
 
 // Fail if layout given has non-zero minimum sizes smaller than shader requirements
 TEST_F(MinBufferSizePipelineCreationTests, LayoutSizesTooSmallMultipleGroups) {
-    std::vector<BindingDescriptor> bg0Bindings = {{0, 0, "a : f32, b : f32,", "f32", "a", 8},
-                                                  {0, 1, "c : f32,", "f32", "c", 4}};
+    std::vector<BindingDescriptor> bg0Bindings = {
+        {0, 0, "a : f32, b : f32, c : f32", "f32", "a", 12},
+        {0, 1, "d : f32, e : f32", "f32", "d", 8}};
     std::vector<BindingDescriptor> bg1Bindings = {
-        {1, 0, "d : f32, e : f32, f : f32,", "f32", "e", 12},
-        {1, 1, "g : mat2x2<f32>,", "mat2x2<f32>", "g", 16}};
+        {1, 0, "f : f32, g : f32, h : f32,", "f32", "f", 12},
+        {1, 1, "i : mat2x2<f32>,", "mat2x2<f32>", "i", 16}};
     std::vector<BindingDescriptor> bindings = CombineBindings({bg0Bindings, bg1Bindings});
 
     std::string computeShader = CreateComputeShaderWithBindings(bindings);
     std::string vertexShader = CreateVertexShaderWithBindings({});
     std::string fragShader = CreateFragmentShaderWithBindings(bindings);
 
-    CheckSizeBounds({8, 4, 12, 16}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
+    CheckSizeBounds({12, 8, 12, 16}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
         wgpu::BindGroupLayout layout0 = CreateBindGroupLayout(bg0Bindings, {sizes[0], sizes[1]});
         wgpu::BindGroupLayout layout1 = CreateBindGroupLayout(bg1Bindings, {sizes[2], sizes[3]});
         if (expectation) {
@@ -388,11 +390,11 @@
 
 // Fail if a binding is smaller than minimum buffer size
 TEST_F(MinBufferSizeBindGroupCreationTests, BindingTooSmall) {
-    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32,", "f32", "a", 8},
-                                               {0, 1, "c : f32,", "f32", "c", 4}};
-    wgpu::BindGroupLayout layout = CreateBindGroupLayout(bindings, {8, 4});
+    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32, c : f32", "f32", "a", 12},
+                                               {0, 1, "d : f32, e : f32", "f32", "d", 8}};
+    wgpu::BindGroupLayout layout = CreateBindGroupLayout(bindings, {12, 8});
 
-    CheckSizeBounds({8, 4}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
+    CheckSizeBounds({12, 8}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
         if (expectation) {
             CreateBindGroup(layout, bindings, sizes);
         } else {
@@ -422,8 +424,8 @@
 
 // Fail if binding sizes are too small at draw time
 TEST_F(MinBufferSizeDrawTimeValidationTests, ZeroMinSizeAndTooSmallBinding) {
-    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32,", "f32", "a", 8},
-                                               {0, 1, "c : f32,", "f32", "c", 4}};
+    std::vector<BindingDescriptor> bindings = {{0, 0, "a : f32, b : f32, c : f32", "f32", "a", 12},
+                                               {0, 1, "d : f32, e : f32", "f32", "d", 8}};
 
     std::string computeShader = CreateComputeShaderWithBindings(bindings);
     std::string vertexShader = CreateVertexShaderWithBindings({});
@@ -434,7 +436,7 @@
     wgpu::ComputePipeline computePipeline = CreateComputePipeline({layout}, computeShader);
     wgpu::RenderPipeline renderPipeline = CreateRenderPipeline({layout}, vertexShader, fragShader);
 
-    CheckSizeBounds({8, 4}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
+    CheckSizeBounds({12, 8}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
         wgpu::BindGroup bindGroup = CreateBindGroup(layout, bindings, sizes);
         TestDispatch(computePipeline, {bindGroup}, expectation);
         TestDraw(renderPipeline, {bindGroup}, expectation);
@@ -445,8 +447,8 @@
 TEST_F(MinBufferSizeDrawTimeValidationTests, UnorderedBindings) {
     std::vector<BindingDescriptor> bindings = {
         {0, 2, "a : f32, b : f32,", "f32", "a", 8},
-        {0, 0, "c : f32,", "f32", "c", 4},
-        {0, 4, "d : f32, e : f32, f : f32,", "f32", "e", 12}};
+        {0, 0, "c : f32, d : f32, e : f32", "f32", "c", 12},
+        {0, 4, "f : f32, g : f32, h : f32, i : f32", "f32", "f", 16}};
 
     std::string computeShader = CreateComputeShaderWithBindings(bindings);
     std::string vertexShader = CreateVertexShaderWithBindings({});
@@ -457,7 +459,7 @@
     wgpu::ComputePipeline computePipeline = CreateComputePipeline({layout}, computeShader);
     wgpu::RenderPipeline renderPipeline = CreateRenderPipeline({layout}, vertexShader, fragShader);
 
-    CheckSizeBounds({8, 4, 12}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
+    CheckSizeBounds({8, 12, 16}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
         wgpu::BindGroup bindGroup = CreateBindGroup(layout, bindings, sizes);
         TestDispatch(computePipeline, {bindGroup}, expectation);
         TestDraw(renderPipeline, {bindGroup}, expectation);
@@ -466,11 +468,12 @@
 
 // Draw time validation works for multiple bind groups
 TEST_F(MinBufferSizeDrawTimeValidationTests, MultipleGroups) {
-    std::vector<BindingDescriptor> bg0Bindings = {{0, 0, "a : f32, b : f32,", "f32", "a", 8},
-                                                  {0, 1, "c : f32,", "f32", "c", 4}};
+    std::vector<BindingDescriptor> bg0Bindings = {
+        {0, 0, "a : f32, b : f32, c : f32", "f32", "a", 12},
+        {0, 1, "d : f32, e : f32", "f32", "d", 8}};
     std::vector<BindingDescriptor> bg1Bindings = {
-        {1, 0, "d : f32, e : f32, f : f32,", "f32", "e", 12},
-        {1, 1, "g : mat2x2<f32>,", "mat2x2<f32>", "g", 16}};
+        {1, 0, "f : f32, g : f32, h : f32,", "f32", "f", 12},
+        {1, 1, "i : mat2x2<f32>,", "mat2x2<f32>", "i", 16}};
     std::vector<BindingDescriptor> bindings = CombineBindings({bg0Bindings, bg1Bindings});
 
     std::string computeShader = CreateComputeShaderWithBindings(bindings);
@@ -485,7 +488,7 @@
     wgpu::RenderPipeline renderPipeline =
         CreateRenderPipeline({layout0, layout1}, vertexShader, fragShader);
 
-    CheckSizeBounds({8, 4, 12, 16}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
+    CheckSizeBounds({12, 8, 12, 16}, [&](const std::vector<uint64_t>& sizes, bool expectation) {
         wgpu::BindGroup bindGroup0 = CreateBindGroup(layout0, bg0Bindings, {sizes[0], sizes[1]});
         wgpu::BindGroup bindGroup1 = CreateBindGroup(layout0, bg0Bindings, {sizes[2], sizes[3]});
         TestDispatch(computePipeline, {bindGroup0, bindGroup1}, expectation);
diff --git a/webgpu-cts/expectations.txt b/webgpu-cts/expectations.txt
index 3eed0b2..7889042 100644
--- a/webgpu-cts/expectations.txt
+++ b/webgpu-cts/expectations.txt
@@ -770,6 +770,16 @@
 crbug.com/dawn/1539 [ ubuntu ] webgpu:api,validation,render_pipeline,fragment_state:pipeline_output_targets:isAsync=true;* [ Failure ]
 
 ################################################################################
+# storage buffer binding size failures
+################################################################################
+crbug.com/dawn/1542 webgpu:api,validation,createBindGroup:buffer,resource_binding_size:type="read-only-storage" [ Failure ]
+crbug.com/dawn/1542 webgpu:api,validation,createBindGroup:buffer,resource_binding_size:type="storage" [ Failure ]
+crbug.com/dawn/1542 webgpu:api,validation,createBindGroup:minBindingSize: [ Failure ]
+crbug.com/dawn/1542 webgpu:api,validation,encoding,cmds,setBindGroup:buffer_dynamic_offsets:type="read-only-storage";* [ Failure ]
+crbug.com/dawn/1542 webgpu:api,validation,encoding,cmds,setBindGroup:buffer_dynamic_offsets:type="storage";* [ Failure ]
+crbug.com/dawn/1542 webgpu:api,validation,encoding,cmds,setBindGroup:dynamic_offsets_match_expectations_in_pass_encoder:* [ Failure ]
+
+################################################################################
 # untriaged failures
 # KEEP
 ################################################################################
@@ -788,8 +798,6 @@
 # New failures. Please triage:
 crbug.com/dawn/0000 [ intel-gen-9 win10 ] webgpu:api,operation,command_buffer,image_copy:mip_levels:initMethod="WriteTexture";checkMethod="PartialCopyT2B";format="rgba32uint";dimension="2d" [ Failure ]
 crbug.com/dawn/0000 webgpu:api,validation,compute_pipeline:overrides,workgroup_size,limits,* [ Failure ]
-crbug.com/dawn/0000 [ win10 ] webgpu:api,validation,createBindGroup:buffer,resource_binding_size:type="read-only-storage" [ Failure ]
-crbug.com/dawn/0000 [ win10 ] webgpu:api,validation,createBindGroup:buffer,resource_binding_size:type="storage" [ Failure ]
 crbug.com/dawn/0000 webgpu:api,validation,createBindGroupLayout:multisampled_validation:viewDimension="2d" [ Failure ]
 crbug.com/dawn/0000 webgpu:api,validation,createBindGroupLayout:multisampled_validation:viewDimension="_undef_" [ Failure ]
 crbug.com/dawn/0000 [ nvidia-0x2184 target-cpu-32 webgpu-adapter-default win10 ] webgpu:shader,execution,shader_io,compute_builtins:inputs:method="mixed";dispatch="indirect";groupSize={"x":1,"y":1,"z":1};numGroups={"x":1,"y":1,"z":1} [ Failure ]