diff --git a/BUILD.gn b/BUILD.gn
index 7d33abb..2b53fd3 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -140,6 +140,8 @@
     "src/dawn_native/Error.h",
     "src/dawn_native/ErrorData.cpp",
     "src/dawn_native/ErrorData.h",
+    "src/dawn_native/Extensions.cpp",
+    "src/dawn_native/Extensions.h",
     "src/dawn_native/Fence.cpp",
     "src/dawn_native/Fence.h",
     "src/dawn_native/FenceSignalTracker.cpp",
@@ -605,6 +607,7 @@
     "src/tests/unittests/CommandAllocatorTests.cpp",
     "src/tests/unittests/EnumClassBitmasksTests.cpp",
     "src/tests/unittests/ErrorTests.cpp",
+    "src/tests/unittests/ExtensionTests.cpp",
     "src/tests/unittests/MathTests.cpp",
     "src/tests/unittests/ObjectBaseTests.cpp",
     "src/tests/unittests/PerStageTests.cpp",
diff --git a/src/dawn_native/Adapter.cpp b/src/dawn_native/Adapter.cpp
index 6e51f17..362b540 100644
--- a/src/dawn_native/Adapter.cpp
+++ b/src/dawn_native/Adapter.cpp
@@ -38,6 +38,24 @@
         return mInstance;
     }
 
+    ExtensionsSet AdapterBase::GetSupportedExtensions() const {
+        return mSupportedExtensions;
+    }
+
+    bool AdapterBase::SupportsAllRequestedExtensions(
+        const std::vector<const char*>& requestedExtensions) const {
+        for (const char* extensionStr : requestedExtensions) {
+            Extension extensionEnum = mInstance->ExtensionNameToEnum(extensionStr);
+            if (extensionEnum == Extension::InvalidEnum) {
+                return false;
+            }
+            if (!mSupportedExtensions.IsEnabled(extensionEnum)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     DeviceBase* AdapterBase::CreateDevice(const DeviceDescriptor* descriptor) {
         DeviceBase* result = nullptr;
 
@@ -50,6 +68,12 @@
 
     MaybeError AdapterBase::CreateDeviceInternal(DeviceBase** result,
                                                  const DeviceDescriptor* descriptor) {
+        if (descriptor != nullptr) {
+            if (!SupportsAllRequestedExtensions(descriptor->requiredExtensions)) {
+                return DAWN_VALIDATION_ERROR("One or more requested extensions are not supported");
+            }
+        }
+
         // TODO(cwallez@chromium.org): This will eventually have validation that the device
         // descriptor is valid and is a subset what's allowed on this adapter.
         DAWN_TRY_ASSIGN(*result, CreateDeviceImpl(descriptor));
diff --git a/src/dawn_native/Adapter.h b/src/dawn_native/Adapter.h
index 6c9d3f1..f4cb28a 100644
--- a/src/dawn_native/Adapter.h
+++ b/src/dawn_native/Adapter.h
@@ -18,6 +18,7 @@
 #include "dawn_native/DawnNative.h"
 
 #include "dawn_native/Error.h"
+#include "dawn_native/Extensions.h"
 
 namespace dawn_native {
 
@@ -35,9 +36,14 @@
 
         DeviceBase* CreateDevice(const DeviceDescriptor* descriptor = nullptr);
 
+        ExtensionsSet GetSupportedExtensions() const;
+        bool SupportsAllRequestedExtensions(
+            const std::vector<const char*>& requestedExtensions) const;
+
       protected:
         PCIInfo mPCIInfo = {};
         DeviceType mDeviceType = DeviceType::Unknown;
+        ExtensionsSet mSupportedExtensions;
 
       private:
         virtual ResultOrError<DeviceBase*> CreateDeviceImpl(const DeviceDescriptor* descriptor) = 0;
diff --git a/src/dawn_native/DawnNative.cpp b/src/dawn_native/DawnNative.cpp
index f5909eb..33969aa 100644
--- a/src/dawn_native/DawnNative.cpp
+++ b/src/dawn_native/DawnNative.cpp
@@ -55,6 +55,11 @@
         return mImpl->GetPCIInfo();
     }
 
+    std::vector<const char*> Adapter::GetSupportedExtensions() const {
+        ExtensionsSet supportedExtensionsSet = mImpl->GetSupportedExtensions();
+        return supportedExtensionsSet.GetEnabledExtensionNames();
+    }
+
     Adapter::operator bool() const {
         return mImpl != nullptr;
     }
diff --git a/src/dawn_native/Device.cpp b/src/dawn_native/Device.cpp
index 2306cf0..8fe4800 100644
--- a/src/dawn_native/Device.cpp
+++ b/src/dawn_native/Device.cpp
@@ -66,6 +66,10 @@
         mDynamicUploader = std::make_unique<DynamicUploader>(this);
         SetDefaultToggles();
 
+        if (descriptor != nullptr) {
+            ApplyExtensions(descriptor);
+        }
+
         mFormatTable = BuildFormatTable(this);
     }
 
@@ -505,10 +509,26 @@
         }
     }
 
+    void DeviceBase::ApplyExtensions(const DeviceDescriptor* deviceDescriptor) {
+        ASSERT(deviceDescriptor);
+        ASSERT(GetAdapter()->SupportsAllRequestedExtensions(deviceDescriptor->requiredExtensions));
+
+        mEnabledExtensions = GetAdapter()->GetInstance()->ExtensionNamesToExtensionsSet(
+            deviceDescriptor->requiredExtensions);
+    }
+
+    std::vector<const char*> DeviceBase::GetEnabledExtensions() const {
+        return mEnabledExtensions.GetEnabledExtensionNames();
+    }
+
     std::vector<const char*> DeviceBase::GetTogglesUsed() const {
         return mTogglesSet.GetEnabledToggleNames();
     }
 
+    bool DeviceBase::IsExtensionEnabled(Extension extension) const {
+        return mEnabledExtensions.IsEnabled(extension);
+    }
+
     bool DeviceBase::IsToggleEnabled(Toggle toggle) const {
         return mTogglesSet.IsEnabled(toggle);
     }
diff --git a/src/dawn_native/Device.h b/src/dawn_native/Device.h
index 3c3d6c7..89353b6 100644
--- a/src/dawn_native/Device.h
+++ b/src/dawn_native/Device.h
@@ -17,6 +17,7 @@
 
 #include "common/Serial.h"
 #include "dawn_native/Error.h"
+#include "dawn_native/Extensions.h"
 #include "dawn_native/Format.h"
 #include "dawn_native/Forward.h"
 #include "dawn_native/ObjectBase.h"
@@ -154,7 +155,9 @@
 
         ResultOrError<DynamicUploader*> GetDynamicUploader() const;
 
+        std::vector<const char*> GetEnabledExtensions() const;
         std::vector<const char*> GetTogglesUsed() const;
+        bool IsExtensionEnabled(Extension extension) const;
         bool IsToggleEnabled(Toggle toggle) const;
         size_t GetLazyClearCountForTesting();
         void IncrementLazyClearCountForTesting();
@@ -212,6 +215,8 @@
                                              TextureBase* texture,
                                              const TextureViewDescriptor* descriptor);
 
+        void ApplyExtensions(const DeviceDescriptor* deviceDescriptor);
+
         void ConsumeError(ErrorData* error);
         void SetDefaultToggles();
 
@@ -240,6 +245,8 @@
 
         TogglesSet mTogglesSet;
         size_t mLazyClearCountForTesting = 0;
+
+        ExtensionsSet mEnabledExtensions;
     };
 
 }  // namespace dawn_native
