diff --git a/BUILD.gn b/BUILD.gn
index 0fd9cf4..58e1278 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -789,6 +789,7 @@
     "src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp",
     "src/tests/unittests/validation/ErrorScopeValidationTests.cpp",
     "src/tests/unittests/validation/FenceValidationTests.cpp",
+    "src/tests/unittests/validation/GetBindGroupLayoutValidationTests.cpp",
     "src/tests/unittests/validation/QueueSubmitValidationTests.cpp",
     "src/tests/unittests/validation/RenderBundleValidationTests.cpp",
     "src/tests/unittests/validation/RenderPassDescriptorValidationTests.cpp",
diff --git a/dawn.json b/dawn.json
index af922ec..44fce28 100644
--- a/dawn.json
+++ b/dawn.json
@@ -437,14 +437,23 @@
         ]
     },
     "compute pipeline": {
-        "category": "object"
+        "category": "object",
+        "methods": [
+            {
+                "name": "get bind group layout",
+                "returns": "bind group layout",
+                "args": [
+                    {"name": "group", "type": "uint32_t"}
+                ]
+            }
+        ]
     },
     "compute pipeline descriptor": {
         "category": "structure",
         "extensible": true,
         "members": [
             {"name": "label", "type": "char", "annotation": "const*", "length": "strlen", "optional": true},
-            {"name": "layout", "type": "pipeline layout"},
+            {"name": "layout", "type": "pipeline layout", "optional": true},
             {"name": "compute stage", "type": "programmable stage descriptor"}
         ]
     },
@@ -1118,14 +1127,23 @@
         ]
     },
     "render pipeline": {
-        "category": "object"
+        "category": "object",
+        "methods": [
+            {
+                "name": "get bind group layout",
+                "returns": "bind group layout",
+                "args": [
+                    {"name": "group", "type": "uint32_t"}
+                ]
+            }
+        ]
     },
     "render pipeline descriptor": {
         "category": "structure",
         "extensible": true,
         "members": [
             {"name": "label", "type": "char", "annotation": "const*", "length": "strlen", "optional": true},
-            {"name": "layout", "type": "pipeline layout"},
+            {"name": "layout", "type": "pipeline layout", "optional": true},
             {"name": "vertex stage", "type": "programmable stage descriptor"},
             {"name": "fragment stage", "type": "programmable stage descriptor", "annotation": "const*", "optional": true},
             {"name": "vertex state", "type": "vertex state descriptor", "annotation": "const*", "optional": true},
diff --git a/generator/templates/webgpu_cpp.h b/generator/templates/webgpu_cpp.h
index 911a16f..b110f56 100644
--- a/generator/templates/webgpu_cpp.h
+++ b/generator/templates/webgpu_cpp.h
@@ -108,6 +108,13 @@
             return static_cast<Derived&>(*this);
         }
 
+        bool operator==(std::nullptr_t) const {
+            return mHandle == nullptr;
+        }
+        bool operator!=(std::nullptr_t) const {
+            return mHandle != nullptr;
+        }
+
         explicit operator bool() const {
             return mHandle != nullptr;
         }
diff --git a/src/dawn_native/ComputePipeline.cpp b/src/dawn_native/ComputePipeline.cpp
index 137d648..c1394c6 100644
--- a/src/dawn_native/ComputePipeline.cpp
+++ b/src/dawn_native/ComputePipeline.cpp
@@ -25,7 +25,10 @@
             return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
         }
 
-        DAWN_TRY(device->ValidateObject(descriptor->layout));
+        if (descriptor->layout != nullptr) {
+            DAWN_TRY(device->ValidateObject(descriptor->layout));
+        }
+
         DAWN_TRY(ValidateProgrammableStageDescriptor(
             device, &descriptor->computeStage, descriptor->layout, SingleShaderStage::Compute));
         return {};
diff --git a/src/dawn_native/Device.cpp b/src/dawn_native/Device.cpp
index cade900..664b81d 100644
--- a/src/dawn_native/Device.cpp
+++ b/src/dawn_native/Device.cpp
@@ -670,7 +670,21 @@
         if (IsValidationEnabled()) {
             DAWN_TRY(ValidateComputePipelineDescriptor(this, descriptor));
         }
-        DAWN_TRY_ASSIGN(*result, GetOrCreateComputePipeline(descriptor));
+
+        if (descriptor->layout == nullptr) {
+            ComputePipelineDescriptor descriptorWithDefaultLayout = *descriptor;
+
+            DAWN_TRY_ASSIGN(
+                descriptorWithDefaultLayout.layout,
+                PipelineLayoutBase::CreateDefault(this, &descriptor->computeStage.module, 1));
+            // Ref will keep the pipeline layout alive until the end of the function where
+            // the pipeline will take another reference.
+            Ref<PipelineLayoutBase> layoutRef = AcquireRef(descriptorWithDefaultLayout.layout);
+
+            DAWN_TRY_ASSIGN(*result, GetOrCreateComputePipeline(&descriptorWithDefaultLayout));
+        } else {
+            DAWN_TRY_ASSIGN(*result, GetOrCreateComputePipeline(descriptor));
+        }
         return {};
     }
 
@@ -705,7 +719,30 @@
         if (IsValidationEnabled()) {
             DAWN_TRY(ValidateRenderPipelineDescriptor(this, descriptor));
         }
