Revert 146458 "[EFL][WebGL] Implement a common GraphicsSurface I..."

Source/WebCore/platform/graphics/efl/GraphicsContext3DPrivate.cpp

 /*
     Copyright (C) 2012 Samsung Electronics
     Copyright (C) 2012 Intel Corporation. All rights reserved.
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
@@ skipping 50 matching lines @@
 
     if (m_context->m_renderStyle == GraphicsContext3D::RenderOffscreen) {
         m_offScreenSurface = GLPlatformSurface::createOffScreenSurface();
 
         if (!m_offScreenSurface)
             return false;
 
         if (!m_offScreenContext->initialize(m_offScreenSurface.get()))
             return false;
 
+#if USE(GRAPHICS_SURFACE)
         if (!makeContextCurrent())
             return false;
-#if USE(GRAPHICS_SURFACE)
-        m_surfaceOperation = CreateSurface;
+
+        m_context->validateAttributes();
+        GLPlatformSurface::SurfaceAttributes sharedSurfaceAttributes = GLPlatformSurface::Default;
+        if (m_context->m_attrs.alpha)
+            sharedSurfaceAttributes = GLPlatformSurface::SupportAlpha;
+
+        m_offScreenContext->releaseCurrent();
+        m_sharedSurface = GLPlatformSurface::createTransportSurface(sharedSurfaceAttributes);
+        if (!m_sharedSurface)
+            return false;
+
+        m_sharedContext = GLPlatformContext::createContext(m_context->m_renderStyle);
+        if (!m_sharedContext)
+            return false;
+
+        if (!m_sharedContext->initialize(m_sharedSurface.get(), m_offScreenContext->handle()))
+            return false;
+
+        if (!makeSharedContextCurrent())
+            return false;
+
+        m_surfaceHandle = GraphicsSurfaceToken(m_sharedSurface->handle());
 #endif
     }
 
+    if (!makeContextCurrent())
+        return false;
+
     return true;
 }
 
 GraphicsContext3DPrivate::~GraphicsContext3DPrivate()
 {
     releaseResources();
 }
 
 void GraphicsContext3DPrivate::releaseResources()
 {
     if (m_context->m_renderStyle == GraphicsContext3D::RenderToCurrentGLContext)
         return;
 
     // Release the current context and drawable only after destroying any associated gl resources.
 #if USE(GRAPHICS_SURFACE)
-    if (m_previousGraphicsSurface)
-        m_previousGraphicsSurface = nullptr;
+    if (m_sharedContext && m_sharedContext->handle() && m_sharedSurface)
+        makeSharedContextCurrent();
 
-    if (m_graphicsSurface)
-        m_graphicsSurface = nullptr;
+    if (m_sharedSurface)
+        m_sharedSurface->destroy();
 
-    m_surfaceHandle = GraphicsSurfaceToken();
+    if (m_sharedContext) {
+        m_sharedContext->destroy();
+        m_sharedContext->releaseCurrent();
+    }
 #endif
     if (m_offScreenSurface)
         m_offScreenSurface->destroy();
 
     if (m_offScreenContext) {
         m_offScreenContext->destroy();
         m_offScreenContext->releaseCurrent();
     }
 }
 
@@ skipping 47 matching lines @@
         }
 
         glBindFramebuffer(Extensions3D::READ_FRAMEBUFFER, m_context->m_multisampleFBO);
         glBindFramebuffer(Extensions3D::DRAW_FRAMEBUFFER, m_context->m_fbo);
 
         // Use NEAREST as no scale is performed during the blit.
         m_context->getExtensions()->blitFramebuffer(0, 0, width, height, 0, 0, width, height, GraphicsContext3D::COLOR_BUFFER_BIT, GraphicsContext3D::NEAREST);
 
         if (enableScissorTest)
             m_context->enable(GraphicsContext3D::SCISSOR_TEST);
-
-        glBindFramebuffer(GL_FRAMEBUFFER, m_context->m_state.boundFBO);
     }
 
     return true;
 }
 
 #if USE(TEXTURE_MAPPER_GL)
 void GraphicsContext3DPrivate::paintToTextureMapper(TextureMapper*, const FloatRect& /* target */, const TransformationMatrix&, float /* opacity */)
 {
     notImplemented();
 }
 #endif
 
 #if USE(GRAPHICS_SURFACE)
