diff --git a/src/Vulkan/VkDeviceMemory.cpp b/src/Vulkan/VkDeviceMemory.cpp
index e3c8229..20fc6cd 100644
--- a/src/Vulkan/VkDeviceMemory.cpp
+++ b/src/Vulkan/VkDeviceMemory.cpp
@@ -15,102 +15,13 @@
 #include "VkDeviceMemory.hpp"
 #include "VkBuffer.hpp"
 #include "VkDevice.hpp"
-#include "VkDeviceMemoryExternalBase.hpp"
 #include "VkImage.hpp"
 #include "VkStringify.hpp"
 
 #include "VkConfig.hpp"
 
-namespace vk {
-
-// Small class describing a given DeviceMemory::ExternalBase derived class.
-// |typeFlagBit| corresponds to the external memory handle type.
-// |instanceSize| is the size of each class instance in bytes.
-// |instanceInit| is a function pointer used to initialize an instance inplace
-// according to a |pAllocateInfo| parameter.
-class ExternalMemoryTraits
-{
-public:
-	VkExternalMemoryHandleTypeFlagBits typeFlagBit;
-	size_t instanceSize;
-	void (*instanceInit)(void *external, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo);
-};
-
-// Template function that parses a |pAllocateInfo.pNext| chain to verify that
-// it asks for the creation or import of a memory type managed by implementation
-// class T. On success, return true and sets |pTraits| accordingly. Otherwise
-// return false.
-template<typename T>
-static bool parseCreateInfo(const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo,
-                            ExternalMemoryTraits *pTraits)
-{
-	if(T::SupportsAllocateInfo(extendedAllocationInfo))
-	{
-		pTraits->typeFlagBit = T::typeFlagBit;
-		pTraits->instanceSize = sizeof(T);
-		pTraits->instanceInit = [](void *external,
-		                           const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo) {
-			new(external) T(extendedAllocationInfo);
-		};
-		return true;
-	}
-	return false;
-}
-
-// DeviceMemory::ExternalBase implementation that uses host memory.
-// Not really external, but makes everything simpler.
-class DeviceMemoryHostExternalBase : public DeviceMemory::ExternalBase
-{
-public:
-	// Does not support any external memory type at all.
-	static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = (VkExternalMemoryHandleTypeFlagBits)0;
-
-	// Always return true as is used as a fallback in findTraits() below.
-	static bool SupportsAllocateInfo(const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
-	{
-		return true;
-	}
-
-	DeviceMemoryHostExternalBase(const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo) {}
-
-	VkResult allocate(size_t size, void **pBuffer) override
-	{
-		buffer = vk::allocate(size, REQUIRED_MEMORY_ALIGNMENT, DEVICE_MEMORY);
-		if(!buffer)
-		{
-			return VK_ERROR_OUT_OF_DEVICE_MEMORY;
-		}
-
-		*pBuffer = buffer;
-		return VK_SUCCESS;
-	}
-
-	void deallocate(void * /* buffer */, size_t size) override
-	{
-		vk::deallocate(buffer, DEVICE_MEMORY);
-		buffer = nullptr;
-	}
-
-	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override
-	{
-		return typeFlagBit;
-	}
-
-#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
-	uint64_t getMemoryObjectId() const override
-	{
-		return (uint64_t)buffer;
-	}
-#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
-
-private:
-	void *buffer = nullptr;
-};
-
-}  // namespace vk
-
 // Host-allocated memory and host-mapped foreign memory
-class ExternalMemoryHost : public vk::DeviceMemory::ExternalBase
+class ExternalMemoryHost : public vk::DeviceMemory, public vk::ObjectBase<ExternalMemoryHost, VkDeviceMemory>
 {
 public:
 	struct AllocateInfo
@@ -127,7 +38,8 @@
 				if((extendedAllocationInfo.importMemoryHostPointerInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT) &&
 				   (extendedAllocationInfo.importMemoryHostPointerInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT))
 				{
-					UNSUPPORTED("extendedAllocationInfo.importMemoryHostPointerInfo->handleType");
+					UNSUPPORTED("extendedAllocationInfo.importMemoryHostPointerInfo->handleType, %d",
+					            int(extendedAllocationInfo.importMemoryHostPointerInfo->handleType));
 				}
 				hostPointer = extendedAllocationInfo.importMemoryHostPointerInfo->pHostPointer;
 				supported = true;
@@ -143,10 +55,10 @@
 		return info.supported;
 	}
 
-	explicit ExternalMemoryHost(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
-	    : allocateInfo(extendedAllocationInfo)
-	{
-	}
+	explicit ExternalMemoryHost(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice)
+	    : vk::DeviceMemory(pCreateInfo, pDevice)
+	    , allocateInfo(extendedAllocationInfo)
+	{}
 
 	VkResult allocate(size_t size, void **pBuffer) override
 	{
@@ -172,9 +84,9 @@
 
 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 
-// Helper struct to parse the VkMemoryAllocateInfo.pNext chain and
-// extract relevant information related to the handle type supported
-// by this DeviceMemory;:ExternalBase subclass.
+// Helper struct which reads the parsed allocation info and
+// extracts relevant information related to the handle type
+// supported by this DeviceMemory subclass.
 struct OpaqueFdAllocateInfo
 {
 	bool importFd = false;
@@ -183,7 +95,7 @@
 
 	OpaqueFdAllocateInfo() = default;
 
-	// Parse the VkMemoryAllocateInfo.pNext chain to initialize an OpaqueFdAllocateInfo.
+	// Read the parsed allocation info to initialize an OpaqueFdAllocateInfo.
 	OpaqueFdAllocateInfo(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
 	{
 		if(extendedAllocationInfo.importMemoryFdInfo)
@@ -230,69 +142,79 @@
 
 namespace vk {
 
-static void findTraits(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo,
-                       ExternalMemoryTraits *pTraits)
+VkResult DeviceMemory::Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory, Device *device)
+{
+	*pMemory = VK_NULL_HANDLE;
+
+	vk::DeviceMemory::ExtendedAllocationInfo extendedAllocationInfo = {};
+	VkResult result = vk::DeviceMemory::ParseAllocationInfo(pAllocateInfo, &extendedAllocationInfo);
+	if(result != VK_SUCCESS)
+	{
+		return result;
+	}
+
+	result = Allocate(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device);
+	if(result != VK_SUCCESS)
+	{
+		return result;
+	}
+
+	// Make sure the memory allocation is done now so that OOM errors can be checked now
+	return vk::Cast(*pMemory)->allocate();
+}
+
+VkResult DeviceMemory::Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory,
+                                const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *device)
 {
 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
-	if(parseCreateInfo<AHardwareBufferExternalMemory>(extendedAllocationInfo, pTraits))
+	if(AHardwareBufferExternalMemory::SupportsAllocateInfo(extendedAllocationInfo))
 	{
-		return;
+		return AHardwareBufferExternalMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device);
 	}
 #endif
 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
-	if(parseCreateInfo<OpaqueFdExternalMemory>(extendedAllocationInfo, pTraits))
+	if(OpaqueFdExternalMemory::SupportsAllocateInfo(extendedAllocationInfo))
 	{
-		return;
+		return OpaqueFdExternalMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device);
 	}
 #endif
 #if VK_USE_PLATFORM_FUCHSIA
-	if(parseCreateInfo<zircon::VmoExternalMemory>(extendedAllocationInfo, pTraits))
+	if(zircon::VmoExternalMemory::SupportsAllocateInfo(extendedAllocationInfo))
 	{
-		return;
+		return zircon::VmoExternalMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device);
 	}
 #endif
-	if(parseCreateInfo<ExternalMemoryHost>(extendedAllocationInfo, pTraits))
+	if(ExternalMemoryHost::SupportsAllocateInfo(extendedAllocationInfo))
 	{
-		return;
+		return ExternalMemoryHost::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device);
 	}
-	parseCreateInfo<DeviceMemoryHostExternalBase>(extendedAllocationInfo, pTraits);
+
+	return vk::DeviceMemoryInternal::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, device);
 }
 
