Refactor EGLDeviceEXT to remove renderer dependency

src/libANGLE/Device.cpp

@@ -45,7 +45,10 @@ Device::~Device()
 
 Error Device::getDevice(EGLAttrib *value)
 {
-    return getImplementation()->getDevice(value);
+    void *nativeDevice = nullptr;
+    egl::Error error = getImplementation()->getDevice(&nativeDevice);
+    *value = reinterpret_cast<EGLAttrib>(nativeDevice);
+    return error;
 }
 
 EGLint Device::getType()

src/libANGLE/renderer/DeviceImpl.h

@@ -26,7 +26,7 @@ class DeviceImpl : angle::NonCopyable
     DeviceImpl();
     virtual ~DeviceImpl();
 
-    virtual egl::Error getDevice(EGLAttrib *value) = 0;
+    virtual egl::Error getDevice(void **outValue) = 0;
     virtual EGLint getType() = 0;
     virtual void generateExtensions(egl::DeviceExtensions *outExtensions) const = 0;
 };

src/libANGLE/renderer/d3d/DeviceD3D.cpp

@@ -17,33 +17,19 @@
 namespace rx
 {
 
-DeviceD3D::DeviceD3D(rx::RendererD3D *renderer)
-    : mRenderer(renderer)
+DeviceD3D::DeviceD3D(void *device, EGLint deviceType) : mDevice(device), mDeviceType(deviceType)
 {
 }
 
-egl::Error DeviceD3D::getDevice(EGLAttrib *value)
+egl::Error DeviceD3D::getDevice(void **outValue)
 {
-    *value = reinterpret_cast<EGLAttrib>(mRenderer->getD3DDevice());
-    if (*value == 0)
-    {
-        return egl::Error(EGL_BAD_DEVICE_EXT);
-    }
+    *outValue = mDevice;
     return egl::Error(EGL_SUCCESS);
 }
 
 EGLint DeviceD3D::getType()
 {
-    switch (mRenderer->getRendererClass())
-    {
-      case RENDERER_D3D11:
-        return EGL_D3D11_DEVICE_ANGLE;
-      case RENDERER_D3D9:
-        return EGL_D3D9_DEVICE_ANGLE;
-      default:
-        UNREACHABLE();
-        return EGL_NONE;
-    }
+    return mDeviceType;
 }
 
 void DeviceD3D::generateExtensions(egl::DeviceExtensions *outExtensions) const

src/libANGLE/renderer/d3d/DeviceD3D.h

@@ -18,14 +18,15 @@ namespace rx
 class DeviceD3D : public DeviceImpl
 {
   public:
-    DeviceD3D(RendererD3D *renderer);
+    DeviceD3D(void *device, EGLint deviceType);
 
-    egl::Error getDevice(EGLAttrib *value) override;
+    egl::Error getDevice(void **outValue) override;
     EGLint getType() override;
     void generateExtensions(egl::DeviceExtensions *outExtensions) const override;
 
   private:
-    RendererD3D *mRenderer;
+    void *mDevice;
+    EGLint mDeviceType;
 };
 
 }

src/libANGLE/renderer/d3d/DisplayD3D.cpp

@@ -141,9 +141,7 @@ egl::Error CreateRendererD3D(egl::Display *display, RendererD3D **outRenderer)
     return result;
 }
 
-DisplayD3D::DisplayD3D()
-    : mRenderer(nullptr),
-      mDevice(nullptr)
+DisplayD3D::DisplayD3D() : mRenderer(nullptr)
 {
 }
 
@@ -209,9 +207,7 @@ ImageImpl *DisplayD3D::createImage(EGLenum target,
 
 egl::Error DisplayD3D::getDevice(DeviceImpl **device)
 {
-    *device = reinterpret_cast<DeviceImpl*>(mDevice);
-    ASSERT(*device != nullptr);
-    return egl::Error(EGL_SUCCESS);
+    return mRenderer->getEGLDevice(device);
 }
 
 egl::Error DisplayD3D::createContext(const egl::Config *config, const gl::Context *shareContext, const egl::AttributeMap &attribs,
@@ -242,15 +238,11 @@ egl::Error DisplayD3D::initialize(egl::Display *display)
         return error;
     }
 
-    ASSERT(mDevice == nullptr);
-    mDevice = new DeviceD3D(mRenderer);
-
     return egl::Error(EGL_SUCCESS);
 }
 
 void DisplayD3D::terminate()
 {
-    SafeDelete(mDevice);
     SafeDelete(mRenderer);
 }
 