diff --git a/src/dawn_native/Extensions.cpp b/src/dawn_native/Extensions.cpp
new file mode 100644
index 0000000..2de7a85
--- /dev/null
+++ b/src/dawn_native/Extensions.cpp
@@ -0,0 +1,113 @@
+// 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 <array>
+
+#include "common/Assert.h"
+#include "common/BitSetIterator.h"
+#include "dawn_native/Extensions.h"
+
+namespace dawn_native {
+    namespace {
+
+        struct ExtensionEnumAndInfo {
+            Extension extension;
+            ExtensionInfo info;
+        };
+
+        using ExtensionEnumAndInfoList =
+            std::array<ExtensionEnumAndInfo, static_cast<size_t>(Extension::EnumCount)>;
+
+        static constexpr ExtensionEnumAndInfoList kExtensionNameAndInfoList = {
+            {{Extension::TextureCompressionBC,
+              {"texture_compression_bc", "Support Block Compressed (BC) texture formats",
+               "https://bugs.chromium.org/p/dawn/issues/detail?id=42"}}}};
+
+    }  // anonymous namespace
+
+    void ExtensionsSet::EnableExtension(Extension extension) {
+        ASSERT(extension != Extension::InvalidEnum);
+        const size_t extensionIndex = static_cast<size_t>(extension);
+        extensionsBitSet.set(extensionIndex);
+    }
+
+    bool ExtensionsSet::IsEnabled(Extension extension) const {
+        ASSERT(extension != Extension::InvalidEnum);
+        const size_t extensionIndex = static_cast<size_t>(extension);
+        return extensionsBitSet[extensionIndex];
+    }
+
+    std::vector<const char*> ExtensionsSet::GetEnabledExtensionNames() const {
+        std::vector<const char*> enabledExtensionNames(extensionsBitSet.count());
+
+        uint32_t index = 0;
+        for (uint32_t i : IterateBitSet(extensionsBitSet)) {
+            const char* extensionName = ExtensionEnumToName(static_cast<Extension>(i));
+            enabledExtensionNames[index] = extensionName;
+            ++index;
+        }
+        return enabledExtensionNames;
+    }
+
+    const char* ExtensionEnumToName(Extension extension) {
+        ASSERT(extension != Extension::InvalidEnum);
+
+        const ExtensionEnumAndInfo& extensionNameAndInfo =
+            kExtensionNameAndInfoList[static_cast<size_t>(extension)];
+        ASSERT(extensionNameAndInfo.extension == extension);
+        return extensionNameAndInfo.info.name;
+    }
+
+    ExtensionsInfo::ExtensionsInfo() {
+        for (size_t index = 0; index < kExtensionNameAndInfoList.size(); ++index) {
+            const ExtensionEnumAndInfo& extensionNameAndInfo = kExtensionNameAndInfoList[index];
+            ASSERT(index == static_cast<size_t>(extensionNameAndInfo.extension));
+            mExtensionNameToEnumMap[extensionNameAndInfo.info.name] =
+                extensionNameAndInfo.extension;
+        }
+    }
+
+    const ExtensionInfo* ExtensionsInfo::GetExtensionInfo(const char* extensionName) const {
+        ASSERT(extensionName);
+
+        const auto& iter = mExtensionNameToEnumMap.find(extensionName);
+        if (iter != mExtensionNameToEnumMap.cend()) {
+            return &kExtensionNameAndInfoList[static_cast<size_t>(iter->second)].info;
+        }
+        return nullptr;
+    }
+
+    Extension ExtensionsInfo::ExtensionNameToEnum(const char* extensionName) const {
+        ASSERT(extensionName);
+
+        const auto& iter = mExtensionNameToEnumMap.find(extensionName);
+        if (iter != mExtensionNameToEnumMap.cend()) {
+            return kExtensionNameAndInfoList[static_cast<size_t>(iter->second)].extension;
+        }
+        return Extension::InvalidEnum;
+    }
+
+    ExtensionsSet ExtensionsInfo::ExtensionNamesToExtensionsSet(
+        const std::vector<const char*>& requiredExtensions) const {
+        ExtensionsSet extensionsSet;
+
+        for (const char* extensionName : requiredExtensions) {
+            Extension extensionEnum = ExtensionNameToEnum(extensionName);
+            ASSERT(extensionEnum != Extension::InvalidEnum);
+            extensionsSet.EnableExtension(extensionEnum);
+        }
+        return extensionsSet;
+    }
+
+}  // namespace dawn_native
diff --git a/src/dawn_native/Extensions.h b/src/dawn_native/Extensions.h
new file mode 100644
index 0000000..274096f
--- /dev/null
+++ b/src/dawn_native/Extensions.h
@@ -0,0 +1,63 @@
+// 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.
+
+#ifndef DAWNNATIVE_EXTENSIONS_H_
+#define DAWNNATIVE_EXTENSIONS_H_
+
+#include <bitset>
+#include <unordered_map>
+#include <vector>
+
+#include "dawn_native/DawnNative.h"
+
+namespace dawn_native {
+
+    enum class Extension {
+        TextureCompressionBC,
+
+        EnumCount,
+        InvalidEnum = EnumCount,
+        ExtensionMin = TextureCompressionBC,
+    };
+
+    // A wrapper of the bitset to store if an extension is enabled or not. This wrapper provides the
+    // convenience to convert the enums of enum class Extension to the indices of a bitset.
+    struct ExtensionsSet {
+        std::bitset<static_cast<size_t>(Extension::EnumCount)> extensionsBitSet;
+
+        void EnableExtension(Extension extension);
+        bool IsEnabled(Extension extension) const;
+        std::vector<const char*> GetEnabledExtensionNames() const;
+    };
+
+    const char* ExtensionEnumToName(Extension extension);
+
+    class ExtensionsInfo {
+      public:
+        ExtensionsInfo();
+
+        // Used to query the details of an extension. Return nullptr if extensionName is not a valid
+        // name of an extension supported in Dawn
+        const ExtensionInfo* GetExtensionInfo(const char* extensionName) const;
+        Extension ExtensionNameToEnum(const char* extensionName) const;
+        ExtensionsSet ExtensionNamesToExtensionsSet(
+            const std::vector<const char*>& requiredExtensions) const;
+
+      private:
+        std::unordered_map<std::string, Extension> mExtensionNameToEnumMap;
+    };
+
+}  // namespace dawn_native
+
+#endif  // DAWNNATIVE_EXTENSIONS_H_
\ No newline at end of file
diff --git a/src/dawn_native/Format.cpp b/src/dawn_native/Format.cpp
index da2946a..44ae1d8 100644
--- a/src/dawn_native/Format.cpp
+++ b/src/dawn_native/Format.cpp
@@ -13,6 +13,8 @@
 // limitations under the License.
 
 #include "dawn_native/Format.h"
