Split up the Display::create*Surface and have them match the API.

src/libANGLE/Display.cpp

@@ -227,17 +227,35 @@ bool Display::getConfigAttrib(const Config *configuration, EGLint attribute, EGL
 Error Display::createWindowSurface(const Config *configuration, EGLNativeWindowType window, const AttributeMap &attribs,
                                    Surface **outSurface)
 {
-    EGLint postSubBufferSupported = attribs.get(EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_FALSE);
-    EGLint width = attribs.get(EGL_WIDTH, 0);
-    EGLint height = attribs.get(EGL_HEIGHT, 0);
-    EGLint fixedSize = attribs.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE);
+    if (mImplementation->testDeviceLost())
+    {
+        Error error = restoreLostDevice();
+        if (error.isError())
+        {
+            return error;
+        }
+    }
 
-    if (!fixedSize)
+    rx::SurfaceImpl *surfaceImpl = nullptr;
+    Error error = mImplementation->createWindowSurface(configuration, window, attribs, &surfaceImpl);
+    if (error.isError())
     {
-        width = -1;
-        height = -1;
+        return error;
     }
 
+    ASSERT(surfaceImpl != nullptr);
+    Surface *surface = new Surface(surfaceImpl);
+    mImplementation->getSurfaceSet().insert(surface);
+
+    ASSERT(outSurface != nullptr);
+    *outSurface = surface;
+    return Error(EGL_SUCCESS);
+}
+
+Error Display::createPbufferSurface(const Config *configuration, const AttributeMap &attribs, Surface **outSurface)
+{
+    ASSERT(isInitialized());
+
     if (mImplementation->testDeviceLost())
     {
         Error error = restoreLostDevice();
@@ -247,31 +265,26 @@ Error Display::createWindowSurface(const Config *configuration, EGLNativeWindowT
         }
     }
 
-    rx::SurfaceImpl *surfaceImpl = mImplementation->createWindowSurface(this, configuration, window,
-                                                                        fixedSize, width, height,
-                                                                        postSubBufferSupported);
-
-    Surface *surface = new Surface(surfaceImpl);
-    Error error = surface->initialize();
+    rx::SurfaceImpl *surfaceImpl = nullptr;
+    Error error = mImplementation->createPbufferSurface(configuration, attribs, &surfaceImpl);
     if (error.isError())
     {
-        SafeDelete(surface);
         return error;
     }
 
+    ASSERT(surfaceImpl != nullptr);
+    Surface *surface = new Surface(surfaceImpl);
     mImplementation->getSurfaceSet().insert(surface);
 
+    ASSERT(outSurface != nullptr);
     *outSurface = surface;
     return Error(EGL_SUCCESS);
 }
 
-Error Display::createOffscreenSurface(const Config *configuration, EGLClientBuffer shareHandle, const AttributeMap &attribs,
-                                      Surface **outSurface)
+Error Display::createPbufferFromClientBuffer(const Config *configuration, EGLClientBuffer shareHandle,
+                                             const AttributeMap &attribs, Surface **outSurface)
 {
-    EGLint width = attribs.get(EGL_WIDTH, 0);
-    EGLint height = attribs.get(EGL_HEIGHT, 0);
-    EGLenum textureFormat = attribs.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE);
-    EGLenum textureTarget = attribs.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE);
+    ASSERT(isInitialized());
 
     if (mImplementation->testDeviceLost())
     {
@@ -282,19 +295,18 @@ Error Display::createOffscreenSurface(const Config *configuration, EGLClientBuff
         }
     }
 
-    rx::SurfaceImpl *surfaceImpl = mImplementation->createOffscreenSurface(this, configuration, shareHandle,
-                                                                           width, height, textureFormat, textureTarget);
-
-    Surface *surface = new Surface(surfaceImpl);
-    Error error = surface->initialize();
+    rx::SurfaceImpl *surfaceImpl = nullptr;
+    Error error = mImplementation->createPbufferFromClientBuffer(configuration, shareHandle, attribs, &surfaceImpl);
     if (error.isError())
     {
-        SafeDelete(surface);
         return error;
     }
 
+    ASSERT(surfaceImpl != nullptr);
+    Surface *surface = new Surface(surfaceImpl);
     mImplementation->getSurfaceSet().insert(surface);
 
+    ASSERT(outSurface != nullptr);
     *outSurface = surface;
     return Error(EGL_SUCCESS);
 }