-        DAWN_TRY_ASSIGN(*result, GetOrCreateRenderPipeline(descriptor));
+
+        if (descriptor->layout == nullptr) {
+            RenderPipelineDescriptor descriptorWithDefaultLayout = *descriptor;
+
+            const ShaderModuleBase* modules[2];
+            modules[0] = descriptor->vertexStage.module;
+            uint32_t count;
+            if (descriptor->fragmentStage == nullptr) {
+                count = 1;
+            } else {
+                modules[1] = descriptor->fragmentStage->module;
+                count = 2;
+            }
+
+            DAWN_TRY_ASSIGN(descriptorWithDefaultLayout.layout,
+                            PipelineLayoutBase::CreateDefault(this, modules, count));
+            // Ref will keep the pipeline layout alive until the end of the function where
+            // the pipeline will take another reference.
+            Ref<PipelineLayoutBase> layoutRef = AcquireRef(descriptorWithDefaultLayout.layout);
+
+            DAWN_TRY_ASSIGN(*result, GetOrCreateRenderPipeline(&descriptorWithDefaultLayout));
+        } else {
+            DAWN_TRY_ASSIGN(*result, GetOrCreateRenderPipeline(descriptor));
+        }
         return {};
     }
 
diff --git a/src/dawn_native/Format.cpp b/src/dawn_native/Format.cpp
index 79623e1..c553784 100644
--- a/src/dawn_native/Format.cpp
+++ b/src/dawn_native/Format.cpp
@@ -22,8 +22,17 @@
 
     // Format
 
+    // static
     Format::Type Format::TextureComponentTypeToFormatType(
         wgpu::TextureComponentType componentType) {
+        switch (componentType) {
+            case wgpu::TextureComponentType::Float:
+            case wgpu::TextureComponentType::Sint:
+            case wgpu::TextureComponentType::Uint:
+                break;
+            default:
+                UNREACHABLE();
+        }
         // Check that Type correctly mirrors TextureComponentType except for "Other".
         static_assert(static_cast<Type>(wgpu::TextureComponentType::Float) == Type::Float, "");
         static_assert(static_cast<Type>(wgpu::TextureComponentType::Sint) == Type::Sint, "");
@@ -31,6 +40,23 @@
         return static_cast<Type>(componentType);
     }
 
+    // static
+    wgpu::TextureComponentType Format::FormatTypeToTextureComponentType(Type type) {
+        switch (type) {
+            case Type::Float:
+            case Type::Sint:
+            case Type::Uint:
+                break;
+            default:
+                UNREACHABLE();
+        }
+        // Check that Type correctly mirrors TextureComponentType except for "Other".
+        static_assert(static_cast<Type>(wgpu::TextureComponentType::Float) == Type::Float, "");
+        static_assert(static_cast<Type>(wgpu::TextureComponentType::Sint) == Type::Sint, "");
+        static_assert(static_cast<Type>(wgpu::TextureComponentType::Uint) == Type::Uint, "");
+        return static_cast<wgpu::TextureComponentType>(type);
+    }
+
     bool Format::IsColor() const {
         return aspect == Aspect::Color;
     }
diff --git a/src/dawn_native/Format.h b/src/dawn_native/Format.h
index 9b5cfbe..f1e4fbb 100644
--- a/src/dawn_native/Format.h
+++ b/src/dawn_native/Format.h
@@ -58,6 +58,7 @@
         uint32_t blockHeight;
 
         static Type TextureComponentTypeToFormatType(wgpu::TextureComponentType componentType);
+        static wgpu::TextureComponentType FormatTypeToTextureComponentType(Type type);
 
         bool IsColor() const;
         bool HasDepth() const;
diff --git a/src/dawn_native/Pipeline.cpp b/src/dawn_native/Pipeline.cpp
index 9d24011..ad819d1 100644
--- a/src/dawn_native/Pipeline.cpp
+++ b/src/dawn_native/Pipeline.cpp
@@ -14,6 +14,7 @@
 
 #include "dawn_native/Pipeline.h"
 
+#include "dawn_native/BindGroupLayout.h"
 #include "dawn_native/Device.h"
 #include "dawn_native/PipelineLayout.h"
 #include "dawn_native/ShaderModule.h"
@@ -32,7 +33,7 @@
         if (descriptor->module->GetExecutionModel() != stage) {
             return DAWN_VALIDATION_ERROR("Setting module with wrong stages");
         }
-        if (!descriptor->module->IsCompatibleWithPipelineLayout(layout)) {
+        if (layout != nullptr && !descriptor->module->IsCompatibleWithPipelineLayout(layout)) {
             return DAWN_VALIDATION_ERROR("Stage not compatible with layout");
         }
         return {};
@@ -65,4 +66,41 @@
         return mLayout.Get();
     }
 