+#include "dawn_native/Device.h"
+#include "dawn_native/Extensions.h"
 
 #include <bitset>
 
@@ -48,7 +50,7 @@
         return static_cast<size_t>(static_cast<uint32_t>(format));
     }
 
-    FormatTable BuildFormatTable(const DeviceBase*) {
+    FormatTable BuildFormatTable(const DeviceBase* device) {
         FormatTable table;
         std::bitset<kKnownFormatCount> formatsSet;
 
@@ -93,12 +95,12 @@
         };
 
         auto AddCompressedFormat = [&AddFormat](dawn::TextureFormat format, uint32_t byteSize,
-                                                uint32_t width, uint32_t height) {
+                                                uint32_t width, uint32_t height, bool isSupported) {
             Format internalFormat;
             internalFormat.format = format;
             internalFormat.isRenderable = false;
             internalFormat.isCompressed = true;
-            internalFormat.isSupported = true;
+            internalFormat.isSupported = isSupported;
             internalFormat.aspect = Format::Aspect::Color;
             internalFormat.blockByteSize = byteSize;
             internalFormat.blockWidth = width;
@@ -168,20 +170,21 @@
         AddDepthStencilFormat(dawn::TextureFormat::Depth24PlusStencil8, Format::Aspect::DepthStencil, 4);
 
         // BC compressed formats
-        AddCompressedFormat(dawn::TextureFormat::BC1RGBAUnorm, 8, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC1RGBAUnormSrgb, 8, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC4RSnorm, 8, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC4RUnorm, 8, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC2RGBAUnorm, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC2RGBAUnormSrgb, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC3RGBAUnorm, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC3RGBAUnormSrgb, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC5RGSnorm, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC5RGUnorm, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC6HRGBSfloat, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC6HRGBUfloat, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC7RGBAUnorm, 16, 4, 4);
-        AddCompressedFormat(dawn::TextureFormat::BC7RGBAUnormSrgb, 16, 4, 4);
+        bool isBCFormatSupported = device->IsExtensionEnabled(Extension::TextureCompressionBC);
+        AddCompressedFormat(dawn::TextureFormat::BC1RGBAUnorm, 8, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC1RGBAUnormSrgb, 8, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC4RSnorm, 8, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC4RUnorm, 8, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC2RGBAUnorm, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC2RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC3RGBAUnorm, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC3RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC5RGSnorm, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC5RGUnorm, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC6HRGBSfloat, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC6HRGBUfloat, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC7RGBAUnorm, 16, 4, 4, isBCFormatSupported);
+        AddCompressedFormat(dawn::TextureFormat::BC7RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
 
         // clang-format on
 
diff --git a/src/dawn_native/Instance.cpp b/src/dawn_native/Instance.cpp
index c106ad17..cc3c9cc 100644
--- a/src/dawn_native/Instance.cpp
+++ b/src/dawn_native/Instance.cpp
@@ -86,6 +86,19 @@
         return mTogglesInfo.ToggleNameToEnum(toggleName);
     }
 
+    const ExtensionInfo* InstanceBase::GetExtensionInfo(const char* extensionName) {
+        return mExtensionsInfo.GetExtensionInfo(extensionName);
+    }
+
+    Extension InstanceBase::ExtensionNameToEnum(const char* extensionName) {
+        return mExtensionsInfo.ExtensionNameToEnum(extensionName);
+    }
+
+    ExtensionsSet InstanceBase::ExtensionNamesToExtensionsSet(
+        const std::vector<const char*>& requiredExtensions) {
+        return mExtensionsInfo.ExtensionNamesToExtensionsSet(requiredExtensions);
+    }
+
     const std::vector<std::unique_ptr<AdapterBase>>& InstanceBase::GetAdapters() const {
         return mAdapters;
     }
diff --git a/src/dawn_native/Instance.h b/src/dawn_native/Instance.h
index a3c5ebb..c0f6da7 100644
--- a/src/dawn_native/Instance.h
+++ b/src/dawn_native/Instance.h
@@ -17,6 +17,7 @@
 
 #include "dawn_native/Adapter.h"
 #include "dawn_native/BackendConnection.h"
+#include "dawn_native/Extensions.h"
 #include "dawn_native/Toggles.h"
 
 #include <array>
@@ -47,9 +48,15 @@
         // Used to query the details of a toggle. Return nullptr if toggleName is not a valid name
         // of a toggle supported in Dawn.
         const ToggleInfo* GetToggleInfo(const char* toggleName);
-
         Toggle ToggleNameToEnum(const char* toggleName);
 
+        // Used to query the details of an extension. Return nullptr if extensionName is not a valid
+        // name of an extension supported in Dawn.
+        const ExtensionInfo* GetExtensionInfo(const char* extensionName);
+        Extension ExtensionNameToEnum(const char* extensionName);
+        ExtensionsSet ExtensionNamesToExtensionsSet(
+            const std::vector<const char*>& requiredExtensions);
+
         void EnableBackendValidation(bool enableBackendValidation);
         bool IsBackendValidationEnabled() const;
 
@@ -74,6 +81,7 @@
         std::vector<std::unique_ptr<BackendConnection>> mBackends;
         std::vector<std::unique_ptr<AdapterBase>> mAdapters;
 
+        ExtensionsInfo mExtensionsInfo;
         TogglesInfo mTogglesInfo;
     };
 
diff --git a/src/dawn_native/d3d12/AdapterD3D12.cpp b/src/dawn_native/d3d12/AdapterD3D12.cpp
index e2c92cc..bb14171 100644
--- a/src/dawn_native/d3d12/AdapterD3D12.cpp
+++ b/src/dawn_native/d3d12/AdapterD3D12.cpp
@@ -84,9 +84,15 @@
             "Error converting");
         mPCIInfo.name = converter.to_bytes(adapterDesc.Description);
 