-DeviceMemory::DeviceMemory(const VkMemoryAllocateInfo *pAllocateInfo, void *mem, const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *pDevice)
+DeviceMemory::DeviceMemory(const VkMemoryAllocateInfo *pAllocateInfo, Device *pDevice)
     : size(pAllocateInfo->allocationSize)
     , memoryTypeIndex(pAllocateInfo->memoryTypeIndex)
     , device(pDevice)
 {
 	ASSERT(size);
-
-	ExternalMemoryTraits traits;
-	findTraits(extendedAllocationInfo, &traits);
-	traits.instanceInit(mem, extendedAllocationInfo);
-	external = reinterpret_cast<ExternalBase *>(mem);
-	external->setDevicePtr(device);
 }
 
 void DeviceMemory::destroy(const VkAllocationCallbacks *pAllocator)
 {
 #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
-	device->emitDeviceMemoryReport(external->isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, external->getMemoryObjectId(), 0 /* size */, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this));
+	device->emitDeviceMemoryReport(isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT, getMemoryObjectId(), 0 /* size */, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this));
 #endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 	if(buffer)
 	{
-		external->deallocate(buffer, size);
+		deallocate(buffer, size);
 		buffer = nullptr;
 	}
-	external->~ExternalBase();  // Call virtual destructor in place.
-	vk::deallocate(external, pAllocator);
 }
 
 size_t DeviceMemory::ComputeRequiredAllocationSize(const VkMemoryAllocateInfo *pAllocateInfo)
 {
-	ExtendedAllocationInfo extendedAllocationInfo;
-	ParseAllocationInfo(pAllocateInfo, &extendedAllocationInfo);
-	ExternalMemoryTraits traits;
-	findTraits(extendedAllocationInfo, &traits);
-	return traits.instanceSize;
+	return 0;
 }
 
 VkResult DeviceMemory::ParseAllocationInfo(const VkMemoryAllocateInfo *pAllocateInfo, DeviceMemory::ExtendedAllocationInfo *extendedAllocationInfo)