+    MaybeError PipelineBase::ValidateGetBindGroupLayout(uint32_t group) {
+        DAWN_TRY(GetDevice()->ValidateObject(this));
+        DAWN_TRY(GetDevice()->ValidateObject(mLayout.Get()));
+        if (group >= kMaxBindGroups) {
+            return DAWN_VALIDATION_ERROR("Bind group layout index out of bounds");
+        }
+        return {};
+    }
+
+    BindGroupLayoutBase* PipelineBase::GetBindGroupLayout(uint32_t group) {
+        if (GetDevice()->ConsumedError(ValidateGetBindGroupLayout(group))) {
+            return BindGroupLayoutBase::MakeError(GetDevice());
+        }
+
+        if (!mLayout->GetBindGroupLayoutsMask()[group]) {
+            // Get or create an empty bind group layout.
+            // TODO(enga): Consider caching this object on the Device and reusing it.
+            // Today, this can't be done correctly because of the order of Device destruction.
+            // For example, vulkan::~Device will be called before ~DeviceBase. If DeviceBase owns
+            // a Ref<BindGroupLayoutBase>, then the VkDevice will be destroyed before the
+            // VkDescriptorSetLayout.
+            BindGroupLayoutDescriptor desc = {};
+            desc.bindingCount = 0;
+            desc.bindings = nullptr;
+
+            BindGroupLayoutBase* bgl = nullptr;
+            if (GetDevice()->ConsumedError(GetDevice()->GetOrCreateBindGroupLayout(&desc), &bgl)) {
+                return BindGroupLayoutBase::MakeError(GetDevice());
+            }
+            return bgl;
+        }
+
+        BindGroupLayoutBase* bgl = mLayout->GetBindGroupLayout(group);
+        bgl->Reference();
+        return bgl;
+    }
+
 }  // namespace dawn_native
diff --git a/src/dawn_native/Pipeline.h b/src/dawn_native/Pipeline.h
index 5c6e6ee..29c8386 100644
--- a/src/dawn_native/Pipeline.h
+++ b/src/dawn_native/Pipeline.h
@@ -38,12 +38,15 @@
         wgpu::ShaderStage GetStageMask() const;
         PipelineLayoutBase* GetLayout();
         const PipelineLayoutBase* GetLayout() const;
+        BindGroupLayoutBase* GetBindGroupLayout(uint32_t group);
 
       protected:
         PipelineBase(DeviceBase* device, PipelineLayoutBase* layout, wgpu::ShaderStage stages);
         PipelineBase(DeviceBase* device, ObjectBase::ErrorTag tag);
 
       private:
+        MaybeError ValidateGetBindGroupLayout(uint32_t group);
+
         wgpu::ShaderStage mStageMask;
         Ref<PipelineLayoutBase> mLayout;
     };
diff --git a/src/dawn_native/PipelineLayout.cpp b/src/dawn_native/PipelineLayout.cpp
index 4aea64b..b76e553 100644
--- a/src/dawn_native/PipelineLayout.cpp
+++ b/src/dawn_native/PipelineLayout.cpp
@@ -19,9 +19,22 @@
 #include "common/HashUtils.h"
 #include "dawn_native/BindGroupLayout.h"
 #include "dawn_native/Device.h"