-void GraphicsContext3DPrivate::createGraphicsSurface()
+bool GraphicsContext3DPrivate::makeSharedContextCurrent() const
 {
-    static PendingSurfaceOperation pendingOperation = DeletePreviousSurface | Resize | CreateSurface;
-    if (!(m_surfaceOperation & pendingOperation))
-        return;
+    bool success = m_sharedContext->makeCurrent(m_sharedSurface.get());
 
-    if (m_surfaceOperation & DeletePreviousSurface) {
-        m_previousGraphicsSurface = nullptr;
-        m_surfaceOperation &= ~DeletePreviousSurface;
+    if (!m_sharedContext->isValid()) {
+        // FIXME: Restore context
+        if (m_contextLostCallback)
+            m_contextLostCallback->onContextLost();
+
+        return false;
     }
 
-    if (!(m_surfaceOperation & pendingOperation))
-        return;
-
-    // Don't release current graphics surface until we have prepared surface
-    // with requested size. This is to avoid flashing during resize.
-    if (m_surfaceOperation & Resize) {
-        m_previousGraphicsSurface = m_graphicsSurface;
-        m_surfaceOperation &= ~Resize;
-        m_surfaceOperation |= DeletePreviousSurface;
-        m_size = IntSize(m_context->m_currentWidth, m_context->m_currentHeight);
-    } else
-        m_surfaceOperation &= ~CreateSurface;
-
-    m_targetRect = IntRect(IntPoint(), m_size);
-
-    if (m_size.isEmpty()) {
-        if (m_graphicsSurface) {
-            m_graphicsSurface = nullptr;
-            m_surfaceHandle = GraphicsSurfaceToken();
-            makeContextCurrent();
-        }
-
-        return;
-    }
-
-    m_offScreenContext->releaseCurrent();
-    GraphicsSurface::Flags flags = GraphicsSurface::SupportsTextureTarget | GraphicsSurface::SupportsSharing;
-
-    if (m_context->m_attrs.alpha)
-        flags |= GraphicsSurface::SupportsAlpha;
-
-    m_graphicsSurface = GraphicsSurface::create(m_size, flags, m_offScreenContext->handle());
-
-    if (!m_graphicsSurface)
-        m_surfaceHandle = GraphicsSurfaceToken();
-    else
-        m_surfaceHandle = GraphicsSurfaceToken(m_graphicsSurface->exportToken());
-
-    makeContextCurrent();
+    return success;
 }
 
 void GraphicsContext3DPrivate::didResizeCanvas(const IntSize& size)
 {
-    if (m_surfaceOperation & CreateSurface) {
-        m_size = size;
-        createGraphicsSurface();
-        return;
-    }
+    m_size = size;
 
-    m_surfaceOperation |= Resize;
+    if (makeSharedContextCurrent())
+        m_sharedSurface->setGeometry(IntRect(0, 0, m_size.width(), m_size.height()));
 }
 
 uint32_t GraphicsContext3DPrivate::copyToGraphicsSurface()
 {
-    createGraphicsSurface();
-
-    if (!m_graphicsSurface || m_context->m_layerComposited || !prepareBuffer())
+    if (m_context->m_layerComposited || !prepareBuffer() || !makeSharedContextCurrent())
         return 0;
 
-    m_graphicsSurface->copyFromTexture(m_context->m_texture, m_targetRect);
+    m_sharedSurface->updateContents(m_context->m_texture);
     makeContextCurrent();
-
-    return m_graphicsSurface->frontBuffer();
+    glBindFramebuffer(GL_FRAMEBUFFER,  m_context->m_state.boundFBO);
+    return 0;
 }
 
 GraphicsSurfaceToken GraphicsContext3DPrivate::graphicsSurfaceToken() const
 {
     return m_surfaceHandle;
 }
 
 IntSize GraphicsContext3DPrivate::platformLayerSize() const
 {
     return m_size;
 }
 #endif
 
 } // namespace WebCore
 
 #endif // USE(3D_GRAPHICS) || USE(ACCELERATED_COMPOSITING)