src/libANGLE/renderer/d3d/DisplayD3D.h

@@ -65,8 +65,6 @@ class DisplayD3D : public DisplayImpl
     egl::Display *mDisplay;
 
     rx::RendererD3D *mRenderer;
-
-    DeviceImpl *mDevice;
 };
 
 }

src/libANGLE/renderer/d3d/RendererD3D.cpp

@@ -20,6 +20,7 @@
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/d3d/BufferD3D.h"
 #include "libANGLE/renderer/d3d/CompilerD3D.h"
+#include "libANGLE/renderer/d3d/DeviceD3D.h"
 #include "libANGLE/renderer/d3d/DisplayD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -44,7 +45,8 @@ RendererD3D::RendererD3D(egl::Display *display)
       mDeviceLost(false),
       mAnnotator(nullptr),
       mScratchMemoryBufferResetCounter(0),
-      mWorkaroundsInitialized(false)
+      mWorkaroundsInitialized(false),
+      mEGLDevice(nullptr)
 {
 }
 
@@ -55,6 +57,8 @@ RendererD3D::~RendererD3D()
 
 void RendererD3D::cleanup()
 {
+    SafeDelete(mEGLDevice);
+
     mScratchMemoryBuffer.resize(0);
     for (auto &incompleteTexture : mIncompleteTextures)
     {
@@ -733,4 +737,16 @@ gl::DebugAnnotator *RendererD3D::getAnnotator()
     return mAnnotator;
 }
 
+egl::Error RendererD3D::getEGLDevice(DeviceImpl **device)
+{
+    egl::Error error = initializeEGLDevice(&mEGLDevice);
+    if (error.isError())
+    {
+        return error;
+    }
+
+    *device = static_cast<DeviceImpl *>(mEGLDevice);
+
+    return egl::Error(EGL_SUCCESS);
+}
 }

src/libANGLE/renderer/d3d/RendererD3D.h

@@ -12,6 +12,7 @@
 #include "common/debug.h"
 #include "common/MemoryBuffer.h"
 #include "libANGLE/Data.h"
+#include "libANGLE/Device.h"
 #include "libANGLE/formatutils.h"
 #include "libANGLE/renderer/Renderer.h"
 #include "libANGLE/renderer/d3d/VertexDataManager.h"
@@ -29,15 +30,16 @@ class ConfigSet;
 
 namespace gl
 {
+class DebugAnnotator;
 class InfoLog;
-struct LinkedVarying;
 class Texture;
-class DebugAnnotator;
+struct LinkedVarying;
 }
 
 namespace rx
 {
 struct D3DUniform;
+class DeviceD3D;
 class EGLImageD3D;
 class ImageD3D;
 class IndexBuffer;
@@ -247,6 +249,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
     // In D3D11, faster than calling setTexture a jillion times
     virtual gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) = 0;
 
+    egl::Error getEGLDevice(DeviceImpl **device);
+
   protected:
     virtual bool getLUID(LUID *adapterLuid) const = 0;
     virtual gl::Error applyShadersImpl(const gl::Data &data, GLenum drawMode) = 0;
@@ -255,6 +259,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     virtual void createAnnotator() = 0;
 
+    virtual egl::Error initializeEGLDevice(DeviceD3D **outDevice) = 0;
+
     // dirtyPointer is a special value that will make the comparison with any valid pointer fail and force the renderer to re-apply the state.
     static const uintptr_t DirtyPointer;
 
@@ -322,6 +328,8 @@ class RendererD3D : public Renderer, public BufferFactoryD3D
 
     mutable bool mWorkaroundsInitialized;
     mutable WorkaroundsD3D mWorkarounds;