@@ -323,6 +335,7 @@ Error Display::createContext(const Config *configuration, gl::Context *shareCont
     ASSERT(context != nullptr);
     mContextSet.insert(context);
 
+    ASSERT(outContext != nullptr);
     *outContext = context;
     return Error(EGL_SUCCESS);
 }

src/libANGLE/Display.h

@@ -51,8 +51,10 @@ class Display final
 
     Error createWindowSurface(const Config *configuration, EGLNativeWindowType window, const AttributeMap &attribs,
                               Surface **outSurface);
-    Error createOffscreenSurface(const Config *configuration, EGLClientBuffer shareHandle, const AttributeMap &attribs,
-                                 Surface **outSurface);
+    Error createPbufferSurface(const Config *configuration, const AttributeMap &attribs, Surface **outSurface);
+    Error createPbufferFromClientBuffer(const Config *configuration, EGLClientBuffer shareHandle, const AttributeMap &attribs,
+                                        Surface **outSurface);
+
     Error createContext(const Config *configuration, gl::Context *shareContext, const AttributeMap &attribs,
                         gl::Context **outContext);
 

src/libANGLE/Surface.cpp

@@ -25,7 +25,6 @@ Surface::Surface(rx::SurfaceImpl *impl)
       mSwapBehavior(EGL_BUFFER_PRESERVED),
       mTexture(NULL)
 {
-    setSwapInterval(1);
 }
 
 Surface::~Surface()
@@ -43,11 +42,6 @@ Surface::~Surface()
     SafeDelete(mImplementation);
 }
 
-Error Surface::initialize()
-{
-    return mImplementation->initialize();
-}
-
 EGLNativeWindowType Surface::getWindowHandle() const
 {
     return mImplementation->getWindowHandle();

src/libANGLE/Surface.h

@@ -39,7 +39,6 @@ class Surface final
 
     rx::SurfaceImpl *getImplementation() const { return mImplementation; }
 
-    Error initialize();
     Error swap();
     Error postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height);
     Error querySurfacePointerANGLE(EGLint attribute, void **value);

src/libANGLE/renderer/DisplayImpl.h

@@ -45,12 +45,12 @@ class DisplayImpl
     virtual egl::Error initialize(egl::Display *display) = 0;
     virtual void terminate() = 0;
 
-    virtual SurfaceImpl *createWindowSurface(egl::Display *display, const egl::Config *config,
-                                             EGLNativeWindowType window, EGLint fixedSize,
-                                             EGLint width, EGLint height, EGLint postSubBufferSupported) = 0;
-    virtual SurfaceImpl *createOffscreenSurface(egl::Display *display, const egl::Config *config,
-                                                EGLClientBuffer shareHandle, EGLint width, EGLint height,
-                                                EGLenum textureFormat, EGLenum textureTarget) = 0;
+    virtual egl::Error createWindowSurface(const egl::Config *configuration, EGLNativeWindowType window, const egl::AttributeMap &attribs,
+                                           SurfaceImpl **outSurface) = 0;
+    virtual egl::Error createPbufferSurface(const egl::Config *configuration, const egl::AttributeMap &attribs,
+                                            SurfaceImpl **outSurface) = 0;
+    virtual egl::Error createPbufferFromClientBuffer(const egl::Config *configuration, EGLClientBuffer shareHandle,
+                                                     const egl::AttributeMap &attribs, SurfaceImpl **outSurface) = 0;
     virtual egl::Error createContext(const egl::Config *config, const gl::Context *shareContext, const egl::AttributeMap &attribs,
                                      gl::Context **outContext) = 0;
 

src/libANGLE/renderer/SurfaceImpl.cpp