@@ -393,12 +315,12 @@
 	VkResult result = VK_SUCCESS;
 	if(!buffer)
 	{
-		result = external->allocate(size, &buffer);
+		result = allocate(size, &buffer);
 	}
 #ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
 	if(result == VK_SUCCESS)
 	{
-		device->emitDeviceMemoryReport(external->isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, external->getMemoryObjectId(), size, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this));
+		device->emitDeviceMemoryReport(isImport() ? VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT : VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT, getMemoryObjectId(), size, VK_OBJECT_TYPE_DEVICE_MEMORY, (uint64_t)(void *)VkDeviceMemory(*this));
 	}
 	else
 	{
@@ -435,7 +357,7 @@
 		// memory, so this check should always pass.
 		return true;
 	}
-	VkExternalMemoryHandleTypeFlagBits handle_type_bit = external->getFlagBit();
+	VkExternalMemoryHandleTypeFlagBits handle_type_bit = getFlagBit();
 	if(!handle_type_bit)
 	{
 		// This device memory is not external and can accommodate
@@ -448,50 +370,47 @@
 	return (supportedHandleTypes & handle_type_bit) != 0;
 }
 
-bool DeviceMemory::hasExternalImageProperties() const
+// Allocate the memory according to |size|. On success return VK_SUCCESS
+// and sets |*pBuffer|.
+VkResult DeviceMemory::allocate(size_t size, void **pBuffer)
 {
-	return external && external->hasExternalImageProperties();
-}
-
-int DeviceMemory::externalImageRowPitchBytes(VkImageAspectFlagBits aspect) const
-{
-	if(external)
+	buffer = vk::allocate(size, REQUIRED_MEMORY_ALIGNMENT, DEVICE_MEMORY);
+	if(!buffer)
 	{
-		return external->externalImageRowPitchBytes(aspect);
+		return VK_ERROR_OUT_OF_DEVICE_MEMORY;
 	}
 
-	// This function should never be called on non-external memory.
-	ASSERT(false);
-	return -1;
+	*pBuffer = buffer;
+	return VK_SUCCESS;
 }
 