+#include "dawn_native/ShaderModule.h"
 
 namespace dawn_native {
 
+    namespace {
+
+        bool operator==(const BindGroupLayoutBinding& lhs, const BindGroupLayoutBinding& rhs) {
+            return lhs.binding == rhs.binding && lhs.visibility == rhs.visibility &&
+                   lhs.type == rhs.type && lhs.hasDynamicOffset == rhs.hasDynamicOffset &&
+                   lhs.multisampled == rhs.multisampled &&
+                   lhs.textureDimension == rhs.textureDimension &&
+                   lhs.textureComponentType == rhs.textureComponentType;
+        }
+
+    }  // anonymous namespace
+
     MaybeError ValidatePipelineLayoutDescriptor(DeviceBase* device,
                                                 const PipelineLayoutDescriptor* descriptor) {
         if (descriptor->nextInChain != nullptr) {
@@ -81,11 +94,126 @@
         return new PipelineLayoutBase(device, ObjectBase::kError);
     }
 
-    const BindGroupLayoutBase* PipelineLayoutBase::GetBindGroupLayout(size_t group) const {
+    // static
+    ResultOrError<PipelineLayoutBase*> PipelineLayoutBase::CreateDefault(
+        DeviceBase* device,
+        const ShaderModuleBase* const* modules,
+        uint32_t count) {
+        ASSERT(count > 0);
+
+        // Data which BindGroupLayoutDescriptor will point to for creation
+        std::array<std::array<BindGroupLayoutBinding, kMaxBindingsPerGroup>, kMaxBindGroups>
+            bindingData = {};
+
+        // Bitsets of used bindings
+        std::array<std::bitset<kMaxBindingsPerGroup>, kMaxBindGroups> usedBindings = {};
+
+        // A flat map of bindings to the index in |bindingData|
+        std::array<std::array<uint32_t, kMaxBindingsPerGroup>, kMaxBindGroups> usedBindingsMap = {};
+
+        // A counter of how many bindings we've populated in |bindingData|
+        std::array<uint32_t, kMaxBindGroups> bindingCounts = {};
+
+        uint32_t bindGroupLayoutCount = 0;
+        for (uint32_t moduleIndex = 0; moduleIndex < count; ++moduleIndex) {
+            const ShaderModuleBase* module = modules[moduleIndex];
+            const ShaderModuleBase::ModuleBindingInfo& info = module->GetBindingInfo();
+
+            for (uint32_t group = 0; group < info.size(); ++group) {
+                for (uint32_t binding = 0; binding < info[group].size(); ++binding) {
+                    const ShaderModuleBase::BindingInfo& bindingInfo = info[group][binding];
+                    if (!bindingInfo.used) {
+                        continue;
+                    }
+
+                    if (bindingInfo.multisampled) {
+                        return DAWN_VALIDATION_ERROR("Multisampled textures not supported (yet)");
+                    }
+
+                    BindGroupLayoutBinding bindingSlot;
+                    bindingSlot.binding = binding;
+                    bindingSlot.visibility = wgpu::ShaderStage::Vertex |
+                                             wgpu::ShaderStage::Fragment |
+                                             wgpu::ShaderStage::Compute;
+                    bindingSlot.type = bindingInfo.type;
+                    bindingSlot.hasDynamicOffset = false;
+                    bindingSlot.multisampled = bindingInfo.multisampled;
+                    bindingSlot.textureDimension = bindingInfo.textureDimension;
+                    bindingSlot.textureComponentType =
+                        Format::FormatTypeToTextureComponentType(bindingInfo.textureComponentType);
+
+                    if (usedBindings[group][binding]) {
+                        if (bindingSlot == bindingData[group][usedBindingsMap[group][binding]]) {
+                            // Already used and the data is the same. Continue.
+                            continue;
+                        } else {
+                            return DAWN_VALIDATION_ERROR(
+                                "Duplicate binding in default pipeline layout initialization not "
+                                "compatible with previous declaration");
+                        }
+                    }
+
+                    uint32_t currentBindingCount = bindingCounts[group];
+                    bindingData[group][currentBindingCount] = bindingSlot;
+
+                    usedBindingsMap[group][binding] = currentBindingCount;
+                    usedBindings[group].set(binding);
+
+                    bindingCounts[group]++;
+
+                    bindGroupLayoutCount = std::max(bindGroupLayoutCount, group + 1);
+                }
+            }
+        }
+
+        std::array<BindGroupLayoutBase*, kMaxBindGroups> bindGroupLayouts = {};
+        for (uint32_t group = 0; group < bindGroupLayoutCount; ++group) {
+            BindGroupLayoutDescriptor desc = {};
+            desc.bindings = bindingData[group].data();
+            desc.bindingCount = bindingCounts[group];
+
+            // We should never produce a bad descriptor.
+            ASSERT(!ValidateBindGroupLayoutDescriptor(device, &desc).IsError());
+            DAWN_TRY_ASSIGN(bindGroupLayouts[group], device->GetOrCreateBindGroupLayout(&desc));
+        }
+
+        PipelineLayoutDescriptor desc = {};
+        desc.bindGroupLayouts = bindGroupLayouts.data();
+        desc.bindGroupLayoutCount = bindGroupLayoutCount;
+        PipelineLayoutBase* pipelineLayout = device->CreatePipelineLayout(&desc);
+        ASSERT(!pipelineLayout->IsError());
+
+        // These bind group layouts are created internally and referenced by the pipeline layout.
+        // Release the external refcount.
+        for (uint32_t group = 0; group < bindGroupLayoutCount; ++group) {
+            if (bindGroupLayouts[group] != nullptr) {
+                bindGroupLayouts[group]->Release();
+            }
+        }
+
+        for (uint32_t moduleIndex = 0; moduleIndex < count; ++moduleIndex) {
+            ASSERT(modules[moduleIndex]->IsCompatibleWithPipelineLayout(pipelineLayout));
+        }
+
+        return pipelineLayout;
+    }
+
+    const BindGroupLayoutBase* PipelineLayoutBase::GetBindGroupLayout(uint32_t group) const {
         ASSERT(!IsError());
         ASSERT(group < kMaxBindGroups);
         ASSERT(mMask[group]);
-        return mBindGroupLayouts[group].Get();
+        const BindGroupLayoutBase* bgl = mBindGroupLayouts[group].Get();
+        ASSERT(bgl != nullptr);
+        return bgl;
+    }
+
+    BindGroupLayoutBase* PipelineLayoutBase::GetBindGroupLayout(uint32_t group) {
+        ASSERT(!IsError());
+        ASSERT(group < kMaxBindGroups);
+        ASSERT(mMask[group]);
+        BindGroupLayoutBase* bgl = mBindGroupLayouts[group].Get();
+        ASSERT(bgl != nullptr);
+        return bgl;
     }
 
     const std::bitset<kMaxBindGroups> PipelineLayoutBase::GetBindGroupLayoutsMask() const {
diff --git a/src/dawn_native/PipelineLayout.h b/src/dawn_native/PipelineLayout.h
index fd769f2..f919eff 100644
--- a/src/dawn_native/PipelineLayout.h
+++ b/src/dawn_native/PipelineLayout.h
@@ -38,8 +38,11 @@
         ~PipelineLayoutBase() override;
 
         static PipelineLayoutBase* MakeError(DeviceBase* device);
+        static ResultOrError<PipelineLayoutBase*>
+        CreateDefault(DeviceBase* device, const ShaderModuleBase* const* modules, uint32_t count);
 
-        const BindGroupLayoutBase* GetBindGroupLayout(size_t group) const;
+        const BindGroupLayoutBase* GetBindGroupLayout(uint32_t group) const;
+        BindGroupLayoutBase* GetBindGroupLayout(uint32_t group);
         const std::bitset<kMaxBindGroups> GetBindGroupLayoutsMask() const;
 
         // Utility functions to compute inherited bind groups.
diff --git a/src/dawn_native/RenderPipeline.cpp b/src/dawn_native/RenderPipeline.cpp
index 160b3d2..be87040 100644
--- a/src/dawn_native/RenderPipeline.cpp
+++ b/src/dawn_native/RenderPipeline.cpp
@@ -280,7 +280,9 @@
             return DAWN_VALIDATION_ERROR("nextInChain must be nullptr");
         }
 
-        DAWN_TRY(device->ValidateObject(descriptor->layout));
+        if (descriptor->layout != nullptr) {
+            DAWN_TRY(device->ValidateObject(descriptor->layout));
+        }
 
         // TODO(crbug.com/dawn/136): Support vertex-only pipelines.
         if (descriptor->fragmentStage == nullptr) {
diff --git a/src/dawn_native/ShaderModule.cpp b/src/dawn_native/ShaderModule.cpp
index 2879b51..dfa9acf 100644
--- a/src/dawn_native/ShaderModule.cpp
+++ b/src/dawn_native/ShaderModule.cpp
@@ -175,36 +175,37 @@
                     continue;
                 }
 
-                auto& info = mBindingInfo[set][binding];
-                info.used = true;
-                info.id = resource.id;
-                info.base_type_id = resource.base_type_id;
+                BindingInfo* info = &mBindingInfo[set][binding];
+                *info = {};
+                info->used = true;
+                info->id = resource.id;
+                info->base_type_id = resource.base_type_id;
                 switch (bindingType) {
                     case wgpu::BindingType::SampledTexture: {
                         spirv_cross::SPIRType::ImageType imageType =
-                            compiler.get_type(info.base_type_id).image;
+                            compiler.get_type(info->base_type_id).image;
                         spirv_cross::SPIRType::BaseType textureComponentType =
                             compiler.get_type(imageType.type).basetype;
 
-                        info.multisampled = imageType.ms;
-                        info.textureDimension =
+                        info->multisampled = imageType.ms;
+                        info->textureDimension =
                             SpirvDimToTextureViewDimension(imageType.dim, imageType.arrayed);
-                        info.textureComponentType =
+                        info->textureComponentType =
                             SpirvCrossBaseTypeToFormatType(textureComponentType);
-                        info.type = bindingType;
+                        info->type = bindingType;
                     } break;
                     case wgpu::BindingType::StorageBuffer: {
                         // Differentiate between readonly storage bindings and writable ones based
                         // on the NonWritable decoration
                         spirv_cross::Bitset flags = compiler.get_buffer_block_flags(resource.id);
                         if (flags.get(spv::DecorationNonWritable)) {
-                            info.type = wgpu::BindingType::ReadonlyStorageBuffer;
+                            info->type = wgpu::BindingType::ReadonlyStorageBuffer;
                         } else {
-                            info.type = wgpu::BindingType::StorageBuffer;
+                            info->type = wgpu::BindingType::StorageBuffer;
                         }
                     } break;
                     default:
-                        info.type = bindingType;
+                        info->type = bindingType;
                 }
             }
         };
@@ -296,7 +297,7 @@
         return mExecutionModel;
     }
 