@@ -21,7 +21,7 @@ SurfaceImpl::SurfaceImpl(egl::Display *display, const egl::Config *config, EGLin
       mWidth(width),
       mHeight(height),
       mFixedSize(fixedSize),
-      mSwapInterval(-1),
+      mSwapInterval(1),
       mPostSubBufferSupported(postSubBufferSupported),
       mTextureFormat(textureFormat),
       mTextureTarget(textureType),

src/libANGLE/renderer/d3d/DisplayD3D.cpp

@@ -122,24 +122,79 @@ DisplayD3D::DisplayD3D()
 {
 }
 
-SurfaceImpl *DisplayD3D::createWindowSurface(egl::Display *display, const egl::Config *config,
-                                             EGLNativeWindowType window, EGLint fixedSize,
-                                             EGLint width, EGLint height, EGLint postSubBufferSupported)
+egl::Error DisplayD3D::createWindowSurface(const egl::Config *configuration, EGLNativeWindowType window,
+                                           const egl::AttributeMap &attribs, SurfaceImpl **outSurface)
 {
     ASSERT(mRenderer != nullptr);
 
-    return SurfaceD3D::createFromWindow(mRenderer, display, config, window, fixedSize,
-                                        width, height, postSubBufferSupported);
+    EGLint postSubBufferSupported = attribs.get(EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_FALSE);
+    EGLint width = attribs.get(EGL_WIDTH, 0);
+    EGLint height = attribs.get(EGL_HEIGHT, 0);
+    EGLint fixedSize = attribs.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE);
+
+    if (!fixedSize)
+    {
+        width = -1;
+        height = -1;
+    }
+
+    SurfaceD3D *surface = SurfaceD3D::createFromWindow(mRenderer, mDisplay, configuration, window, fixedSize,
+                                                       width, height, postSubBufferSupported);
+    egl::Error error = surface->initialize();
+    if (error.isError())
+    {
+        SafeDelete(surface);
+        return error;
+    }
+
+    *outSurface = surface;
+    return egl::Error(EGL_SUCCESS);
+}
+
+egl::Error DisplayD3D::createPbufferSurface(const egl::Config *configuration, const egl::AttributeMap &attribs,
+                                            SurfaceImpl **outSurface)
+{
+    ASSERT(mRenderer != nullptr);
+
+    EGLint width = attribs.get(EGL_WIDTH, 0);
+    EGLint height = attribs.get(EGL_HEIGHT, 0);
+    EGLenum textureFormat = attribs.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE);
+    EGLenum textureTarget = attribs.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE);
+    
+    SurfaceD3D *surface = SurfaceD3D::createOffscreen(mRenderer, mDisplay, configuration, NULL,
+                                                      width, height, textureFormat, textureTarget);
+    egl::Error error = surface->initialize();
+    if (error.isError())
+    {
+        SafeDelete(surface);
+        return error;
+    }
+
+    *outSurface = surface;
+    return egl::Error(EGL_SUCCESS);
 }
 