-VkDeviceSize DeviceMemory::externalImageMemoryOffset(VkImageAspectFlagBits aspect) const
+// Deallocate previously allocated memory at |buffer|.
+void DeviceMemory::deallocate(void *buffer, size_t size)
 {
-	if(external)
-	{
-		return external->externalImageMemoryOffset(aspect);
-	}
+	vk::deallocate(buffer, DEVICE_MEMORY);
+	buffer = nullptr;
+}
 
-	// This function should never be called on non-external memory.
-	ASSERT(false);
-	return -1;
+// Return the handle type flag bit supported by this implementation.
+// A value of 0 corresponds to non-external memory.
+VkExternalMemoryHandleTypeFlagBits DeviceMemory::getFlagBit() const
+{
+	// Does not support any external memory type at all.
+	static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = (VkExternalMemoryHandleTypeFlagBits)0;
+	return typeFlagBit;
 }
 
 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
 VkResult DeviceMemory::exportFd(int *pFd) const
 {
-	return external->exportFd(pFd);
+	return VK_ERROR_INVALID_EXTERNAL_HANDLE;
 }
 #endif
 
 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
 VkResult DeviceMemory::exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const
 {
-	if(external->getFlagBit() != VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
-	{
-		return VK_ERROR_OUT_OF_HOST_MEMORY;
-	}
-	return static_cast<AHardwareBufferExternalMemory *>(external)->exportAndroidHardwareBuffer(pAhb);
+	return VK_ERROR_OUT_OF_HOST_MEMORY;
 }
 
 VkResult DeviceMemory::GetAndroidHardwareBufferProperties(VkDevice &ahbDevice, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties)
@@ -503,7 +422,7 @@
 #if VK_USE_PLATFORM_FUCHSIA
 VkResult DeviceMemory::exportHandle(zx_handle_t *pHandle) const
 {
-	return external->exportHandle(pHandle);
+	return VK_ERROR_INVALID_EXTERNAL_HANDLE;
 }
 #endif
 
diff --git a/src/Vulkan/VkDeviceMemory.hpp b/src/Vulkan/VkDeviceMemory.hpp
index 098494c..77bf23a 100644
--- a/src/Vulkan/VkDeviceMemory.hpp
+++ b/src/Vulkan/VkDeviceMemory.hpp
@@ -22,11 +22,13 @@
 
 class Device;
 
-class DeviceMemory : public Object<DeviceMemory, VkDeviceMemory>
+class DeviceMemory
 {
 public:
 	struct ExtendedAllocationInfo
 	{
+		VkDeviceSize allocationSize = 0;
+		uint32_t memoryTypeIndex = 0;
 		const VkExportMemoryAllocateInfo *exportMemoryAllocateInfo = nullptr;
 		const VkImportMemoryHostPointerInfoEXT *importMemoryHostPointerInfo = nullptr;
 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
@@ -41,22 +43,37 @@
 #endif
 	};
 
-	DeviceMemory(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *pDevice);
+protected:
+	DeviceMemory(const VkMemoryAllocateInfo *pCreateInfo, Device *pDevice);
+
+public:
+	virtual ~DeviceMemory() {}
+
+	static VkResult Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory, Device *device);
+
+	operator VkDeviceMemory()
+	{
+		return vk::TtoVkT<DeviceMemory, VkDeviceMemory>(this);
+	}
+
+	static inline DeviceMemory *Cast(VkDeviceMemory object)
+	{
+		return vk::VkTtoT<DeviceMemory, VkDeviceMemory>(object);
+	}
 
 	static size_t ComputeRequiredAllocationSize(const VkMemoryAllocateInfo *pCreateInfo);
-	static VkResult ParseAllocationInfo(const VkMemoryAllocateInfo *pAllocateInfo, DeviceMemory::ExtendedAllocationInfo *extendedAllocationInfo);
 
 #if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
-	VkResult exportFd(int *pFd) const;
+	virtual VkResult exportFd(int *pFd) const;
 #endif
 
 #if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
-	VkResult exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const;
+	virtual VkResult exportAndroidHardwareBuffer(struct AHardwareBuffer **pAhb) const;
 	static VkResult GetAndroidHardwareBufferProperties(VkDevice &device, const struct AHardwareBuffer *buffer, VkAndroidHardwareBufferPropertiesANDROID *pProperties);
 #endif
 
 #if VK_USE_PLATFORM_FUCHSIA
-	VkResult exportHandle(zx_handle_t *pHandle) const;
+	virtual VkResult exportHandle(zx_handle_t *pHandle) const;
 #endif
 
 	void destroy(const VkAllocationCallbacks *pAllocator);
@@ -71,21 +88,58 @@
 	bool checkExternalMemoryHandleType(
 	    VkExternalMemoryHandleTypeFlags supportedExternalMemoryHandleType) const;
 
-	// Internal implementation class for external memory. Platform-specific.
-	class ExternalBase;
+	// Some external device memories, such as Android hardware buffers, represent
+	// specific images with requirements.
+	virtual bool hasExternalImageProperties() const { return false; }
+	virtual int externalImageRowPitchBytes(VkImageAspectFlagBits aspect) const { return 0; }
+	virtual VkDeviceSize externalImageMemoryOffset(VkImageAspectFlagBits aspect) const { return 0; }
 
-	bool hasExternalImageProperties() const;
-	int externalImageRowPitchBytes(VkImageAspectFlagBits aspect) const;
-	VkDeviceSize externalImageMemoryOffset(VkImageAspectFlagBits aspect) const;
+protected:
+	// Allocate the memory according to |size|. On success return VK_SUCCESS
+	// and sets |*pBuffer|.
+	virtual VkResult allocate(size_t size, void **pBuffer);
+
+	// Deallocate previously allocated memory at |buffer|.
+	virtual void deallocate(void *buffer, size_t size);
+
+	// Return the handle type flag bit supported by this implementation.
+	// A value of 0 corresponds to non-external memory.
+	virtual VkExternalMemoryHandleTypeFlagBits getFlagBit() const;
+
+	virtual void setDevicePtr(Device *pDevice) {}
+
+#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
+	virtual bool isImport() const
+	{
+		return false;
+	}
+
+	virtual uint64_t getMemoryObjectId() const
+	{
+		return (uint64_t)buffer;
+	}
+#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
 
 private:
+	static VkResult ParseAllocationInfo(const VkMemoryAllocateInfo *pAllocateInfo, DeviceMemory::ExtendedAllocationInfo *extendedAllocationInfo);
+	static VkResult Allocate(const VkAllocationCallbacks *pAllocator, const VkMemoryAllocateInfo *pAllocateInfo, VkDeviceMemory *pMemory,
+	                         const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *device);
+
 	void *buffer = nullptr;
 	VkDeviceSize size = 0;
 	uint32_t memoryTypeIndex = 0;
-	ExternalBase *external = nullptr;
 	Device *device;
 };
 