-    bool ShaderModuleBase::IsCompatibleWithPipelineLayout(const PipelineLayoutBase* layout) {
+    bool ShaderModuleBase::IsCompatibleWithPipelineLayout(const PipelineLayoutBase* layout) const {
         ASSERT(!IsError());
 
         for (uint32_t group : IterateBitSet(layout->GetBindGroupLayoutsMask())) {
@@ -316,8 +317,9 @@
         return true;
     }
 
-    bool ShaderModuleBase::IsCompatibleWithBindGroupLayout(size_t group,
-                                                           const BindGroupLayoutBase* layout) {
+    bool ShaderModuleBase::IsCompatibleWithBindGroupLayout(
+        size_t group,
+        const BindGroupLayoutBase* layout) const {
         ASSERT(!IsError());
 
         const auto& layoutInfo = layout->GetBindingInfo();
diff --git a/src/dawn_native/ShaderModule.h b/src/dawn_native/ShaderModule.h
index dedde2f..42756be 100644
--- a/src/dawn_native/ShaderModule.h
+++ b/src/dawn_native/ShaderModule.h
@@ -69,7 +69,7 @@
         using FragmentOutputBaseTypes = std::array<Format::Type, kMaxColorAttachments>;
         const FragmentOutputBaseTypes& GetFragmentOutputBaseTypes() const;
 
-        bool IsCompatibleWithPipelineLayout(const PipelineLayoutBase* layout);
+        bool IsCompatibleWithPipelineLayout(const PipelineLayoutBase* layout) const;
 
         // Functors necessary for the unordered_set<ShaderModuleBase*>-based cache.
         struct HashFunc {
@@ -82,7 +82,7 @@
       private:
         ShaderModuleBase(DeviceBase* device, ObjectBase::ErrorTag tag);
 
-        bool IsCompatibleWithBindGroupLayout(size_t group, const BindGroupLayoutBase* layout);
+        bool IsCompatibleWithBindGroupLayout(size_t group, const BindGroupLayoutBase* layout) const;
 
         // TODO(cwallez@chromium.org): The code is only stored for deduplication. We could maybe
         // store a cryptographic hash of the code instead?
diff --git a/src/tests/unittests/validation/GetBindGroupLayoutValidationTests.cpp b/src/tests/unittests/validation/GetBindGroupLayoutValidationTests.cpp
new file mode 100644
index 0000000..18673ea
--- /dev/null
+++ b/src/tests/unittests/validation/GetBindGroupLayoutValidationTests.cpp
@@ -0,0 +1,674 @@
+// Copyright 2019 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 "tests/unittests/validation/ValidationTest.h"
+
+#include "utils/ComboRenderPipelineDescriptor.h"
+#include "utils/WGPUHelpers.h"
+
+class GetBindGroupLayoutTests : public ValidationTest {
+  protected:
+    static constexpr wgpu::ShaderStage kVisibilityAll =
+        wgpu::ShaderStage::Compute | wgpu::ShaderStage::Fragment | wgpu::ShaderStage::Vertex;
+
+    wgpu::RenderPipeline RenderPipelineFromVertexShader(const char* shader) {
+        wgpu::ShaderModule vsModule =
+            utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, shader);
+        wgpu::ShaderModule fsModule =
+            utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        void main() {
+        })");
+
+        utils::ComboRenderPipelineDescriptor descriptor(device);
+        descriptor.layout = nullptr;
+        descriptor.vertexStage.module = vsModule;
+        descriptor.cFragmentStage.module = fsModule;
+
+        return device.CreateRenderPipeline(&descriptor);
+    }
+};
+
+// Test that GetBindGroupLayout returns the same object for the same index
+// and for matching layouts.
+TEST_F(GetBindGroupLayoutTests, SameObject) {
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform UniformBuffer1 {
+            vec4 pos1;
+        };
+
+        layout(set = 1, binding = 0) uniform UniformBuffer2 {
+            vec4 pos2;
+        };
+
+        void main() {
+        })");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 2, binding = 0) uniform UniformBuffer3 {
+            vec4 pos3;
+        };
+
+        layout(set = 3, binding = 0) buffer StorageBuffer {
+            mat4 pos4;
+        };
+
+        void main() {
+        })");
+
+    utils::ComboRenderPipelineDescriptor descriptor(device);
+    descriptor.layout = nullptr;
+    descriptor.vertexStage.module = vsModule;
+    descriptor.cFragmentStage.module = fsModule;
+
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor);
+
+    EXPECT_EQ(pipeline.GetBindGroupLayout(0).Get(), pipeline.GetBindGroupLayout(0).Get());
+
+    EXPECT_EQ(pipeline.GetBindGroupLayout(1).Get(), pipeline.GetBindGroupLayout(1).Get());
+
+    EXPECT_EQ(pipeline.GetBindGroupLayout(0).Get(), pipeline.GetBindGroupLayout(1).Get());
+
+    EXPECT_EQ(pipeline.GetBindGroupLayout(0).Get(), pipeline.GetBindGroupLayout(2).Get());
+
+    EXPECT_NE(pipeline.GetBindGroupLayout(0).Get(), pipeline.GetBindGroupLayout(3).Get());
+}
+
+// Test that getBindGroupLayout defaults are correct
+// - shader stage visibility is All
+// - dynamic offsets is false
+TEST_F(GetBindGroupLayoutTests, DefaultShaderStageAndDynamicOffsets) {
+    wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform UniformBuffer {
+            vec4 pos;
+        };
+
+        void main() {
+        })");
+
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.type = wgpu::BindingType::UniformBuffer;
+    binding.multisampled = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    // Check that visibility and dynamic offsets match
+    binding.hasDynamicOffset = false;
+    binding.visibility = kVisibilityAll;
+    EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+
+    // Check that any change in visibility doesn't match.
+    binding.visibility = wgpu::ShaderStage::Vertex;
+    EXPECT_NE(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+
+    binding.visibility = wgpu::ShaderStage::Fragment;
+    EXPECT_NE(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+
+    binding.visibility = wgpu::ShaderStage::Compute;
+    EXPECT_NE(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+
+    // Check that any change in hasDynamicOffsets doesn't match.
+    binding.hasDynamicOffset = true;
+    binding.visibility = kVisibilityAll;
+    EXPECT_NE(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+}
+
+// Test GetBindGroupLayout works with a compute pipeline
+TEST_F(GetBindGroupLayoutTests, ComputePipeline) {
+    wgpu::ShaderModule csModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Compute, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform UniformBuffer {
+            vec4 pos;
+        };
+        void main() {
+        })");
+
+    wgpu::ComputePipelineDescriptor descriptor;
+    descriptor.layout = nullptr;
+    descriptor.computeStage.module = csModule;
+    descriptor.computeStage.entryPoint = "main";
+
+    wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&descriptor);
+
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.type = wgpu::BindingType::UniformBuffer;
+    binding.visibility = kVisibilityAll;
+    binding.hasDynamicOffset = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+}
+
+// Test that the binding type matches the shader.
+TEST_F(GetBindGroupLayoutTests, BindingType) {
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.visibility = kVisibilityAll;
+    binding.hasDynamicOffset = false;
+    binding.multisampled = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    {
+        binding.type = wgpu::BindingType::UniformBuffer;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform Buffer {
+            vec4 pos;
+        };
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.type = wgpu::BindingType::StorageBuffer;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) buffer Storage {
+            vec4 pos;
+        };
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.type = wgpu::BindingType::ReadonlyStorageBuffer;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) readonly buffer Storage {
+            vec4 pos;
+        };
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.type = wgpu::BindingType::SampledTexture;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2D tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.type = wgpu::BindingType::Sampler;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform sampler samp;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+}
+
+// Test that multisampling matches the shader.
+TEST_F(GetBindGroupLayoutTests, Multisampled) {
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.type = wgpu::BindingType::SampledTexture;
+    binding.visibility = kVisibilityAll;
+    binding.hasDynamicOffset = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    {
+        binding.multisampled = false;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2D tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    // TODO: Support multisampling
+    GTEST_SKIP() << "Multisampling unimplemented";
+    {
+        binding.multisampled = true;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2DMS tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+}
+
+// Test that texture view dimension matches the shader.
+TEST_F(GetBindGroupLayoutTests, TextureDimension) {
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.type = wgpu::BindingType::SampledTexture;
+    binding.visibility = kVisibilityAll;
+    binding.hasDynamicOffset = false;
+    binding.multisampled = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    {
+        binding.textureDimension = wgpu::TextureViewDimension::e1D;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture1D tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureDimension = wgpu::TextureViewDimension::e2D;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2D tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureDimension = wgpu::TextureViewDimension::e2DArray;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2DArray tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureDimension = wgpu::TextureViewDimension::e3D;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture3D tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureDimension = wgpu::TextureViewDimension::Cube;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform textureCube tex;
+
+        void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureDimension = wgpu::TextureViewDimension::CubeArray;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 0) uniform textureCubeArray tex;
+
+                void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+}
+
+// Test that texture component type matches the shader.
+TEST_F(GetBindGroupLayoutTests, TextureComponentType) {
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.type = wgpu::BindingType::SampledTexture;
+    binding.visibility = kVisibilityAll;
+    binding.hasDynamicOffset = false;
+    binding.multisampled = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    {
+        binding.textureComponentType = wgpu::TextureComponentType::Float;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 0) uniform texture2D tex;
+
+                void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureComponentType = wgpu::TextureComponentType::Sint;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 0) uniform itexture2D tex;
+
+                void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.textureComponentType = wgpu::TextureComponentType::Uint;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 0) uniform utexture2D tex;
+
+                void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+}
+
+// Test that binding= indices match.
+TEST_F(GetBindGroupLayoutTests, BindingIndices) {
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.type = wgpu::BindingType::UniformBuffer;
+    binding.visibility = kVisibilityAll;
+    binding.hasDynamicOffset = false;
+    binding.multisampled = false;
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 1;
+    desc.bindings = &binding;
+
+    {
+        binding.binding = 0;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 0) uniform Buffer {
+                    vec4 pos;
+                };
+
+                void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.binding = 1;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 1) uniform Buffer {
+                    vec4 pos;
+                };
+
+                void main() {})");
+        EXPECT_EQ(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+
+    {
+        binding.binding = 2;
+        wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+                #version 450
+                layout(set = 0, binding = 1) uniform Buffer {
+                    vec4 pos;
+                };
+
+                void main() {})");
+        EXPECT_NE(device.CreateBindGroupLayout(&desc).Get(), pipeline.GetBindGroupLayout(0).Get());
+    }
+}
+
+// Test it is valid to have duplicate bindings in the shaders.
+TEST_F(GetBindGroupLayoutTests, DuplicateBinding) {
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform UniformBuffer1 {
+            vec4 pos1;
+        };
+
+        layout(set = 1, binding = 0) uniform UniformBuffer2 {
+            vec4 pos2;
+        };
+
+        void main() {})");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 1, binding = 0) uniform UniformBuffer3 {
+            vec4 pos3;
+        };
+
+        void main() {})");
+
+    utils::ComboRenderPipelineDescriptor descriptor(device);
+    descriptor.layout = nullptr;
+    descriptor.vertexStage.module = vsModule;
+    descriptor.cFragmentStage.module = fsModule;
+
+    device.CreateRenderPipeline(&descriptor);
+}
+
+// Test it is invalid to have conflicting binding types in the shaders.
+TEST_F(GetBindGroupLayoutTests, ConflictingBindingType) {
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform UniformBuffer {
+            vec4 pos;
+        };
+
+        void main() {})");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 0, binding = 0) buffer StorageBuffer {
+            vec4 pos;
+        };
+
+        void main() {})");
+
+    utils::ComboRenderPipelineDescriptor descriptor(device);
+    descriptor.layout = nullptr;
+    descriptor.vertexStage.module = vsModule;
+    descriptor.cFragmentStage.module = fsModule;
+
+    ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor));
+}
+
+// Test it is invalid to have conflicting binding texture multisampling in the shaders.
+TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureMultisampling) {
+    // TODO: Support multisampling
+    GTEST_SKIP() << "Multisampling unimplemented";
+
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2D tex;
+
+        void main() {})");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2DMS tex;
+
+        void main() {})");
+
+    utils::ComboRenderPipelineDescriptor descriptor(device);
+    descriptor.layout = nullptr;
+    descriptor.vertexStage.module = vsModule;
+    descriptor.cFragmentStage.module = fsModule;
+
+    ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor));
+}
+
+// Test it is invalid to have conflicting binding texture dimension in the shaders.
+TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureDimension) {
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2D tex;
+
+        void main() {})");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture3D tex;
+
+        void main() {})");
+
+    utils::ComboRenderPipelineDescriptor descriptor(device);
+    descriptor.layout = nullptr;
+    descriptor.vertexStage.module = vsModule;
+    descriptor.cFragmentStage.module = fsModule;
+
+    ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor));
+}
+
+// Test it is invalid to have conflicting binding texture component type in the shaders.
+TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureComponentType) {
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform texture2D tex;
+
+        void main() {})");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform utexture2D tex;
+
+        void main() {})");
+
+    utils::ComboRenderPipelineDescriptor descriptor(device);
+    descriptor.layout = nullptr;
+    descriptor.vertexStage.module = vsModule;
+    descriptor.cFragmentStage.module = fsModule;
+
+    ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor));
+}
+
+// Test it is an error to query an out of range bind group layout.
+TEST_F(GetBindGroupLayoutTests, OutOfRangeIndex) {
+    ASSERT_DEVICE_ERROR(RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform Buffer1 {
+            vec4 pos1;
+        };
+        void main() {})")
+                            .GetBindGroupLayout(kMaxBindGroups));
+
+    ASSERT_DEVICE_ERROR(RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform Buffer1 {
+            vec4 pos1;
+        };
+        void main() {})")
+                            .GetBindGroupLayout(kMaxBindGroups + 1));
+}
+
+// Test that unused indices return the empty bind group layout.
+TEST_F(GetBindGroupLayoutTests, UnusedIndex) {
+    wgpu::RenderPipeline pipeline = RenderPipelineFromVertexShader(R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform Buffer1 {
+            vec4 pos1;
+        };
+
+        layout(set = 2, binding = 0) uniform Buffer2 {
+            vec4 pos2;
+        };
+
+        void main() {})");
+
+    wgpu::BindGroupLayoutDescriptor desc = {};
+    desc.bindingCount = 0;
+    desc.bindings = nullptr;
+
+    wgpu::BindGroupLayout emptyBindGroupLayout = device.CreateBindGroupLayout(&desc);
+
+    EXPECT_NE(pipeline.GetBindGroupLayout(0).Get(), emptyBindGroupLayout.Get());  // Used
+    EXPECT_EQ(pipeline.GetBindGroupLayout(1).Get(), emptyBindGroupLayout.Get());  // Not Used.
+    EXPECT_NE(pipeline.GetBindGroupLayout(2).Get(), emptyBindGroupLayout.Get());  // Used.
+    EXPECT_EQ(pipeline.GetBindGroupLayout(3).Get(), emptyBindGroupLayout.Get());  // Not used
+}
+
+// Test that after explicitly creating a pipeline with a pipeline layout, calling
+// GetBindGroupLayout reflects the same bind group layouts.
+TEST_F(GetBindGroupLayoutTests, Reflection) {
+    wgpu::BindGroupLayoutBinding binding = {};
+    binding.binding = 0;
+    binding.type = wgpu::BindingType::UniformBuffer;
+    binding.visibility = wgpu::ShaderStage::Vertex;
+
+    wgpu::BindGroupLayoutDescriptor bglDesc = {};
+    bglDesc.bindingCount = 1;
+    bglDesc.bindings = &binding;
+
+    wgpu::BindGroupLayout bindGroupLayout = device.CreateBindGroupLayout(&bglDesc);
+
+    wgpu::PipelineLayoutDescriptor pipelineLayoutDesc = {};
+    pipelineLayoutDesc.bindGroupLayoutCount = 1;
+    pipelineLayoutDesc.bindGroupLayouts = &bindGroupLayout;
+
+    wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc);
+
+    wgpu::ShaderModule vsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Vertex, R"(
+        #version 450
+        layout(set = 0, binding = 0) uniform Buffer1 {
+            vec4 pos1;
+        };
+
+        void main() {
+        })");
+
+    wgpu::ShaderModule fsModule =
+        utils::CreateShaderModule(device, utils::SingleShaderStage::Fragment, R"(
+        #version 450
+        void main() {
+        })");
+
+    utils::ComboRenderPipelineDescriptor pipelineDesc(device);
+    pipelineDesc.layout = pipelineLayout;
+    pipelineDesc.vertexStage.module = vsModule;
+    pipelineDesc.cFragmentStage.module = fsModule;
+
+    wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&pipelineDesc);
+
+    EXPECT_EQ(pipeline.GetBindGroupLayout(0).Get(), bindGroupLayout.Get());
+
+    {
+        wgpu::BindGroupLayoutDescriptor emptyDesc = {};
+        emptyDesc.bindingCount = 0;
+        emptyDesc.bindings = nullptr;
+
+        wgpu::BindGroupLayout emptyBindGroupLayout = device.CreateBindGroupLayout(&emptyDesc);
+
+        // Check that the rest of the bind group layouts reflect the empty one.
+        EXPECT_EQ(pipeline.GetBindGroupLayout(1).Get(), emptyBindGroupLayout.Get());
+        EXPECT_EQ(pipeline.GetBindGroupLayout(2).Get(), emptyBindGroupLayout.Get());
+        EXPECT_EQ(pipeline.GetBindGroupLayout(3).Get(), emptyBindGroupLayout.Get());
+    }
+}