+
+    DeviceD3D *mEGLDevice;
 };
 
 struct dx_VertexConstants

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -21,6 +21,7 @@
 #include "libANGLE/histogram_macros.h"
 #include "libANGLE/Program.h"
 #include "libANGLE/renderer/d3d/CompilerD3D.h"
+#include "libANGLE/renderer/d3d/DeviceD3D.h"
 #include "libANGLE/renderer/d3d/d3d11/Blit11.h"
 #include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
 #include "libANGLE/renderer/d3d/d3d11/Clear11.h"
@@ -4086,4 +4087,14 @@ gl::Error Renderer11::clearTextures(gl::SamplerType samplerType, size_t rangeSta
     return gl::Error(GL_NO_ERROR);
 }
 
+egl::Error Renderer11::initializeEGLDevice(DeviceD3D **outDevice)
+{
+    if (*outDevice == nullptr)
+    {
+        ASSERT(mDevice != nullptr);
+        *outDevice = new DeviceD3D(reinterpret_cast<void *>(mDevice), EGL_D3D11_DEVICE_ANGLE);
+    }
+
+    return egl::Error(EGL_SUCCESS);
+}
 }

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -277,6 +277,8 @@ class Renderer11 : public RendererD3D
     gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override;
     gl::Error applyShadersImpl(const gl::Data &data, GLenum drawMode) override;
 
+    egl::Error initializeEGLDevice(DeviceD3D **outDevice) override;
+
   private:
     gl::Error drawArraysImpl(const gl::Data &data,
                              GLenum mode,

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -21,6 +21,7 @@
 #include "libANGLE/angletypes.h"
 #include "libANGLE/features.h"
 #include "libANGLE/formatutils.h"
+#include "libANGLE/renderer/d3d/DeviceD3D.h"
 #include "libANGLE/renderer/d3d/FramebufferD3D.h"
 #include "libANGLE/renderer/d3d/IndexDataManager.h"
 #include "libANGLE/renderer/d3d/ProgramD3D.h"
@@ -3050,6 +3051,17 @@ gl::Error Renderer9::clearTextures(gl::SamplerType samplerType, size_t rangeStar
     return gl::Error(GL_NO_ERROR);
 }
 
+egl::Error Renderer9::initializeEGLDevice(DeviceD3D **outDevice)
+{
+    if (*outDevice == nullptr)
+    {
+        ASSERT(mDevice != nullptr);
+        *outDevice = new DeviceD3D(reinterpret_cast<void *>(mDevice), EGL_D3D9_DEVICE_ANGLE);
+    }
+
+    return egl::Error(EGL_SUCCESS);
+}
+
 Renderer9::CurSamplerState::CurSamplerState()
     : forceSet(true),
       baseLevel(std::numeric_limits<size_t>::max()),

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -244,6 +244,8 @@ class Renderer9 : public RendererD3D
     gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override;
     gl::Error applyShadersImpl(const gl::Data &data, GLenum drawMode) override;
 
+    egl::Error initializeEGLDevice(DeviceD3D **outDevice) override;
+
   private:
     gl::Error drawArraysImpl(const gl::Data &data,
                              GLenum mode,

src/libGLESv2/entry_points_egl_ext.cpp

@@ -309,15 +309,8 @@ EGLBoolean EGLAPIENTRY QueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribut
     switch (attribute)
     {
       case EGL_D3D11_DEVICE_ANGLE:
-        if (!dev->getExtensions().deviceD3D || dev->getType() != EGL_D3D11_DEVICE_ANGLE)
-        {
-            SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
-            return EGL_FALSE;
-        }
-        error = dev->getDevice(value);
-        break;
       case EGL_D3D9_DEVICE_ANGLE:
-        if (!dev->getExtensions().deviceD3D || dev->getType() != EGL_D3D9_DEVICE_ANGLE)
+        if (!dev->getExtensions().deviceD3D || dev->getType() != attribute)
         {
             SetGlobalError(Error(EGL_BAD_ATTRIBUTE));
             return EGL_FALSE;