+// This class represents a DeviceMemory object with no external memory
+class DeviceMemoryInternal : public DeviceMemory, public ObjectBase<DeviceMemoryInternal, VkDeviceMemory>
+{
+public:
+	DeviceMemoryInternal(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, Device *pDevice)
+	    : DeviceMemory(pCreateInfo, pDevice)
+	{}
+};
+
 static inline DeviceMemory *Cast(VkDeviceMemory object)
 {
 	return DeviceMemory::Cast(object);
diff --git a/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp b/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp
index 1eab778..9085814 100644
--- a/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp
+++ b/src/Vulkan/VkDeviceMemoryExternalAndroid.cpp
@@ -191,8 +191,9 @@
 	}
 }
 
-AHardwareBufferExternalMemory::AHardwareBufferExternalMemory(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
-    : allocateInfo(extendedAllocationInfo)
+AHardwareBufferExternalMemory::AHardwareBufferExternalMemory(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice)
+    : vk::DeviceMemory(pCreateInfo, pDevice)
+    , allocateInfo(extendedAllocationInfo)
 {
 }
 
@@ -332,6 +333,11 @@
 
 VkResult AHardwareBufferExternalMemory::exportAndroidHardwareBuffer(AHardwareBuffer **pAhb) const
 {
+	if(getFlagBit() != VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
+	{
+		return VK_ERROR_OUT_OF_HOST_MEMORY;
+	}
+
 	// Each call to vkGetMemoryAndroidHardwareBufferANDROID *must* return an Android hardware buffer with a new reference
 	// acquired in addition to the reference held by the VkDeviceMemory. To avoid leaking resources, the application *must*
 	// release the reference by calling AHardwareBuffer_release when it is no longer needed.
diff --git a/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp b/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp
index aa9f989..b8e5844 100644
--- a/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp
+++ b/src/Vulkan/VkDeviceMemoryExternalAndroid.hpp
@@ -18,17 +18,16 @@
 #include "VkBuffer.hpp"
 #include "VkDevice.hpp"
 #include "VkDeviceMemory.hpp"
-#include "VkDeviceMemoryExternalBase.hpp"
 #include "VkImage.hpp"
 
 #include <vndk/hardware_buffer.h>
 
-class AHardwareBufferExternalMemory : public vk::DeviceMemory::ExternalBase
+class AHardwareBufferExternalMemory : public vk::DeviceMemory, public vk::ObjectBase<AHardwareBufferExternalMemory, VkDeviceMemory>
 {
 public:
-	// Helper struct to used the parse allocation info and extract
-	// relevant information related to the handle type supported
-	// by this DeviceMemory::ExternalBase subclass.
+	// Helper struct which reads the parsed allocation info and
+	// extracts relevant information related to the handle type
+	// supported by this DeviceMemory subclass.
 	struct AllocateInfo
 	{
 		bool importAhb = false;
@@ -39,7 +38,7 @@
 
 		AllocateInfo() = default;
 
-		// Used the parsed allocation info to initialize a AllocateInfo.
+		// Use the parsed allocation info to initialize a AllocateInfo.
 		AllocateInfo(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo);
 	};
 
@@ -51,7 +50,7 @@
 		return info.importAhb || info.exportAhb;
 	}
 
-	explicit AHardwareBufferExternalMemory(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo);
+	explicit AHardwareBufferExternalMemory(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice);
 	~AHardwareBufferExternalMemory();
 
 	VkResult allocate(size_t size, void **pBuffer) override;
@@ -59,7 +58,7 @@
 
 	VkExternalMemoryHandleTypeFlagBits getFlagBit() const override { return typeFlagBit; }
 
-	VkResult exportAndroidHardwareBuffer(AHardwareBuffer **pAhb) const;
+	virtual VkResult exportAndroidHardwareBuffer(AHardwareBuffer **pAhb) const override final;
 
 	void setDevicePtr(vk::Device *pDevice) override { device = pDevice; }
 
diff --git a/src/Vulkan/VkDeviceMemoryExternalBase.hpp b/src/Vulkan/VkDeviceMemoryExternalBase.hpp
deleted file mode 100644
index c8dc313..0000000
--- a/src/Vulkan/VkDeviceMemoryExternalBase.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-// Copyright 2020 The SwiftShader Authors. All Rights Reserved.
-//
-// 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 VK_DEVICE_MEMORY_EXTERNAL_BASE_HPP_
-#define VK_DEVICE_MEMORY_EXTERNAL_BASE_HPP_
-
-#include "VkDeviceMemory.hpp"
-
-namespace vk {
-
-// Base abstract interface for a device memory implementation.
-class DeviceMemory::ExternalBase
-{
-public:
-	virtual ~ExternalBase() = default;
-
-	// Allocate the memory according to |size|. On success return VK_SUCCESS
-	// and sets |*pBuffer|.
-	virtual VkResult allocate(size_t size, void **pBuffer) = 0;
-
-	// Deallocate previously allocated memory at |buffer|.
-	virtual void deallocate(void *buffer, size_t size) = 0;
-
-	// Return the handle type flag bit supported by this implementation.
-	// A value of 0 corresponds to non-external memory.
-	virtual VkExternalMemoryHandleTypeFlagBits getFlagBit() const = 0;
-
-	virtual void setDevicePtr(Device *pDevice) {}
-
-#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
-	virtual VkResult exportFd(int *pFd) const
-	{
-		return VK_ERROR_INVALID_EXTERNAL_HANDLE;
-	}
-#endif
-
-	// Some external device memories, such as Android hardware buffers, represent
-	// specific images with requirements.
-	virtual bool hasExternalImageProperties() const { return false; }
-	virtual int externalImageRowPitchBytes(VkImageAspectFlagBits aspect) const { return 0; }
-	virtual VkDeviceSize externalImageMemoryOffset(VkImageAspectFlagBits aspect) const { return 0; }
-
-#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
-	virtual bool isImport() const
-	{
-		return false;
-	}
-
-	virtual uint64_t getMemoryObjectId() const
-	{
-		return 0;
-	}
-#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
-
-protected:
-	ExternalBase() = default;
-};
-
-}  // namespace vk
-
-#endif  // VK_DEVICE_MEMORY_EXTERNAL_BASE_HPP_
diff --git a/src/Vulkan/VkDeviceMemoryExternalFuchsia.hpp b/src/Vulkan/VkDeviceMemoryExternalFuchsia.hpp
index 5c2c8f3..b7a4cef 100644
--- a/src/Vulkan/VkDeviceMemoryExternalFuchsia.hpp
+++ b/src/Vulkan/VkDeviceMemoryExternalFuchsia.hpp
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "VkDeviceMemory.hpp"
 #include "VkStringify.hpp"
 
 #include "System/Debug.hpp"
@@ -21,12 +22,12 @@
 
 namespace zircon {
 
-class VmoExternalMemory : public vk::DeviceMemory::ExternalBase
+class VmoExternalMemory : public vk::DeviceMemory, public vk::ObjectBase<VmoExternalMemory, VkDeviceMemory>
 {
 public:
-	// Helper struct to parse the VkMemoryAllocateInfo.pNext chain and
-	// extract relevant information related to the handle type supported
-	// by this DeviceMemory::ExternalBase subclass.
+	// Helper struct which reads the parsed allocation info and
+	// extracts relevant information related to the handle type
+	// supported by this DeviceMemory subclass.
 	struct AllocateInfo
 	{
 		bool importHandle = false;
@@ -35,7 +36,7 @@
 
 		AllocateInfo() = default;
 
-		// Used the parsed allocation info to initialize a AllocateInfo.
+		// Use the parsed allocation info to initialize a AllocateInfo.
 		AllocateInfo(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
 		{
 			if(extendedAllocationInfo.importMemoryZirconHandleInfo)
@@ -67,8 +68,9 @@
 		return info.importHandle || info.exportHandle;
 	}
 
-	explicit VmoExternalMemory(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
-	    : allocateInfo(extendedAllocationInfo)
+	explicit VmoExternalMemory(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice)
+	    : vk::DeviceMemory(pCreateInfo, pDevice)
+	    , allocateInfo(extendedAllocationInfo)
 	{
 	}
 
diff --git a/src/Vulkan/VkDeviceMemoryExternalLinux.hpp b/src/Vulkan/VkDeviceMemoryExternalLinux.hpp
index 462dd7c..f4d7f66 100644
--- a/src/Vulkan/VkDeviceMemoryExternalLinux.hpp
+++ b/src/Vulkan/VkDeviceMemoryExternalLinux.hpp
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "VkDeviceMemory.hpp"
+
 #include "System/Debug.hpp"
 #include "System/Linux/MemFd.hpp"
 
@@ -19,7 +21,7 @@
 #include <string.h>
 #include <sys/mman.h>
 
-class OpaqueFdExternalMemory : public vk::DeviceMemory::ExternalBase
+class OpaqueFdExternalMemory : public vk::DeviceMemory, public vk::ObjectBase<OpaqueFdExternalMemory, VkDeviceMemory>
 {
 public:
 	static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
@@ -30,8 +32,9 @@
 		return info.importFd || info.exportFd;
 	}
 
-	explicit OpaqueFdExternalMemory(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
-	    : allocateInfo(extendedAllocationInfo)
+	explicit OpaqueFdExternalMemory(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice)
+	    : vk::DeviceMemory(pCreateInfo, pDevice)
+	    , allocateInfo(extendedAllocationInfo)
 	{
 	}
 
diff --git a/src/Vulkan/VkDeviceMemoryExternalMac.hpp b/src/Vulkan/VkDeviceMemoryExternalMac.hpp
index 4d35810..b68f618 100644
--- a/src/Vulkan/VkDeviceMemoryExternalMac.hpp
+++ b/src/Vulkan/VkDeviceMemoryExternalMac.hpp
@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "VkDeviceMemory.hpp"
+
 #include "System/Debug.hpp"
 
 #include <errno.h>
@@ -55,7 +57,7 @@
 
 // An implementation of OpaqueFdExternalMemory that relies on shm_open().
 // Useful on OS X which do not have Linux memfd regions.
-class OpaqueFdExternalMemory : public vk::DeviceMemory::ExternalBase
+class OpaqueFdExternalMemory : public vk::DeviceMemory, public vk::ObjectBase<OpaqueFdExternalMemory, VkDeviceMemory>
 {
 public:
 	static const VkExternalMemoryHandleTypeFlagBits typeFlagBit = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
@@ -66,8 +68,9 @@
 		return info.importFd || info.exportFd;
 	}
 
-	explicit OpaqueFdExternalMemory(const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo)
-	    : allocateInfo(extendedAllocationInfo)
+	explicit OpaqueFdExternalMemory(const VkMemoryAllocateInfo *pCreateInfo, void *mem, const vk::DeviceMemory::ExtendedAllocationInfo &extendedAllocationInfo, vk::Device *pDevice)
+	    : vk::DeviceMemory(pCreateInfo, pDevice)
+	    , allocateInfo(extendedAllocationInfo)
 	{
 	}
 
diff --git a/src/Vulkan/libVulkan.cpp b/src/Vulkan/libVulkan.cpp
index f2551d6..1dcb45e 100644
--- a/src/Vulkan/libVulkan.cpp
+++ b/src/Vulkan/libVulkan.cpp
@@ -1025,21 +1025,8 @@
 	TRACE("(VkDevice device = %p, const VkMemoryAllocateInfo* pAllocateInfo = %p, const VkAllocationCallbacks* pAllocator = %p, VkDeviceMemory* pMemory = %p)",
 	      device, pAllocateInfo, pAllocator, pMemory);
 
-	vk::DeviceMemory::ExtendedAllocationInfo extendedAllocationInfo = {};
-	VkResult result = vk::DeviceMemory::ParseAllocationInfo(pAllocateInfo, &extendedAllocationInfo);
-	if(result != VK_SUCCESS)
-	{
-		return result;
-	}
+	VkResult result = vk::DeviceMemory::Allocate(pAllocator, pAllocateInfo, pMemory, vk::Cast(device));
 
-	result = vk::DeviceMemory::Create(pAllocator, pAllocateInfo, pMemory, extendedAllocationInfo, vk::Cast(device));
-	if(result != VK_SUCCESS)
-	{
-		return result;
-	}
-
-	// Make sure the memory allocation is done now so that OOM errors can be checked now
-	result = vk::Cast(*pMemory)->allocate();
 	if(result != VK_SUCCESS)
 	{
 		vk::destroy(*pMemory, pAllocator);