-SurfaceImpl *DisplayD3D::createOffscreenSurface(egl::Display *display, const egl::Config *config,
-                                                EGLClientBuffer shareHandle, EGLint width, EGLint height,
-                                                EGLenum textureFormat, EGLenum textureTarget)
+egl::Error DisplayD3D::createPbufferFromClientBuffer(const egl::Config *configuration, EGLClientBuffer shareHandle,
+                                                     const egl::AttributeMap &attribs, SurfaceImpl **outSurface)
 {
     ASSERT(mRenderer != nullptr);
 
-    return SurfaceD3D::createOffscreen(mRenderer, display, config, shareHandle,
-                                       width, height, textureFormat, textureTarget);
+    EGLint width = attribs.get(EGL_WIDTH, 0);
+    EGLint height = attribs.get(EGL_HEIGHT, 0);
+    EGLenum textureFormat = attribs.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE);
+    EGLenum textureTarget = attribs.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE);
+
+    SurfaceD3D *surface = SurfaceD3D::createOffscreen(mRenderer, mDisplay, configuration, shareHandle,
+                                                      width, height, textureFormat, textureTarget);
+    egl::Error error = surface->initialize();
+    if (error.isError())
+    {
+        SafeDelete(surface);
+        return error;
+    }
+
+    *outSurface = surface;
+    return egl::Error(EGL_SUCCESS);
 }
 
 egl::Error DisplayD3D::createContext(const egl::Config *config, const gl::Context *shareContext, const egl::AttributeMap &attribs,
@@ -163,6 +218,7 @@ egl::Error DisplayD3D::makeCurrent(egl::Surface *drawSurface, egl::Surface *read
 egl::Error DisplayD3D::initialize(egl::Display *display)
 {
     ASSERT(mRenderer == nullptr && display != nullptr);
+    mDisplay = display;
     return CreateRendererD3D(display, &mRenderer);
 }
 

src/libANGLE/renderer/d3d/DisplayD3D.h

@@ -23,12 +23,12 @@ class DisplayD3D : public DisplayImpl
     egl::Error initialize(egl::Display *display) override;
     virtual void terminate() override;
 
-    SurfaceImpl *createWindowSurface(egl::Display *display, const egl::Config *config,
-                                     EGLNativeWindowType window, EGLint fixedSize,
-                                     EGLint width, EGLint height, EGLint postSubBufferSupported) override;
-    SurfaceImpl *createOffscreenSurface(egl::Display *display, const egl::Config *config,
-                                        EGLClientBuffer shareHandle, EGLint width, EGLint height,
-                                        EGLenum textureFormat, EGLenum textureTarget) override;
+    egl::Error createWindowSurface(const egl::Config *configuration, EGLNativeWindowType window, const egl::AttributeMap &attribs,
+                                   SurfaceImpl **outSurface) override;
+    egl::Error createPbufferSurface(const egl::Config *configuration, const egl::AttributeMap &attribs,
+                                    SurfaceImpl **outSurface) override;
+    egl::Error createPbufferFromClientBuffer(const egl::Config *configuration, EGLClientBuffer shareHandle,
+                                             const egl::AttributeMap &attribs, SurfaceImpl **outSurface) override;
 
     egl::Error createContext(const egl::Config *config, const gl::Context *shareContext, const egl::AttributeMap &attribs,
                              gl::Context **outContext) override;
@@ -51,6 +51,8 @@ class DisplayD3D : public DisplayImpl
     void generateExtensions(egl::DisplayExtensions *outExtensions) const override;
     void generateCaps(egl::Caps *outCaps) const override;
 
+    egl::Display *mDisplay;
+
     rx::RendererD3D *mRenderer;
 };
 

src/libANGLE/renderer/d3d/SurfaceD3D.cpp

@@ -40,6 +40,7 @@ SurfaceD3D::SurfaceD3D(RendererD3D *renderer, egl::Display *display, const egl::
     : SurfaceImpl(display, config, width, height, fixedSize, postSubBufferSupported, textureFormat, textureType, shareHandle),
       mRenderer(renderer),
       mSwapChain(NULL),
+      mSwapIntervalDirty(true),
       mWindowSubclassed(false),
       mNativeWindow(window)
 {

src/libANGLE/renderer/d3d/SurfaceD3D.h

@@ -35,6 +35,7 @@ class SurfaceD3D : public SurfaceImpl
     void releaseSwapChain();
 
     egl::Error initialize() override;
+
     egl::Error swap() override;
     egl::Error postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height) override;
     egl::Error querySurfacePointerANGLE(EGLint attribute, void **value) override;

src/libGLESv2/entry_points_egl.cpp

@@ -282,7 +282,7 @@ EGLSurface EGLAPIENTRY CreatePbufferSurface(EGLDisplay dpy, EGLConfig config, co
     }
 
     egl::Surface *surface = nullptr;
-    error = display->createOffscreenSurface(configuration, NULL, attributes, &surface);
+    error = display->createPbufferSurface(configuration, attributes, &surface);
     if (error.isError())
     {
         SetGlobalError(error);
@@ -932,7 +932,7 @@ EGLSurface EGLAPIENTRY CreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buf
     }
 
     egl::Surface *surface = nullptr;
-    error = display->createOffscreenSurface(configuration, buffer, attributes, &surface);
+    error = display->createPbufferFromClientBuffer(configuration, buffer, attributes, &surface);
     if (error.isError())
     {
         SetGlobalError(error);

tests/angle_implementation_unit_tests/Surface_unittest.cpp

@@ -35,7 +35,6 @@ class SurfaceTest : public testing::Test
     virtual void SetUp()
     {
         mImpl = new MockSurfaceImpl;
-        EXPECT_CALL(*mImpl, setSwapInterval(1));
         EXPECT_CALL(*mImpl, destroy());
         mSurface = new egl::Surface(mImpl);
     }
@@ -52,7 +51,6 @@ class SurfaceTest : public testing::Test
 TEST_F(SurfaceTest, DestructionDeletesImpl)
 {
     MockSurfaceImpl *impl = new MockSurfaceImpl;
-    EXPECT_CALL(*impl, setSwapInterval(1)).Times(1).RetiresOnSaturation();
     EXPECT_CALL(*impl, destroy()).Times(1).RetiresOnSaturation();
 
     egl::Surface *surface = new egl::Surface(impl);