+        InitializeSupportedExtensions();
+
         return {};
     }
 
+    void Adapter::InitializeSupportedExtensions() {
+        mSupportedExtensions.EnableExtension(Extension::TextureCompressionBC);
+    }
+
     ResultOrError<DeviceBase*> Adapter::CreateDeviceImpl(const DeviceDescriptor* descriptor) {
         std::unique_ptr<Device> device = std::make_unique<Device>(this, descriptor);
         DAWN_TRY(device->Initialize());
diff --git a/src/dawn_native/d3d12/AdapterD3D12.h b/src/dawn_native/d3d12/AdapterD3D12.h
index b5a726b..6c085f0 100644
--- a/src/dawn_native/d3d12/AdapterD3D12.h
+++ b/src/dawn_native/d3d12/AdapterD3D12.h
@@ -38,6 +38,7 @@
 
       private:
         ResultOrError<DeviceBase*> CreateDeviceImpl(const DeviceDescriptor* descriptor) override;
+        void InitializeSupportedExtensions();
 
         ComPtr<IDXGIAdapter1> mHardwareAdapter;
         ComPtr<ID3D12Device> mD3d12Device;
diff --git a/src/dawn_native/metal/BackendMTL.mm b/src/dawn_native/metal/BackendMTL.mm
index e09976d..d8516df 100644
--- a/src/dawn_native/metal/BackendMTL.mm
+++ b/src/dawn_native/metal/BackendMTL.mm
@@ -182,6 +182,11 @@
         ResultOrError<DeviceBase*> CreateDeviceImpl(const DeviceDescriptor* descriptor) override {
             return {new Device(this, mDevice, descriptor)};
         }
+        void InitializeSupportedExtensions() {
+            if ([mDevice supportsFeatureSet:MTLFeatureSet_macOS_GPUFamily1_v1]) {
+                mSupportedExtensions.EnableExtension(Extension::TextureCompressionBC);
+            }
+        }
 
         id<MTLDevice> mDevice = nil;
     };
diff --git a/src/dawn_native/null/DeviceNull.cpp b/src/dawn_native/null/DeviceNull.cpp
index 693cf09..47a3aec 100644
--- a/src/dawn_native/null/DeviceNull.cpp
+++ b/src/dawn_native/null/DeviceNull.cpp
@@ -17,6 +17,7 @@
 #include "dawn_native/BackendConnection.h"
 #include "dawn_native/Commands.h"
 #include "dawn_native/DynamicUploader.h"
+#include "dawn_native/Instance.h"
 
 #include <spirv-cross/spirv_cross.hpp>
 
@@ -24,19 +25,24 @@
 
     // Implementation of pre-Device objects: the null adapter, null backend connection and Connect()
 
-    class Adapter : public AdapterBase {
-      public:
-        Adapter(InstanceBase* instance) : AdapterBase(instance, BackendType::Null) {
-            mPCIInfo.name = "Null backend";
-            mDeviceType = DeviceType::CPU;
-        }
-        virtual ~Adapter() = default;
+    Adapter::Adapter(InstanceBase* instance) : AdapterBase(instance, BackendType::Null) {
+        mPCIInfo.name = "Null backend";
+        mDeviceType = DeviceType::CPU;
 
-      private:
-        ResultOrError<DeviceBase*> CreateDeviceImpl(const DeviceDescriptor* descriptor) override {
-            return {new Device(this, descriptor)};
-        }
-    };
+        // Enable all extensions by default for the convenience of tests.
+        mSupportedExtensions.extensionsBitSet.flip();
+    }
+
+    Adapter::~Adapter() = default;
+
+    // Used for the tests that intend to use an adapter without all extensions enabled.
+    void Adapter::SetSupportedExtensions(const std::vector<const char*>& requiredExtensions) {
+        mSupportedExtensions = GetInstance()->ExtensionNamesToExtensionsSet(requiredExtensions);
+    }
+
+    ResultOrError<DeviceBase*> Adapter::CreateDeviceImpl(const DeviceDescriptor* descriptor) {
+        return {new Device(this, descriptor)};
+    }
 
     class Backend : public BackendConnection {
       public:
diff --git a/src/dawn_native/null/DeviceNull.h b/src/dawn_native/null/DeviceNull.h
index cff06a0..36139a5 100644
--- a/src/dawn_native/null/DeviceNull.h
+++ b/src/dawn_native/null/DeviceNull.h
@@ -15,6 +15,7 @@
 #ifndef DAWNNATIVE_NULL_DEVICENULL_H_
 #define DAWNNATIVE_NULL_DEVICENULL_H_
 
+#include "dawn_native/Adapter.h"
 #include "dawn_native/BindGroup.h"
 #include "dawn_native/BindGroupLayout.h"
 #include "dawn_native/Buffer.h"
@@ -137,6 +138,18 @@
         size_t mMemoryUsage = 0;
     };
 
