Refactor DeviceImpl creation.

src/libANGLE/Device.cpp

@@ -47,19 +47,25 @@ egl::Error Device::CreateDevice(void *devicePointer, EGLint deviceType, Device *
 {
     *outDevice = nullptr;
 
+    std::unique_ptr<rx::DeviceImpl> newDeviceImpl;
+
 #if defined(ANGLE_ENABLE_D3D11)
     if (deviceType == EGL_D3D11_DEVICE_ANGLE)
     {
-        std::unique_ptr<rx::DeviceD3D> deviceD3D(new rx::DeviceD3D());
-        ANGLE_TRY(deviceD3D->initialize(devicePointer, deviceType));
-        *outDevice = new Device(nullptr, deviceD3D.release());
-        GetDeviceSet()->insert(*outDevice);
-        return NoError();
+        newDeviceImpl.reset(new rx::DeviceD3D(deviceType, devicePointer));
     }
 #endif
 
-    // Note that creating an EGL device from inputted D3D9 parameters isn't currently supported
-    return EglBadAttribute();
+    if (newDeviceImpl == nullptr)
+    {
+        return EglBadAttribute();
+    }
+
+    ANGLE_TRY(newDeviceImpl->initialize());
+    *outDevice = new Device(nullptr, newDeviceImpl.release());
+    GetDeviceSet()->insert(*outDevice);
+
+    return NoError();
 }
 
 egl::Error Device::CreateDevice(Display *owningDisplay, rx::DeviceImpl *impl, Device **outDevice)

src/libANGLE/renderer/DeviceImpl.h

@@ -26,6 +26,8 @@ class DeviceImpl : angle::NonCopyable
     DeviceImpl();
     virtual ~DeviceImpl();
 
+    virtual egl::Error initialize() = 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,14 +17,15 @@
 namespace rx
 {
 
-DeviceD3D::DeviceD3D() : mDevice(0), mDeviceType(0), mIsInitialized(false)
+DeviceD3D::DeviceD3D(GLint deviceType, void *nativeDevice)
+    : mDevice(nativeDevice), mDeviceType(deviceType), mIsInitialized(false)
 {
 }
 
 DeviceD3D::~DeviceD3D()
 {
 #if defined(ANGLE_ENABLE_D3D11)
-    if (mDeviceType == EGL_D3D11_DEVICE_ANGLE)
+    if (mIsInitialized && mDeviceType == EGL_D3D11_DEVICE_ANGLE)
     {
         // DeviceD3D holds a ref to an externally-sourced D3D11 device. We must release it.
         ID3D11Device *device = reinterpret_cast<ID3D11Device *>(mDevice);
@@ -35,29 +36,20 @@ DeviceD3D::~DeviceD3D()
 
 egl::Error DeviceD3D::getDevice(void **outValue)
 {
-    if (!mIsInitialized)
-    {
-        *outValue = nullptr;
-        return egl::EglBadDevice();
-    }
-
+    ASSERT(mIsInitialized);
     *outValue = mDevice;
     return egl::NoError();
 }
 
-egl::Error DeviceD3D::initialize(void *device, EGLint deviceType)
+egl::Error DeviceD3D::initialize()
 {
     ASSERT(!mIsInitialized);
-    if (mIsInitialized)
-    {
-        return egl::EglBadDevice();
-    }
 
 #if defined(ANGLE_ENABLE_D3D11)
-    if (deviceType == EGL_D3D11_DEVICE_ANGLE)
+    if (mDeviceType == EGL_D3D11_DEVICE_ANGLE)
     {
         // Validate the device
-        IUnknown *iunknown = reinterpret_cast<IUnknown *>(device);
+        IUnknown *iunknown = reinterpret_cast<IUnknown *>(mDevice);
 
         ID3D11Device *d3dDevice = nullptr;
         HRESULT hr =
@@ -73,9 +65,7 @@ egl::Error DeviceD3D::initialize(void *device, EGLint deviceType)
     }
 #endif
 
-    mDevice                  = device;
-    mDeviceType              = deviceType;
-    mIsInitialized           = true;
+    mIsInitialized = true;
 
     return egl::NoError();
 }

src/libANGLE/renderer/d3d/DeviceD3D.h

@@ -18,10 +18,10 @@ namespace rx
 class DeviceD3D : public DeviceImpl
 {
   public:
-    DeviceD3D();
+    DeviceD3D(EGLint deviceType, void *nativeDevice);
     ~DeviceD3D() override;
 
-    egl::Error initialize(void *device, EGLint deviceType);
+    egl::Error initialize() override;
     egl::Error getDevice(void **outValue) override;
     EGLint getType() override;
     void generateExtensions(egl::DeviceExtensions *outExtensions) const override;

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

@@ -3813,15 +3813,9 @@ egl::Error Renderer11::getEGLDevice(DeviceImpl **device)
     if (mEGLDevice == nullptr)
     {
         ASSERT(mDevice != nullptr);
-        mEGLDevice       = new DeviceD3D();
-        egl::Error error =
-            mEGLDevice->initialize(reinterpret_cast<void *>(mDevice), EGL_D3D11_DEVICE_ANGLE);
-
-        if (error.isError())
-        {
-            SafeDelete(mEGLDevice);
-            return error;
-        }
+        std::unique_ptr<DeviceD3D> newDevice(new DeviceD3D(EGL_D3D11_DEVICE_ANGLE, mDevice));
+        ANGLE_TRY(newDevice->initialize());
+        mEGLDevice = newDevice.release();
     }
 
     *device = static_cast<DeviceImpl *>(mEGLDevice);

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

@@ -3089,15 +3089,9 @@ egl::Error Renderer9::getEGLDevice(DeviceImpl **device)
     if (mEGLDevice == nullptr)
     {
         ASSERT(mDevice != nullptr);
-        mEGLDevice       = new DeviceD3D();
-        egl::Error error =
-            mEGLDevice->initialize(reinterpret_cast<void *>(mDevice), EGL_D3D9_DEVICE_ANGLE);
-
-        if (error.isError())
-        {
-            SafeDelete(mEGLDevice);
-            return error;
-        }
+        std::unique_ptr<DeviceD3D> newDevice(new DeviceD3D(EGL_D3D9_DEVICE_ANGLE, mDevice));
+        ANGLE_TRY(newDevice->initialize());
+        mEGLDevice = newDevice.release();
     }
 
     *device = static_cast<DeviceImpl *>(mEGLDevice);

src/libANGLE/renderer/null/DeviceNULL.cpp

@@ -22,6 +22,11 @@ DeviceNULL::~DeviceNULL()
 {
 }
 
+egl::Error DeviceNULL::initialize()
+{
+    return egl::NoError();
+}
+
 egl::Error DeviceNULL::getDevice(void **outValue)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/null/DeviceNULL.h

@@ -21,6 +21,7 @@ class DeviceNULL : public DeviceImpl
     DeviceNULL();
     ~DeviceNULL() override;
 
+    egl::Error initialize() override;
     egl::Error getDevice(void **outValue) override;
     EGLint getType() override;
     void generateExtensions(egl::DeviceExtensions *outExtensions) const override;

src/libANGLE/renderer/vulkan/DeviceVk.cpp

@@ -22,6 +22,12 @@ DeviceVk::~DeviceVk()
 {
 }
 
+egl::Error DeviceVk::initialize()
+{
+    UNIMPLEMENTED();
+    return egl::NoError();
+}
+
 egl::Error DeviceVk::getDevice(void **outValue)
 {
     UNIMPLEMENTED();

src/libANGLE/renderer/vulkan/DeviceVk.h

@@ -21,6 +21,7 @@ class DeviceVk : public DeviceImpl
     DeviceVk();
     ~DeviceVk() override;
 
+    egl::Error initialize() override;
     egl::Error getDevice(void **outValue) override;
     EGLint getType() override;
     void generateExtensions(egl::DeviceExtensions *outExtensions) const override;