+    class Adapter : public AdapterBase {
+      public:
+        Adapter(InstanceBase* instance);
+        virtual ~Adapter();
+
+        // Used for the tests that intend to use an adapter without all extensions enabled.
+        void SetSupportedExtensions(const std::vector<const char*>& requiredExtensions);
+
+      private:
+        ResultOrError<DeviceBase*> CreateDeviceImpl(const DeviceDescriptor* descriptor) override;
+    };
+
     class Buffer : public BufferBase {
       public:
         Buffer(Device* device, const BufferDescriptor* descriptor);
diff --git a/src/dawn_native/vulkan/AdapterVk.cpp b/src/dawn_native/vulkan/AdapterVk.cpp
index 614eeda..d86a3bb 100644
--- a/src/dawn_native/vulkan/AdapterVk.cpp
+++ b/src/dawn_native/vulkan/AdapterVk.cpp
@@ -40,6 +40,8 @@
     MaybeError Adapter::Initialize() {
         DAWN_TRY_ASSIGN(mDeviceInfo, GatherDeviceInfo(*this));
 
+        InitializeSupportedExtensions();
+
         mPCIInfo.deviceId = mDeviceInfo.properties.deviceID;
         mPCIInfo.vendorId = mDeviceInfo.properties.vendorID;
         mPCIInfo.name = mDeviceInfo.properties.deviceName;
@@ -62,6 +64,12 @@
         return {};
     }
 
+    void Adapter::InitializeSupportedExtensions() {
+        if (mDeviceInfo.features.textureCompressionBC == VK_TRUE) {
+            mSupportedExtensions.EnableExtension(Extension::TextureCompressionBC);
+        }
+    }
+
     ResultOrError<DeviceBase*> Adapter::CreateDeviceImpl(const DeviceDescriptor* descriptor) {
         std::unique_ptr<Device> device = std::make_unique<Device>(this, descriptor);
         DAWN_TRY(device->Initialize());
diff --git a/src/dawn_native/vulkan/AdapterVk.h b/src/dawn_native/vulkan/AdapterVk.h
index 2d9ed83..a4a3d53 100644
--- a/src/dawn_native/vulkan/AdapterVk.h
+++ b/src/dawn_native/vulkan/AdapterVk.h
@@ -37,6 +37,7 @@
 
       private:
         ResultOrError<DeviceBase*> CreateDeviceImpl(const DeviceDescriptor* descriptor) override;
+        void InitializeSupportedExtensions();
 
         VkPhysicalDevice mPhysicalDevice;
         Backend* mBackend;
diff --git a/src/dawn_native/vulkan/DeviceVk.cpp b/src/dawn_native/vulkan/DeviceVk.cpp
index 7ff3f3f..3d370e3 100644
--- a/src/dawn_native/vulkan/DeviceVk.cpp
+++ b/src/dawn_native/vulkan/DeviceVk.cpp
@@ -344,8 +344,11 @@
         // Always require fragmentStoresAndAtomics because it is required by end2end tests.
         usedKnobs.features.fragmentStoresAndAtomics = VK_TRUE;
 
-        // TODO(jiawei.shao@intel.com): support BC formats as extension
-        usedKnobs.features.textureCompressionBC = VK_TRUE;
+        if (IsExtensionEnabled(Extension::TextureCompressionBC)) {
+            ASSERT(ToBackend(GetAdapter())->GetDeviceInfo().features.textureCompressionBC ==
+                   VK_TRUE);
+            usedKnobs.features.textureCompressionBC = VK_TRUE;
+        }
 
         // Find a universal queue family
         {
diff --git a/src/include/dawn_native/DawnNative.h b/src/include/dawn_native/DawnNative.h
index d90abd0..3382409 100644
--- a/src/include/dawn_native/DawnNative.h
+++ b/src/include/dawn_native/DawnNative.h
@@ -50,6 +50,7 @@
     // An optional parameter of Adapter::CreateDevice() to send additional information when creating
     // a Device. For example, we can use it to enable a workaround, optimization or feature.
     struct DAWN_NATIVE_EXPORT DeviceDescriptor {
+        std::vector<const char*> requiredExtensions;
         std::vector<const char*> forceEnabledToggles;
         std::vector<const char*> forceDisabledToggles;
     };
@@ -63,6 +64,11 @@
         const char* url;
     };
 
+    // A struct to record the information of an extension. An extension is a GPU feature that is not
+    // required to be supported by all Dawn backends and can only be used when it is enabled on the
+    // creation of device.
+    using ExtensionInfo = ToggleInfo;
+
     // An adapter is an object that represent on possibility of creating devices in the system.
     // Most of the time it will represent a combination of a physical GPU and an API. Not that the
     // same GPU can be represented by multiple adapters but on different APIs.
@@ -78,6 +84,7 @@
         BackendType GetBackendType() const;
         DeviceType GetDeviceType() const;
         const PCIInfo& GetPCIInfo() const;
+        std::vector<const char*> GetSupportedExtensions() const;
 
         explicit operator bool() const;
 
diff --git a/src/tests/DawnTest.cpp b/src/tests/DawnTest.cpp
index c8afc2b..ea2070c 100644
--- a/src/tests/DawnTest.cpp
+++ b/src/tests/DawnTest.cpp
@@ -333,9 +333,31 @@
     return gTestEnv->GetVendorIdFilter();
 }
 
+std::vector<const char*> DawnTest::GetRequiredExtensions() {
+    return {};
+}
+
+// This function can only be called after SetUp() because it requires mBackendAdapter to be
+// initialized.
+bool DawnTest::SupportsExtensions(const std::vector<const char*>& extensions) {
+    ASSERT(mBackendAdapter);
+
+    std::set<std::string> supportedExtensionsSet;
+    for (const char* supportedExtensionName : mBackendAdapter.GetSupportedExtensions()) {
+        supportedExtensionsSet.insert(supportedExtensionName);
+    }
+
+    for (const char* extensionName : extensions) {
+        if (supportedExtensionsSet.find(extensionName) == supportedExtensionsSet.end()) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 void DawnTest::SetUp() {
-    // Get an adapter for the backend to use, and create the device.
-    dawn_native::Adapter backendAdapter;
+    // Initialize mBackendAdapter, and create the device.
     const dawn_native::BackendType backendType = GetParam().backendType;
     {
         dawn_native::Instance* instance = gTestEnv->GetInstance();
@@ -345,11 +367,11 @@
             if (adapter.GetBackendType() == backendType) {
                 if (HasVendorIdFilter()) {
                     if (adapter.GetPCIInfo().vendorId == GetVendorIdFilter()) {
-                        backendAdapter = adapter;
+                        mBackendAdapter = adapter;
                         break;
                     }
                 } else {
-                    backendAdapter = adapter;
+                    mBackendAdapter = adapter;
 
                     // On Metal, select the last adapter so that the discrete GPU is tested on
                     // multi-GPU systems.
@@ -363,10 +385,10 @@
             }
         }
 
-        ASSERT(backendAdapter);
+        ASSERT(mBackendAdapter);
     }
 
-    mPCIInfo = backendAdapter.GetPCIInfo();
+    mPCIInfo = mBackendAdapter.GetPCIInfo();
 
     for (const char* forceEnabledWorkaround : GetParam().forceEnabledWorkarounds) {
         ASSERT(gTestEnv->GetInstance()->GetToggleInfo(forceEnabledWorkaround) != nullptr);
@@ -377,7 +399,9 @@
     dawn_native::DeviceDescriptor deviceDescriptor;
     deviceDescriptor.forceEnabledToggles = GetParam().forceEnabledWorkarounds;
     deviceDescriptor.forceDisabledToggles = GetParam().forceDisabledWorkarounds;
-    backendDevice = backendAdapter.CreateDevice(&deviceDescriptor);
+    deviceDescriptor.requiredExtensions = GetRequiredExtensions();
+    backendDevice = mBackendAdapter.CreateDevice(&deviceDescriptor);
+    ASSERT_NE(nullptr, backendDevice);
 
     backendProcs = dawn_native::GetProcs();
 
diff --git a/src/tests/DawnTest.h b/src/tests/DawnTest.h
index 3aa685e..bbde83e 100644
--- a/src/tests/DawnTest.h
+++ b/src/tests/DawnTest.h
@@ -206,6 +206,14 @@
 
     void SwapBuffersForCapture();
 
+    bool SupportsExtensions(const std::vector<const char*>& extensions);
+
+    // Called in SetUp() to get the extensions required to be enabled in the tests. The tests must
+    // check if the required extensions are supported by the adapter in this function and guarantee
+    // the returned extensions are all supported by the adapter. The tests may provide different
+    // code path to handle the situation when not all extensions are supported.
+    virtual std::vector<const char*> GetRequiredExtensions();
+
   private:
     // Things used to set up testing through the Wire.
     std::unique_ptr<dawn_wire::WireServer> mWireServer;
@@ -263,6 +271,8 @@
     std::unique_ptr<utils::BackendBinding> mBinding;
 
     dawn_native::PCIInfo mPCIInfo;
+
+    dawn_native::Adapter mBackendAdapter;
 };
 
 // Instantiate the test once for each backend provided after the first argument. Use it like this:
diff --git a/src/tests/end2end/CompressedTextureFormatTests.cpp b/src/tests/end2end/CompressedTextureFormatTests.cpp
index 157ae9e..c19b6ad 100644
--- a/src/tests/end2end/CompressedTextureFormatTests.cpp
+++ b/src/tests/end2end/CompressedTextureFormatTests.cpp
@@ -67,9 +67,24 @@
                      {1, dawn::ShaderStageBit::Fragment, dawn::BindingType::SampledTexture}});
     }
 
+    std::vector<const char*> GetRequiredExtensions() override {
+        mIsBCFormatSupported = SupportsExtensions({"texture_compression_bc"});
+        if (!mIsBCFormatSupported) {
+            return {};
+        }
+
+        return {"texture_compression_bc"};
+    }
+
+    bool IsBCFormatSupported() const {
+        return mIsBCFormatSupported;
+    }
+
     // Copy the compressed texture data into the destination texture as is specified in copyConfig.
     void CopyDataIntoCompressedTexture(dawn::Texture bcCompressedTexture,
                                        const CopyConfig& copyConfig) {
+        ASSERT(IsBCFormatSupported());
+
         // Compute the upload buffer size with rowPitchAlignment and the copy region.
         uint32_t actualWidthAtLevel = copyConfig.textureWidthLevel0 >> copyConfig.baseMipmapLevel;
         uint32_t actualHeightAtLevel = copyConfig.textureHeightLevel0 >> copyConfig.baseMipmapLevel;
@@ -121,6 +136,8 @@
                                            dawn::TextureFormat bcFormat,
                                            uint32_t baseArrayLayer = 0,
                                            uint32_t baseMipLevel = 0) {
+        ASSERT(IsBCFormatSupported());
+
         dawn::SamplerDescriptor samplerDesc = utils::GetDefaultSamplerDescriptor();
         samplerDesc.minFilter = dawn::FilterMode::Nearest;
         samplerDesc.magFilter = dawn::FilterMode::Nearest;
@@ -140,6 +157,8 @@
 
     // Create a render pipeline for sampling from a BC texture and rendering into the render target.
     dawn::RenderPipeline CreateRenderPipelineForTest() {
+        ASSERT(IsBCFormatSupported());
+
         dawn::PipelineLayout pipelineLayout =
             utils::MakeBasicPipelineLayout(device, &mBindGroupLayout);
 
@@ -183,6 +202,8 @@
                                             const dawn::Origin3D& expectedOrigin,
                                             const dawn::Extent3D& expectedExtent,
                                             const std::vector<RGBA8>& expected) {
+        ASSERT(IsBCFormatSupported());
+
         ASSERT(expected.size() == renderTargetSize.width * renderTargetSize.height);
         utils::BasicRenderPass renderPass =
             utils::CreateBasicRenderPass(device, renderTargetSize.width, renderTargetSize.height);
@@ -207,6 +228,8 @@
     // Run the tests that copies pre-prepared BC format data into a BC texture and verifies if we
     // can render correctly with the pixel values sampled from the BC texture.
     void TestCopyRegionIntoBCFormatTextures(const CopyConfig& config) {
+        ASSERT(IsBCFormatSupported());
+
         dawn::Texture bcTexture = Create2DTexture(device, config.format, config.textureWidthLevel0,
                                                   config.textureHeightLevel0,
                                                   config.arrayLayerCount, config.mipmapLevelCount);
@@ -416,10 +439,14 @@
     static constexpr uint32_t kBCBlockHeightInTexels = 4;
 
     dawn::BindGroupLayout mBindGroupLayout;
+
+    bool mIsBCFormatSupported = false;
 };
 
 // Test copying into the whole BC texture with 2x2 blocks and sampling from it.
 TEST_P(CompressedTextureBCFormatTest, Basic) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureWidthLevel0 = 8;
     config.textureHeightLevel0 = 8;
@@ -433,6 +460,8 @@
 
 // Test copying into a sub-region of a texture with BC formats works correctly.
 TEST_P(CompressedTextureBCFormatTest, CopyIntoSubRegion) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureHeightLevel0 = 8;
     config.textureWidthLevel0 = 8;
@@ -451,6 +480,8 @@
 
 // Test using rowPitch == 0 in the copies with BC formats works correctly.
 TEST_P(CompressedTextureBCFormatTest, CopyWithZeroRowPitch) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureHeightLevel0 = 8;
 
@@ -468,6 +499,8 @@
 
 // Test copying into the non-zero layer of a 2D array texture with BC formats works correctly.
 TEST_P(CompressedTextureBCFormatTest, CopyIntoNonZeroArrayLayer) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureHeightLevel0 = 8;
     config.textureWidthLevel0 = 8;
@@ -486,6 +519,8 @@
 
 // Test copying into a non-zero mipmap level of a texture with BC texture formats.
 TEST_P(CompressedTextureBCFormatTest, CopyBufferIntoNonZeroMipmapLevel) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureHeightLevel0 = 60;
     config.textureWidthLevel0 = 60;
@@ -517,6 +552,8 @@
 
 // Test texture-to-texture whole-size copies with BC formats.
 TEST_P(CompressedTextureBCFormatTest, CopyWholeTextureSubResourceIntoNonZeroMipmapLevel) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     // TODO(cwallez@chromium.org): This consistently fails on with the 12th pixel being opaque black
     // instead of opaque red on Win10 FYI Release (NVIDIA GeForce GTX 1660). See
     // https://bugs.chromium.org/p/chromium/issues/detail?id=981393
@@ -576,6 +613,8 @@
 
 // Test BC format texture-to-texture partial copies.
 TEST_P(CompressedTextureBCFormatTest, CopyPartofTextureSubResourceIntoNonZeroMipmapLevel) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     // TODO(jiawei.shao@intel.com): add workaround on the T2T copies where Extent3D fits in one
     // subresource and does not fit in another one on Vulkan. Currently this test causes an error if
     // Vulkan validation layer is enabled.
@@ -652,6 +691,8 @@
 // Test the special case of the B2T copies on the D3D12 backend that the buffer offset and texture
 // extent exactly fit the RowPitch.
 TEST_P(CompressedTextureBCFormatTest, BufferOffsetAndExtentFitRowPitch) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureWidthLevel0 = 8;
     config.textureHeightLevel0 = 8;
@@ -677,6 +718,8 @@
 // backend the texelOffset.y will be greater than 0 after calcuting the texelOffset in the function
 // ComputeTexelOffsets().
 TEST_P(CompressedTextureBCFormatTest, BufferOffsetExceedsSlicePitch) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureWidthLevel0 = 8;
     config.textureHeightLevel0 = 8;
@@ -703,6 +746,8 @@
 // Test the special case of the B2T copies on the D3D12 backend that the buffer offset and texture
 // extent exceed the RowPitch. On D3D12 backend two copies are required for this case.
 TEST_P(CompressedTextureBCFormatTest, CopyWithBufferOffsetAndExtentExceedRowPitch) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureWidthLevel0 = 8;
     config.textureHeightLevel0 = 8;
@@ -729,6 +774,8 @@
 // rowPitch. On D3D12 backend the texelOffset.z will be greater than 0 after calcuting the
 // texelOffset in the function ComputeTexelOffsets().
 TEST_P(CompressedTextureBCFormatTest, RowPitchEqualToSlicePitch) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureWidthLevel0 = 8;
     config.textureHeightLevel0 = kBCBlockHeightInTexels;
@@ -755,6 +802,8 @@
 // copyExtent.depth) on Metal backends. As copyExtent.depth can only be 1 for BC formats, on Metal
 // backend we will use two copies to implement such copy.
 TEST_P(CompressedTextureBCFormatTest, LargeImageHeight) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureWidthLevel0 = 8;
     config.textureHeightLevel0 = 8;
@@ -771,6 +820,8 @@
 // Test the workaround in the B2T copies when (bufferSize - bufferOffset < bytesPerImage *
 // copyExtent.depth) and copyExtent needs to be clamped.
 TEST_P(CompressedTextureBCFormatTest, LargeImageHeightAndClampedCopyExtent) {
+    DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
+
     CopyConfig config;
     config.textureHeightLevel0 = 56;
     config.textureWidthLevel0 = 56;
@@ -803,4 +854,8 @@
 }
 
 // TODO(jiawei.shao@intel.com): support BC formats on OpenGL backend
-DAWN_INSTANTIATE_TEST(CompressedTextureBCFormatTest, D3D12Backend, MetalBackend, VulkanBackend);
+DAWN_INSTANTIATE_TEST(CompressedTextureBCFormatTest,
+                      D3D12Backend,
+                      MetalBackend,
+                      OpenGLBackend,
+                      VulkanBackend);
diff --git a/src/tests/unittests/ExtensionTests.cpp b/src/tests/unittests/ExtensionTests.cpp
new file mode 100644
index 0000000..cef2752
--- /dev/null
+++ b/src/tests/unittests/ExtensionTests.cpp
@@ -0,0 +1,78 @@
+// 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 <gtest/gtest.h>
+
+#include "dawn_native/Extensions.h"
+#include "dawn_native/Instance.h"
+#include "dawn_native/null/DeviceNull.h"
+
+class ExtensionTests : public testing::Test {
+  public:
+    ExtensionTests() : testing::Test(), mInstanceBase(), mAdapterBase(&mInstanceBase) {
+    }
+
+    std::vector<const char*> GetAllExtensionNames() {
+        std::vector<const char*> allExtensionNames(kTotalExtensionsCount);
+        for (size_t i = 0; i < kTotalExtensionsCount; ++i) {
+            allExtensionNames[i] = ExtensionEnumToName(static_cast<dawn_native::Extension>(i));
+        }
+        return allExtensionNames;
+    }
+
+    static constexpr size_t kTotalExtensionsCount =
+        static_cast<size_t>(dawn_native::Extension::EnumCount);
+
+  protected:
+    dawn_native::InstanceBase mInstanceBase;
+    dawn_native::null::Adapter mAdapterBase;
+};
+
+// Test the creation of a device will fail if the requested extension is not supported on the
+// Adapter.
+TEST_F(ExtensionTests, AdapterWithRequiredExtensionDisabled) {
+    const std::vector<const char*> kAllExtensionNames = GetAllExtensionNames();
+    for (size_t i = 0; i < kTotalExtensionsCount; ++i) {
+        dawn_native::Extension notSupportedExtension = static_cast<dawn_native::Extension>(i);
+
+        std::vector<const char*> extensionNamesWithoutOne = kAllExtensionNames;
+        extensionNamesWithoutOne.erase(extensionNamesWithoutOne.begin() + i);
+
+        mAdapterBase.SetSupportedExtensions(extensionNamesWithoutOne);
+        dawn_native::Adapter adapterWithoutExtension(&mAdapterBase);
+
+        dawn_native::DeviceDescriptor deviceDescriptor;
+        const char* extensionName = ExtensionEnumToName(notSupportedExtension);
+        deviceDescriptor.requiredExtensions = std::vector<const char*>(1, extensionName);
+        DawnDevice deviceWithExtension = adapterWithoutExtension.CreateDevice(&deviceDescriptor);
+        ASSERT_EQ(nullptr, deviceWithExtension);
+    }
+}
+
+// Test Device.GetEnabledExtensions() can return the names of the enabled extensions correctly.
+TEST_F(ExtensionTests, GetEnabledExtensions) {
+    dawn_native::Adapter adapter(&mAdapterBase);
+    for (size_t i = 0; i < kTotalExtensionsCount; ++i) {
+        dawn_native::Extension extension = static_cast<dawn_native::Extension>(i);
+        const char* extensionName = ExtensionEnumToName(extension);
+
+        dawn_native::DeviceDescriptor deviceDescriptor;
+        deviceDescriptor.requiredExtensions = {extensionName};
+        dawn_native::DeviceBase* deviceBase =
+            reinterpret_cast<dawn_native::DeviceBase*>(adapter.CreateDevice(&deviceDescriptor));
+        std::vector<const char*> enabledExtensions = deviceBase->GetEnabledExtensions();
+        ASSERT_EQ(1u, enabledExtensions.size());
+        ASSERT_EQ(0, std::strcmp(extensionName, enabledExtensions[0]));
+    }
+}
diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
index b2ca88e..0ed925c 100644
--- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -1155,6 +1155,11 @@
 }
 
 class CopyCommandTest_CompressedTextureFormats : public CopyCommandTest {
+  public:
+    CopyCommandTest_CompressedTextureFormats() : CopyCommandTest() {
+        device = CreateDeviceFromAdapter(adapter, {"texture_compression_bc"});
+    }
+
   protected:
     dawn::Texture Create2DTexture(dawn::TextureFormat format,
                                   uint32_t mipmapLevels = 1,
diff --git a/src/tests/unittests/validation/TextureValidationTests.cpp b/src/tests/unittests/validation/TextureValidationTests.cpp
index bef154e..75874f8 100644
--- a/src/tests/unittests/validation/TextureValidationTests.cpp
+++ b/src/tests/unittests/validation/TextureValidationTests.cpp
@@ -250,10 +250,14 @@
     ASSERT_DEVICE_ERROR(device.CreateTexture(&descriptor));
 }
 
-// TODO(jiawei.shao@intel.com): use compressed texture formats as extensions.
 // TODO(jiawei.shao@intel.com): add tests to verify we cannot create 1D or 3D textures with
 // compressed texture formats.
 class CompressedTextureFormatsValidationTests : public TextureValidationTest {
+  public:
+    CompressedTextureFormatsValidationTests() : TextureValidationTest() {
+        device = CreateDeviceFromAdapter(adapter, {"texture_compression_bc"});
+    }
+
   protected:
     dawn::TextureDescriptor CreateDefaultTextureDescriptor() {
         dawn::TextureDescriptor descriptor =
@@ -309,6 +313,18 @@
     }
 }
 
+// Test the creation of a texture with BC format will fail when the extension textureCompressionBC
+// is not enabled.
+TEST_F(CompressedTextureFormatsValidationTests, UseBCFormatWithoutEnablingExtension) {
+    const std::vector<const char*> kEmptyVector;
+    dawn::Device deviceWithoutExtension = CreateDeviceFromAdapter(adapter, kEmptyVector);
+    for (dawn::TextureFormat format : kBCFormats) {
+        dawn::TextureDescriptor descriptor = CreateDefaultTextureDescriptor();
+        descriptor.format = format;
+        ASSERT_DEVICE_ERROR(deviceWithoutExtension.CreateTexture(&descriptor));
+    }
+}
+
 // Test the validation of texture usages when creating textures in compressed texture formats.
 TEST_F(CompressedTextureFormatsValidationTests, TextureUsage) {
     // Test that only CopySrc, CopyDst and Sampled are accepted as the texture usage of the
diff --git a/src/tests/unittests/validation/ValidationTest.cpp b/src/tests/unittests/validation/ValidationTest.cpp
index 09f6e87..af02a0b 100644
--- a/src/tests/unittests/validation/ValidationTest.cpp
+++ b/src/tests/unittests/validation/ValidationTest.cpp
@@ -35,12 +35,29 @@
     }
 
     ASSERT(foundNullAdapter);
-    device = dawn::Device::Acquire(adapter.CreateDevice());
 
     DawnProcTable procs = dawn_native::GetProcs();
     dawnSetProcs(&procs);
 
-    device.SetErrorCallback(ValidationTest::OnDeviceError, this);
+    device = CreateDeviceFromAdapter(adapter, std::vector<const char*>());
+}
+
+dawn::Device ValidationTest::CreateDeviceFromAdapter(
+    dawn_native::Adapter adapterToTest,
+    const std::vector<const char*>& requiredExtensions) {
+    dawn::Device deviceToTest;
+
+    // Always keep the code path to test creating a device without a device descriptor.
+    if (requiredExtensions.empty()) {
+        deviceToTest = dawn::Device::Acquire(adapterToTest.CreateDevice());
+    } else {
+        dawn_native::DeviceDescriptor descriptor;
+        descriptor.requiredExtensions = requiredExtensions;
+        deviceToTest = dawn::Device::Acquire(adapterToTest.CreateDevice(&descriptor));
+    }
+
+    deviceToTest.SetErrorCallback(ValidationTest::OnDeviceError, this);
+    return deviceToTest;
 }
 
 ValidationTest::~ValidationTest() {
diff --git a/src/tests/unittests/validation/ValidationTest.h b/src/tests/unittests/validation/ValidationTest.h
index 92aef16..5deb019 100644
--- a/src/tests/unittests/validation/ValidationTest.h
+++ b/src/tests/unittests/validation/ValidationTest.h
@@ -29,6 +29,9 @@
     ValidationTest();
     ~ValidationTest();
 
+    dawn::Device CreateDeviceFromAdapter(dawn_native::Adapter adapter,
+                                         const std::vector<const char*>& requiredExtensions);
+
     void TearDown() override;
 
     void StartExpectDeviceError();