Attachment #180772 for bug #105602

View Details Raw Unified Return to Bug 105602

| Differences between



2012-12-21  Kondapally Kalyan  <kalyan.kondapally@intel.com>

        [EFL][WebGL] Implement EGL support with GLX.
        https://bugs.webkit.org/show_bug.cgi?id=105602

        Reviewed by NOBODY (OOPS!).

        Adds support for EGL with GLX backend. EGL support can be enabled during compile time
        by passing -DENABLE_EGL=ON as cmake config parameter.

        * Source/cmake/OptionsEfl.cmake:

2012-12-21  Sheriff Bot  <webkit.review.bot@gmail.com>

        Unreviewed, rolling out r138338.



2012-12-21  Kondapally Kalyan  <kalyan.kondapally@intel.com>

        [EFL][WebGL] Implement EGL support with GLX.
        https://bugs.webkit.org/show_bug.cgi?id=105602

        Reviewed by NOBODY (OOPS!).

        This is in preparation for adding GLES2 support.
        This patch adds support for EGL with GLX backend. EGL support can be enabled during compile time
        by passing -DENABLE_EGL=ON as cmake config parameter. This is disabled by default.

        * PlatformEfl.cmake:
        * platform/graphics/opengl/GLDefs.h:
        (WebCore):
        * platform/graphics/opengl/GLPlatformContext.cpp:
        (WebCore):
        (WebCore::GLPlatformContext::createContext): Added GLX checks.
        (WebCore::GLPlatformContext::createOffScreenContext): Added support for creating EGLOffscreen Context.
        (WebCore::GLPlatformContext::createCurrentContextWrapper): Added support for creating EGLCurrentContextWrapper.
        * platform/graphics/opengl/GLPlatformContext.h:
        * platform/graphics/opengl/GLPlatformSurface.cpp:
        (WebCore::GLPlatformSurface::createTransportSurface): Added support for creating EGLSurface.

        * platform/graphics/surfaces/egl/EGLContext.cpp: Added.
        (WebCore):
        (WebCore::isRobustnessExtSupported):
        (WebCore::EGLCurrentContextWrapper::EGLCurrentContextWrapper):
        (WebCore::EGLCurrentContextWrapper::handle):
        (WebCore::EGLOffScreenContext::EGLOffScreenContext):
        (WebCore::EGLOffScreenContext::initialize):
        (WebCore::EGLOffScreenContext::~EGLOffScreenContext):
        (WebCore::EGLOffScreenContext::isCurrentContext):
        (WebCore::EGLOffScreenContext::platformMakeCurrent):
        (WebCore::EGLOffScreenContext::platformReleaseCurrent):
        (WebCore::EGLOffScreenContext::freeResources):
        (WebCore::EGLOffScreenContext::destroy):
        * platform/graphics/surfaces/egl/EGLContext.h:
        (WebCore):
        (EGLCurrentContextWrapper):
        (WebCore::EGLCurrentContextWrapper::~EGLCurrentContextWrapper):
        (EGLOffScreenContext):

        EGL implementation for Context Management.

        * platform/graphics/surfaces/egl/EGLSurface.cpp: Added.
        (WebCore):
        (WebCore::EGLWindowTransportSurface::EGLWindowTransportSurface):
        (WebCore::EGLWindowTransportSurface::~EGLWindowTransportSurface):
        (WebCore::EGLWindowTransportSurface::configuration):
        (WebCore::EGLWindowTransportSurface::swapBuffers):
        (WebCore::EGLWindowTransportSurface::destroy):
        (WebCore::EGLWindowTransportSurface::freeEGLResources):
        * platform/graphics/surfaces/egl/EGLSurface.h:
        (WebCore):
        (EGLWindowTransportSurface):

        EGL implementation for Offscreen Surface. The surface is backed by native window.

        * platform/graphics/surfaces/egl/EGLConfigHelper.cpp: Added.
        (WebCore):
        (WebCore::SharedEGLDisplay::deref):
        (WebCore::SharedEGLDisplay::sharedEGLDisplay):
        (WebCore::SharedEGLDisplay::SharedEGLDisplay):
        (WebCore::SharedEGLDisplay::cleanup):
        (WebCore::SharedEGLDisplay::~SharedEGLDisplay):
        (WebCore::EGLConfigHelper::EGLConfigHelper):
        (WebCore::EGLConfigHelper::~EGLConfigHelper):
        (WebCore::EGLConfigHelper::display):
        (WebCore::EGLConfigHelper::pBufferContextConfig):
        (WebCore::EGLConfigHelper::surfaceContextConfig):
        (WebCore::EGLConfigHelper::nativeVisualId):
        (WebCore::EGLConfigHelper::reset):
        (WebCore::EGLConfigHelper::createConfig):

        Helper class to initialize EGL resources and choose right EGL configuration.

2012-12-21  Brady Eidson  <beidson@apple.com>

        Update localizable strings as a followup to http://trac.webkit.org/changeset/138387



        "${WEBCORE_DIR}/platform/graphics/surfaces/glx"
        "${WEBCORE_DIR}/platform/graphics/texmap"
    )

    if (WTF_USE_EGL)
        list(APPEND WebCore_INCLUDE_DIRECTORIES
            ${EGL_INCLUDE_DIR}
            "${WEBCORE_DIR}/platform/graphics/surfaces/egl"
    )
    endif ()

    list(APPEND WebCore_SOURCES
        platform/graphics/OpenGLShims.cpp
        platform/graphics/cairo/DrawingBufferCairo.cpp

        platform/graphics/opengl/GraphicsContext3DOpenGL.cpp
        platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp
        platform/graphics/surfaces/GraphicsSurface.cpp
        platform/graphics/surfaces/glx/GLXSurface.cpp
        platform/graphics/surfaces/glx/GLXContext.cpp
        platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp
        platform/graphics/surfaces/glx/X11WindowResources.cpp
        platform/graphics/texmap/TextureMapperGL.cpp
        platform/graphics/texmap/TextureMapperShaderManager.cpp
    )

    if (WTF_USE_EGL)
        list(APPEND WebCore_SOURCES
            platform/graphics/surfaces/egl/EGLSurface.cpp
            platform/graphics/surfaces/egl/EGLContext.cpp
        )
    endif ()

    if (WTF_USE_GLX)
        list(APPEND WebCore_SOURCES
            platform/graphics/surfaces/glx/GLXSurface.cpp
            platform/graphics/surfaces/glx/GLXContext.cpp
        )
    endif ()

    list(APPEND WebCore_LIBRARIES
        ${X11_X11_LIB}
        ${X11_Xcomposite_LIB}
        ${X11_Xrender_LIB}
    )
    if (WTF_USE_EGL)
        list(APPEND WebCore_LIBRARIES
            ${EGL_LIBRARY}
        )
    endif ()
endif ()

add_definitions(-DDATA_DIR="${CMAKE_INSTALL_PREFIX}/${DATA_INSTALL_DIR}")




#if USE(ACCELERATED_COMPOSITING)

#include "OpenGLShims.h"

#if USE(OPENGL_ES_2)
#include "OpenGLESShims.h"
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
#else
#include "OpenGLShims.h"
#include <GL/gl.h>
#include <GL/glext.h>
#endif

#include <GL/glx.h>
#endif

#if USE(EGL)
#define EGL_EGLEXT_PROTOTYPES 1
#include <EGL/egl.h>
#include <EGL/eglext.h>
#endif

namespace WebCore {

typedef uint32_t PlatformBufferHandle;

typedef Display* PlatformDisplay;
typedef GLXFBConfig PlatformSurfaceConfig;
typedef GLXDrawable PlatformDrawable;
#elif USE(EGL)
#if USE(OPENGL_ES_2)
static const EGLenum eglAPIVersion = EGL_OPENGL_ES_API;
#else
static const EGLenum eglAPIVersion = EGL_OPENGL_API;
#endif
typedef EGLContext PlatformContext;
typedef EGLDisplay PlatformDisplay;
typedef EGLConfig PlatformSurfaceConfig;
typedef EGLSurface PlatformDrawable;
#else
typedef void* PlatformContext;
typedef void* PlatformDisplay;

Lines 30-35 Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp_sec1
- Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp -6 / +10 lines
30		30
31	#if USE(GLX)	31	#if USE(GLX)
32	#include "GLXContext.h"	32	#include "GLXContext.h"
		33	#elif USE(EGL)
		34	#include "EGLContext.h"
33	#endif	35	#endif
34		36
35	#include "NotImplemented.h"	37	#include "NotImplemented.h"
Lines 44-54 PassOwnPtr<GLPlatformContext> GLPlatformContext::createContext(GraphicsContext3D Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp_sec2
44	if (!initializeOpenGLShims())	46	if (!initializeOpenGLShims())
45	return nullptr;	47	return nullptr;
46		48
47	if (!glGetGraphicsResetStatusARB) {
48	#if USE(GLX)	49	#if USE(GLX)
		50	if (!glGetGraphicsResetStatusARB) {
49	glGetGraphicsResetStatusARB = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSARBPROC>(glXGetProcAddressARB(reinterpret_cast<const GLubyte*>("glGetGraphicsResetStatusARB")));	51	glGetGraphicsResetStatusARB = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSARBPROC>(glXGetProcAddressARB(reinterpret_cast<const GLubyte*>("glGetGraphicsResetStatusARB")));
50	#endif
51	}	52	}
		53	#endif
52		54
53	switch (renderStyle) {	55	switch (renderStyle) {
54	case GraphicsContext3D::RenderOffscreen:	56	case GraphicsContext3D::RenderOffscreen:
Lines 70-77 PassOwnPtr<GLPlatformContext> GLPlatformContext::createContext(GraphicsContext3D Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp_sec3
70	PassOwnPtr<GLPlatformContext> GLPlatformContext::createOffScreenContext()	72	PassOwnPtr<GLPlatformContext> GLPlatformContext::createOffScreenContext()
71	{	73	{
72	#if USE(GLX)	74	#if USE(GLX)
73	OwnPtr<GLPlatformContext> glxContext = adoptPtr(new GLXOffScreenContext());	75	return adoptPtr(new GLXOffScreenContext());
74	return glxContext.release();	76	#elif USE(EGL)
		77	return adoptPtr(new EGLOffScreenContext());
75	#endif	78	#endif
76		79
77	return nullptr;	80	return nullptr;
Lines 80-87 PassOwnPtr<GLPlatformContext> GLPlatformContext::createOffScreenContext() Source/WebCore/platform/graphics/opengl/GLPlatformContext.cpp_sec4
80	PassOwnPtr<GLPlatformContext> GLPlatformContext::createCurrentContextWrapper()	83	PassOwnPtr<GLPlatformContext> GLPlatformContext::createCurrentContextWrapper()
81	{	84	{
82	#if USE(GLX)	85	#if USE(GLX)
83	OwnPtr<GLPlatformContext> glxContext = adoptPtr(new GLXCurrentContextWrapper());	86	return adoptPtr(new GLXCurrentContextWrapper());
84	return glxContext.release();	87	#elif USE(EGL)
		88	return adoptPtr(new EGLCurrentContextWrapper());
85	#endif	89	#endif
86		90
87	return nullptr;	91	return nullptr;

Lines 64-70 public: Source/WebCore/platform/graphics/opengl/GLPlatformContext.h_sec1
- Source/WebCore/platform/graphics/opengl/GLPlatformContext.h -1 / +1 lines
64	// Doesn't have any effect if this is not the current Context.	64	// Doesn't have any effect if this is not the current Context.
65	void releaseCurrent();	65	void releaseCurrent();
66		66
67	PlatformContext handle() const;	67	virtual PlatformContext handle() const;
68		68
69	virtual bool isCurrentContext() const;	69	virtual bool isCurrentContext() const;
70		70

Lines 32-37 Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp_sec1
- Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp -2 / +10 lines
32	#include "GLXSurface.h"	32	#include "GLXSurface.h"
33	#endif	33	#endif
34		34
		35	#if USE(EGL)
		36	#include "EGLSurface.h"
		37	#endif
		38
35	#include "NotImplemented.h"	39	#include "NotImplemented.h"
36		40
37	namespace WebCore {	41	namespace WebCore {
Lines 50-59 PassOwnPtr<GLPlatformSurface> GLPlatformSurface::createOffscreenSurface() Source/WebCore/platform/graphics/opengl/GLPlatformSurface.cpp_sec2
50		54
51	PassOwnPtr<GLPlatformSurface> GLPlatformSurface::createTransportSurface()	55	PassOwnPtr<GLPlatformSurface> GLPlatformSurface::createTransportSurface()
52	{	56	{
53	#if USE(GLX) && USE(GRAPHICS_SURFACE)	57	#if USE(GRAPHICS_SURFACE)
		58	#if USE(GLX)
54	OwnPtr<GLPlatformSurface> surface = adoptPtr(new GLXTransportSurface());	59	OwnPtr<GLPlatformSurface> surface = adoptPtr(new GLXTransportSurface());
		60	#elif USE(EGL)
		61	OwnPtr<GLPlatformSurface> surface = adoptPtr(new EGLWindowTransportSurface());
		62	#endif
55		63
56	if (surface->handle())	64	if (surface && surface->handle() && surface->drawable())
57	return surface.release();	65	return surface.release();
58	#endif	66	#endif
59		67



/*
 * Copyright (C) 2012 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "EGLConfigHelper.h"

#if USE(EGL)

namespace WebCore {

SharedEGLDisplay* SharedEGLDisplay::m_staticSharedEGLDisplay = 0;

static EGLint configAttributeList[] = {
#if USE(OPENGL_ES_2)
    EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
#else
    EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
#endif
    EGL_RED_SIZE, 8,
    EGL_GREEN_SIZE, 8,
    EGL_BLUE_SIZE, 8,
    EGL_STENCIL_SIZE, 8,
    EGL_ALPHA_SIZE, 8,
    EGL_SURFACE_TYPE, EGL_NONE,
    EGL_NONE
};

void SharedEGLDisplay::deref()
{
    if (derefBase()) {
        m_staticSharedEGLDisplay = 0;
        delete this;
    }
}

EGLDisplay SharedEGLDisplay::sharedEGLDisplay()
{
    return m_eglDisplay;
}

SharedEGLDisplay::SharedEGLDisplay(NativeSharedDisplay* display)
    : m_eglDisplay(EGL_NO_DISPLAY)
{
    if (display)
        m_eglDisplay = eglGetDisplay(reinterpret_cast<EGLNativeDisplayType>(display));
    else
        m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);

    if (m_eglDisplay == EGL_NO_DISPLAY) {
        LOG_ERROR("EGLDisplay Initialization failed.\n");
        return;
    }

    EGLBoolean success;
    success = eglInitialize(m_eglDisplay, 0, 0);

    if (success != EGL_TRUE) {
        LOG_ERROR("EGLInitialization failed.\n");
        m_eglDisplay = EGL_NO_DISPLAY;
    }

    success = eglBindAPI(eglAPIVersion);

    if (success != EGL_TRUE) {
        LOG_ERROR("Failed to set EGL API(%d).\n", eglGetError());
        m_eglDisplay = EGL_NO_DISPLAY;
    }
}

void SharedEGLDisplay::cleanup()
{
    if (m_eglDisplay == EGL_NO_DISPLAY)
        return;

    eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    eglTerminate(m_eglDisplay);
    m_eglDisplay = EGL_NO_DISPLAY;
}

SharedEGLDisplay::~SharedEGLDisplay()
{
    cleanup();
}

EGLConfigHelper::EGLConfigHelper(NativeSharedDisplay* display)
    : m_pbufferFBConfig(0)
    , m_surfaceContextFBConfig(0)
{
    m_sharedDisplay = SharedEGLDisplay::create(display);
}

EGLConfigHelper::~EGLConfigHelper()
{
}

PlatformDisplay EGLConfigHelper::display()
{
    return m_sharedDisplay->sharedEGLDisplay();
}

EGLConfig EGLConfigHelper::pBufferContextConfig()
{
    if (!m_pbufferFBConfig) {
        configAttributeList[13] = EGL_PIXMAP_BIT;
        m_pbufferFBConfig = createConfig(configAttributeList);
    }

    return m_pbufferFBConfig;
}

EGLConfig EGLConfigHelper::surfaceContextConfig()
{
    if (!m_surfaceContextFBConfig) {
        configAttributeList[13] = EGL_WINDOW_BIT;
        m_surfaceContextFBConfig = createConfig(configAttributeList);
    }

    return m_surfaceContextFBConfig;
}

EGLint EGLConfigHelper::nativeVisualId(const EGLConfig& config)
{
    if (display() == EGL_NO_DISPLAY)
        return -1;

    EGLint eglValue = 0;
    eglGetConfigAttrib(display(), config, EGL_NATIVE_VISUAL_ID, &eglValue);

    return eglValue;
}

void EGLConfigHelper::reset()
{
    m_surfaceContextFBConfig = 0;
    m_pbufferFBConfig = 0;
}

EGLConfig EGLConfigHelper::createConfig(const int attributes[])
{
    if (display() == EGL_NO_DISPLAY)
        return 0;

    int numConfigs;
    EGLConfig rightConfig = 0;

    if (!eglChooseConfig(display(), attributes, &rightConfig, 1, &numConfigs))
        LOG_ERROR("Failed to get supported configirations.\n");

    if (numConfigs != 1) {
        LOG_ERROR("EGLChooseConfig didn't return exactly one config but (%d).\n", numConfigs);
        rightConfig = 0;
    }

    return rightConfig;
}

}

#endif



/*
 * Copyright (C) 2012 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef EGLConfigHelper_h
#define EGLConfigHelper_h

#if USE(EGL)

#include <opengl/GLDefs.h>
#include <wtf/Noncopyable.h>
#include <wtf/PassRefPtr.h>
#include <wtf/RefCounted.h>
#include <wtf/RefPtr.h>

namespace WebCore {

typedef Display NativeSharedDisplay;

class SharedEGLDisplay : public WTF::RefCountedBase {
    WTF_MAKE_NONCOPYABLE(SharedEGLDisplay);

public:
    static PassRefPtr<SharedEGLDisplay> create(NativeSharedDisplay* display)
    {
        if (!m_staticSharedEGLDisplay)
            m_staticSharedEGLDisplay = new SharedEGLDisplay(display);
        else
            m_staticSharedEGLDisplay->ref();

        return adoptRef(m_staticSharedEGLDisplay);
    }

    void deref();
    EGLDisplay sharedEGLDisplay();

protected:
    SharedEGLDisplay(NativeSharedDisplay*);
    void cleanup();
    virtual ~SharedEGLDisplay();

    static SharedEGLDisplay* m_staticSharedEGLDisplay;
    EGLDisplay m_eglDisplay;
};

class EGLConfigHelper {
    WTF_MAKE_NONCOPYABLE(EGLConfigHelper);

public:
    EGLConfigHelper(NativeSharedDisplay* = 0);
    virtual ~EGLConfigHelper();
    PlatformDisplay display();
    virtual EGLConfig pBufferContextConfig();
    virtual EGLConfig surfaceContextConfig();
    EGLint nativeVisualId(const EGLConfig&);
    void reset();

private:
    EGLConfig createConfig(const int attributes[]);

protected:
    EGLConfig m_pbufferFBConfig;
    EGLConfig m_surfaceContextFBConfig;
    RefPtr<SharedEGLDisplay> m_sharedDisplay;
};

}

#endif

#endif



/*
 * Copyright (C) 2012 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "EGLContext.h"

#if USE(EGL)

#include <wtf/text/WTFString.h>

#if HAVE(GLX)
#include <GL/glx.h>
#endif

namespace WebCore {

static const EGLint contextAttributes[] = {
#if USE(OPENGL_ES_2)
    EGL_CONTEXT_CLIENT_VERSION, 2,
#endif
    EGL_NONE
};

static const EGLint contextRobustnessAttributes[] = {
#if USE(OPENGL_ES_2)
    EGL_CONTEXT_CLIENT_VERSION, 2,
#endif
    EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY_EXT,
    EGL_LOSE_CONTEXT_ON_RESET_EXT,
    EGL_NONE
};

static bool isRobustnessExtSupported(EGLDisplay display)
{
    static bool didQueryForRobustnessExtension = false;
    static bool isRobustnessExtensionSupported = false;

    if (!didQueryForRobustnessExtension) {
        didQueryForRobustnessExtension = true;
        String supportedExtensions = reinterpret_cast<const char*>(eglQueryString(display, EGL_EXTENSIONS));

        if (!supportedExtensions.isEmpty()) {
            supportedExtensions.append(" ");
            isRobustnessExtensionSupported = supportedExtensions.contains("EGL_EXT_create_context_robustness");
        }
    }

    return isRobustnessExtensionSupported;
}

EGLCurrentContextWrapper::EGLCurrentContextWrapper()
    : GLPlatformContext()
{
}

// FIXME: This is a temporary workaround until we are able to build evas with EGL support.
PlatformContext EGLCurrentContextWrapper::handle() const
{
    return glXGetCurrentContext();
}

EGLOffScreenContext::EGLOffScreenContext()
    : GLPlatformContext()
    , m_display(0)
{
}

bool EGLOffScreenContext::initialize(GLPlatformSurface* surface)
{
    if (!surface)
        return false;

    if (!eglBindAPI(eglAPIVersion)) {
        LOG_ERROR("Failed to set EGL API(%d).\n", eglGetError());
        return false;
    }

    m_display = surface->sharedDisplay();
    if (!m_display)
        return false;

    EGLConfig config = surface->configuration();
    if (!config)
        return false;

    if (config) {
        if (isRobustnessExtSupported(m_display))
            m_contextHandle = eglCreateContext(m_display, config, EGL_NO_CONTEXT, contextRobustnessAttributes);

        if (m_contextHandle != EGL_NO_CONTEXT)
            m_resetLostContext = true;
        else
            m_contextHandle = eglCreateContext(m_display, config, EGL_NO_CONTEXT, contextAttributes);

        if (m_contextHandle != EGL_NO_CONTEXT)
            return true;
    }

    return false;
}

EGLOffScreenContext::~EGLOffScreenContext()
{
}

bool EGLOffScreenContext::isCurrentContext() const
{
    return m_contextHandle == eglGetCurrentContext();
}

bool EGLOffScreenContext::platformMakeCurrent(GLPlatformSurface* surface)
{
    if (!eglMakeCurrent(m_display, surface->drawable(), surface->drawable(), m_contextHandle)) {
        LOG_ERROR("Failed to make context current.(%d).\n", eglGetError());

        if (m_resetLostContext && eglGetError() == EGL_CONTEXT_LOST) {
            LOG_ERROR("Lost current context.\n");
            m_contextLost = true;
        }

        return false;
    }

    return true;
}

void EGLOffScreenContext::platformReleaseCurrent()
{
    eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}

void EGLOffScreenContext::freeResources()
{
    if (m_contextHandle == EGL_NO_CONTEXT)
        return;

    eglDestroyContext(m_display, m_contextHandle);
    m_contextHandle = EGL_NO_CONTEXT;
    m_display = 0;
}

void EGLOffScreenContext::destroy()
{
    GLPlatformContext::destroy();
    freeResources();
}

}

#endif



/*
 * Copyright (C) 2012 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef EGLContext_h
#define EGLContext_h

#if USE(EGL)

#include "GLPlatformContext.h"

namespace WebCore {

class EGLCurrentContextWrapper : public GLPlatformContext {

public:
    EGLCurrentContextWrapper();
    virtual PlatformContext handle() const OVERRIDE;
    virtual ~EGLCurrentContextWrapper() { }
};

class EGLOffScreenContext : public GLPlatformContext {

public:
    EGLOffScreenContext();
    virtual ~EGLOffScreenContext();
    virtual bool initialize(GLPlatformSurface*) OVERRIDE;
    virtual bool platformMakeCurrent(GLPlatformSurface*) OVERRIDE;
    virtual void platformReleaseCurrent() OVERRIDE;
    virtual void destroy() OVERRIDE;
    virtual bool isCurrentContext() const OVERRIDE;

private:
    void freeResources();
    EGLDisplay m_display;
};

}

#endif

#endif



/*
 * Copyright (C) 2012 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "config.h"
#include "EGLSurface.h"

#if USE(EGL) && USE(GRAPHICS_SURFACE)

namespace WebCore {

EGLWindowTransportSurface::EGLWindowTransportSurface()
    : GLPlatformSurface()
{
    m_nativeResource = adoptPtr(new NativeOffScreenWindow());
    m_eglConfigHelper = adoptPtr(new EGLConfigHelper(m_nativeResource->nativeSharedDisplay()));
    m_sharedDisplay = m_eglConfigHelper->display();

    if (m_sharedDisplay == EGL_NO_DISPLAY) {
        m_eglConfigHelper = nullptr;
        m_nativeResource = nullptr;
        return;
    }

    EGLConfig config = m_eglConfigHelper->surfaceContextConfig();

    if (!config) {
        destroy();
        return;
    }

    EGLint visualId = m_eglConfigHelper->nativeVisualId(config);

    if (visualId == -1) {
        destroy();
        return;
    }

    if (!m_nativeResource->setVisualId(visualId)) {
        destroy();
        return;
    }

    m_nativeResource->createOffscreenWindow(&m_bufferHandle);

    if (!m_bufferHandle) {
        destroy();
        return;
    }

    m_drawable = eglCreateWindowSurface(m_sharedDisplay, m_eglConfigHelper->surfaceContextConfig(), (EGLNativeWindowType)m_bufferHandle, 0);

    if (m_drawable == EGL_NO_SURFACE) {
        LOG_ERROR("Failed to create EGL surface(%d).\n", eglGetError());
        destroy();
    }
}

EGLWindowTransportSurface::~EGLWindowTransportSurface()
{
}

PlatformSurfaceConfig EGLWindowTransportSurface::configuration()
{
    return m_eglConfigHelper->surfaceContextConfig();
}

void EGLWindowTransportSurface::swapBuffers()
{
    if (!m_drawable)
        return;

    EGLBoolean success = eglBindAPI(eglAPIVersion);

    if (success != EGL_TRUE) {
        LOG_ERROR("Failed to set EGL API(%d).\n", eglGetError());
        destroy();
    }

    success = eglSwapBuffers(m_sharedDisplay, m_drawable);

    if (success != EGL_TRUE) {
        LOG_ERROR("Failed to SwapBuffers(%d).\n", eglGetError());
        destroy();
    }
}

void EGLWindowTransportSurface::destroy()
{
    m_nativeResource->destroyWindow(m_bufferHandle);
    freeEGLResources();
    m_nativeResource = nullptr;
    m_eglConfigHelper = nullptr;
    m_bufferHandle = 0;
}

void EGLWindowTransportSurface::freeEGLResources()
{
    if (m_drawable == EGL_NO_SURFACE || m_sharedDisplay == EGL_NO_DISPLAY)
        return;

    EGLBoolean eglResult = eglBindAPI(eglAPIVersion);

    if (eglResult != EGL_TRUE) {
        LOG_ERROR("Failed to set EGL API(%d).\n", eglGetError());
        return;
    }

    eglDestroySurface(m_sharedDisplay, m_drawable);
    m_drawable = EGL_NO_SURFACE;
}

void EGLWindowTransportSurface::setGeometry(const IntRect& newRect)
{
    GLPlatformSurface::setGeometry(newRect);
    m_nativeResource->reSizeWindow(newRect, m_bufferHandle);
}

}

#endif



/*
 * Copyright (C) 2012 Intel Corporation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef EGLSurface_h
#define EGLSurface_h

#if USE(EGL) && USE(GRAPHICS_SURFACE)

#include "EGLConfigHelper.h"
#include "GLPlatformSurface.h"

#include <glx/X11WindowResources.h>
#include <wtf/Noncopyable.h>
#include <wtf/PassOwnPtr.h>

namespace WebCore {

typedef X11OffScreenWindow NativeOffScreenWindow;

// Contents of the surface are backed by native window.
class EGLWindowTransportSurface : public GLPlatformSurface {

public:
    EGLWindowTransportSurface();
    virtual ~EGLWindowTransportSurface();
    virtual PlatformSurfaceConfig configuration() OVERRIDE;
    virtual void setGeometry(const IntRect& newRect) OVERRIDE;
    virtual void swapBuffers() OVERRIDE;
    virtual void destroy() OVERRIDE;

private:
    void freeEGLResources();
    OwnPtr<NativeOffScreenWindow> m_nativeResource;
    OwnPtr<EGLConfigHelper> m_eglConfigHelper;
};

}

#endif

#endif



GLXTransportSurface::GLXTransportSurface()
    : X11OffScreenWindow()
{
    createOffscreenWindow(&m_bufferHandle);
    m_drawable = m_bufferHandle;
}


    return m_sharedResources->surfaceContextConfig();
}

void GLXTransportSurface::setGeometry(const IntRect& newRect)
{
    GLPlatformSurface::setGeometry(newRect);
    reSizeWindow(newRect, m_drawable);
}

void GLXTransportSurface::swapBuffers()
{
    if (!m_drawable)


void GLXTransportSurface::destroy()
{
    destroyWindow(m_bufferHandle);
    m_bufferHandle = 0;
}


Lines 43-48 public: Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.h_sec1
- Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.h +1 lines
43	virtual ~GLXTransportSurface();	43	virtual ~GLXTransportSurface();
44	PlatformSurfaceConfig configuration();	44	PlatformSurfaceConfig configuration();
45	void swapBuffers();	45	void swapBuffers();
		46	void setGeometry(const IntRect&);
46	void destroy();	47	void destroy();
47		48
48	private:	49	private:



        return SharedX11Resources::x11Display();
    }

    XVisualInfo* visualInfo()
    {
        if (!m_VisualInfo)
            surfaceContextConfig();

        return m_VisualInfo;
    }

    virtual GLXFBConfig pBufferContextConfig()
    {
        if (!m_pbufferfbConfig) {

        return m_surfaceContextfbConfig;
    }

protected:
    SharedGLXResources()
        : SharedX11Resources()
        , m_pbufferfbConfig(0)
        , m_surfaceContextfbConfig(0)
        , m_VisualInfo(0)
    {
    }



        if (m_surfaceContextfbConfig)
            m_surfaceContextfbConfig = 0;

        if (m_VisualInfo) {
            XFree(m_VisualInfo);
            m_VisualInfo = 0;
        }
    }

    GLXFBConfig m_pbufferfbConfig;
    GLXFBConfig m_surfaceContextfbConfig;
    XVisualInfo* m_VisualInfo;
};

}




#if USE(ACCELERATED_COMPOSITING)

#if USE(GLX)
#include "GLXWindowResources.h"
#endif

namespace WebCore {


X11OffScreenWindow::X11OffScreenWindow()
    : GLPlatformSurface()
    , m_sharedResources(0)
    , m_configVisualInfo(0)
{
    m_sharedResources = PlatformSharedResources::create();

    if (!m_sharedResources)
        return;

    m_sharedDisplay = m_sharedResources->x11Display();
}

X11OffScreenWindow::~X11OffScreenWindow()
{
    if (m_configVisualInfo) {
        XFree(m_configVisualInfo);
        m_configVisualInfo = 0;
    }
}

void X11OffScreenWindow::reSizeWindow(const IntRect& newRect, PlatformBufferHandle windowId)
{
    XResizeWindow(m_sharedResources->x11Display(), windowId, newRect.width(), newRect.height());
    XResizeWindow(m_sharedResources->x11Display(), m_bufferHandle, newRect.width(), newRect.height());
}

void X11OffScreenWindow::createOffscreenWindow(PlatformBufferHandle* handleId)
{
    if (!m_sharedResources)
        return;

    if (!display)
        return;

#if USE(GLX)

    if (!config) {
        LOG_ERROR("Failed to retrieve a valid configiration.");
        return;
    }

    XVisualInfo* visInfo = m_sharedResources->visualInfo();
#else
    XVisualInfo* visInfo = m_configVisualInfo;
#endif

    if (!visInfo) {
        LOG_ERROR("Failed to find valid XVisual");

    attribute.background_pixel = WhitePixel(display, 0);
    attribute.border_pixel = BlackPixel(display, 0);
    attribute.colormap = cmap;
    PlatformBufferHandle tempHandleId;
    tempHandleId = XCreateWindow(display, xWindow, 0, 0, 1, 1, 0, visInfo->depth, InputOutput, visInfo->visual, CWBackPixel | CWBorderPixel | CWColormap, &attribute);

    if (!tempHandleId) {
        LOG_ERROR("Failed to create offscreen window");
        return;
    }

    XSetWindowBackgroundPixmap(display, tempHandleId, 0);
    XCompositeRedirectWindow(display, tempHandleId, CompositeRedirectManual);
    *handleId = tempHandleId;
    m_bufferHandle = tempHandleId;

    if (m_sharedResources->isXRenderExtensionSupported())
        XMapWindow(display, tempHandleId);

}

void X11OffScreenWindow::destroyWindow(PlatformBufferHandle windowId)
{
    if (!windowId)
        return;

    GLPlatformSurface::destroy();

    if (!display)
        return;

    XDestroyWindow(display, windowId);
}

Display* X11OffScreenWindow::nativeSharedDisplay()
{
    return m_sharedResources->x11Display();
}

#if USE(EGL)
bool X11OffScreenWindow::setVisualId(const EGLint id)
{
    VisualID visualId = static_cast<VisualID>(id);

    if (!visualId)
        return false;

    // EGL has suggested a visual id, so get the rest of the visual info for that id.
    XVisualInfo visualInfoTemplate;
    memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
    visualInfoTemplate.visualid = visualId;

    XVisualInfo* chosenVisualInfo;
    int matchingCount = 0;
    chosenVisualInfo = XGetVisualInfo(m_sharedResources->x11Display(), VisualIDMask, &visualInfoTemplate, &matchingCount);
    if (chosenVisualInfo) {
#if USE(GRAPHICS_SURFACE)
        if (m_sharedResources->isXRenderExtensionSupported()) {
            XRenderPictFormat* format = XRenderFindVisualFormat(m_sharedResources->x11Display(), chosenVisualInfo->visual);
            if (format && format->direct.alphaMask > 0) {
                m_configVisualInfo = chosenVisualInfo;
                return true;
            }
        }
#endif
        if (chosenVisualInfo->depth == 32) {
            m_configVisualInfo = chosenVisualInfo;
            return true;
        }
    }

    if (!m_configVisualInfo) {
        memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
        XVisualInfo* matchingVisuals;
        int matchingCount = 0;

        visualInfoTemplate.depth = chosenVisualInfo->depth;
        matchingVisuals = XGetVisualInfo(m_sharedResources->x11Display(), VisualDepthMask, &visualInfoTemplate, &matchingCount);

        if (matchingVisuals) {
            m_configVisualInfo = &matchingVisuals[0];
            XFree(matchingVisuals);
            return true;
        }
    }

    if (!m_configVisualInfo)
        LOG_ERROR("Failed to retrieve XVisual Info.\n");

    return false;
}
#endif

}





namespace WebCore {

#if USE(GLX)
class SharedGLXResources;
typedef SharedGLXResources PlatformSharedResources;
#elif USE(EGL)
class SharedX11Resources;
typedef SharedX11Resources PlatformSharedResources;
#endif

class SharedX11Resources : public WTF::RefCountedBase {
    WTF_MAKE_NONCOPYABLE(SharedX11Resources);

public:
#if USE(EGL)
    static PassRefPtr<PlatformSharedResources> create()
    {
        if (!m_staticSharedResource)
            m_staticSharedResource = new PlatformSharedResources();
        else
            m_staticSharedResource->ref();

        return adoptRef(m_staticSharedResource);
    }
#endif

    void deref()
    {
        if (derefBase()) {

        return m_window;
    }

    XVisualInfo* visualInfo()
    {
        if (!m_VisualInfo)
            surfaceContextConfig();

        return m_VisualInfo;
    }

    bool isXRenderExtensionSupported()
    {
        return m_supportsXRenderExtension;
    }

    virtual PlatformSurfaceConfig pBufferContextConfig() = 0;
    virtual PlatformSurfaceConfig surfaceContextConfig() = 0;
    virtual PlatformDisplay nativeDisplay() = 0;

protected:
    SharedX11Resources()
        : m_supportsXRenderExtension(false)
        , m_window(0)
        , m_display(0)
        , m_VisualInfo(0)
    {
    }


            m_window = 0;
        }

        if (m_VisualInfo) {
            XFree(m_VisualInfo);
            m_VisualInfo = 0;
        }

        XCloseDisplay(m_display);
        m_display = 0;
    }

    bool m_supportsXRenderExtension;
    Window m_window;
    Display* m_display;
    XVisualInfo* m_VisualInfo;
};

class X11OffScreenWindow : public GLPlatformSurface {

public:
    X11OffScreenWindow();
    virtual ~X11OffScreenWindow();
    void createOffscreenWindow(PlatformBufferHandle*);
    void destroyWindow(PlatformBufferHandle);
    void reSizeWindow(const IntRect&, PlatformBufferHandle);
    Display* nativeSharedDisplay();
#if USE(EGL)
    bool setVisualId(const EGLint);
#endif

protected:
    RefPtr<PlatformSharedResources> m_sharedResources;
    XVisualInfo* m_configVisualInfo;
};

}

Lines 175-186 if (ENABLE_WEBGL OR WTF_USE_TILED_BACKING_STORE) Source/cmake/OptionsEfl.cmake_sec1
- Source/cmake/OptionsEfl.cmake -4 / +17 lines
175		175
176	if (OPENGLX_FOUND)	176	if (OPENGLX_FOUND)
177	add_definitions(-DHAVE_GLX)	177	add_definitions(-DHAVE_GLX)
178	add_definitions(-DWTF_USE_GLX=1)	178	endif ()
		179
		180	option(ENABLE_EGL ON)
179		181
180	if (X11_Xcomposite_FOUND AND X11_Xrender_FOUND)	182	if (ENABLE_EGL)
181	set(USE_GRAPHICS_SURFACE 1)	183	find_package(EGL REQUIRED)
182	endif ()
183	endif ()	184	endif ()
		185
		186	if (EGL_FOUND)
		187	set(WTF_USE_EGL 1)
		188	add_definitions(-DWTF_USE_EGL=1)
		189	elseif (OPENGLX_FOUND)
		190	set(WTF_USE_GLX 1)
		191	add_definitions(-DWTF_USE_GLX=1)
		192	endif ()
		193
		194	if ((OPENGLX_FOUND OR EGL_FOUND) AND X11_Xcomposite_FOUND AND X11_Xrender_FOUND)
		195	set(USE_GRAPHICS_SURFACE 1)
		196	endif ()
184	endif ()	197	endif ()
185		198
186	if (ENABLE_INSPECTOR)	199	if (ENABLE_INSPECTOR)

Return to Bug 105602

Lines 265-270 if (WTF_USE_3D_GRAPHICS) Source/WebCore/PlatformEfl.cmake_sec1
- Source/WebCore/PlatformEfl.cmake -2 / +28 lines
265	"${WEBCORE_DIR}/platform/graphics/surfaces/glx"	265	"${WEBCORE_DIR}/platform/graphics/surfaces/glx"
266	"${WEBCORE_DIR}/platform/graphics/texmap"	266	"${WEBCORE_DIR}/platform/graphics/texmap"
267	)	267	)
		268
		269	if (WTF_USE_EGL)
		270	list(APPEND WebCore_INCLUDE_DIRECTORIES
		271	${EGL_INCLUDE_DIR}
		272	"${WEBCORE_DIR}/platform/graphics/surfaces/egl"
		273	)
		274	endif ()
		275
268	list(APPEND WebCore_SOURCES	276	list(APPEND WebCore_SOURCES
269	platform/graphics/OpenGLShims.cpp	277	platform/graphics/OpenGLShims.cpp
270	platform/graphics/cairo/DrawingBufferCairo.cpp	278	platform/graphics/cairo/DrawingBufferCairo.cpp
Lines 277-294 if (WTF_USE_3D_GRAPHICS) Source/WebCore/PlatformEfl.cmake_sec2
277	platform/graphics/opengl/GraphicsContext3DOpenGL.cpp	285	platform/graphics/opengl/GraphicsContext3DOpenGL.cpp
278	platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp	286	platform/graphics/opengl/GraphicsContext3DOpenGLCommon.cpp
279	platform/graphics/surfaces/GraphicsSurface.cpp	287	platform/graphics/surfaces/GraphicsSurface.cpp
280	platform/graphics/surfaces/glx/GLXSurface.cpp
281	platform/graphics/surfaces/glx/GLXContext.cpp
282	platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp	288	platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp
283	platform/graphics/surfaces/glx/X11WindowResources.cpp	289	platform/graphics/surfaces/glx/X11WindowResources.cpp
284	platform/graphics/texmap/TextureMapperGL.cpp	290	platform/graphics/texmap/TextureMapperGL.cpp
285	platform/graphics/texmap/TextureMapperShaderManager.cpp	291	platform/graphics/texmap/TextureMapperShaderManager.cpp
286	)	292	)
		293
		294	if (WTF_USE_EGL)
		295	list(APPEND WebCore_SOURCES
		296	platform/graphics/surfaces/egl/EGLSurface.cpp
		297	platform/graphics/surfaces/egl/EGLContext.cpp
		298	)
		299	endif ()
		300
		301	if (WTF_USE_GLX)
		302	list(APPEND WebCore_SOURCES
		303	platform/graphics/surfaces/glx/GLXSurface.cpp
		304	platform/graphics/surfaces/glx/GLXContext.cpp
		305	)
		306	endif ()
		307
287	list(APPEND WebCore_LIBRARIES	308	list(APPEND WebCore_LIBRARIES
288	${X11_X11_LIB}	309	${X11_X11_LIB}
289	${X11_Xcomposite_LIB}	310	${X11_Xcomposite_LIB}
290	${X11_Xrender_LIB}	311	${X11_Xrender_LIB}
291	)	312	)
		313	if (WTF_USE_EGL)
		314	list(APPEND WebCore_LIBRARIES
		315	${EGL_LIBRARY}
		316	)
		317	endif ()
292	endif ()	318	endif ()
293		319
294	add_definitions(-DDATA_DIR="${CMAKE_INSTALL_PREFIX}/${DATA_INSTALL_DIR}")	320	add_definitions(-DDATA_DIR="${CMAKE_INSTALL_PREFIX}/${DATA_INSTALL_DIR}")

Lines 1-3 ChangeLog_sec1
- ChangeLog +12 lines
		1	2012-12-21 Kondapally Kalyan <kalyan.kondapally@intel.com>
		2
		3	[EFL][WebGL] Implement EGL support with GLX.
		4	https://bugs.webkit.org/show_bug.cgi?id=105602
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	Adds support for EGL with GLX backend. EGL support can be enabled during compile time
		9	by passing -DENABLE_EGL=ON as cmake config parameter.
		10
		11	* Source/cmake/OptionsEfl.cmake:
		12
1	2012-12-21 Sheriff Bot <webkit.review.bot@gmail.com>	13	2012-12-21 Sheriff Bot <webkit.review.bot@gmail.com>
2		14
3	Unreviewed, rolling out r138338.	15	Unreviewed, rolling out r138338.

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +76 lines
		1	2012-12-21 Kondapally Kalyan <kalyan.kondapally@intel.com>
		2
		3	[EFL][WebGL] Implement EGL support with GLX.
		4	https://bugs.webkit.org/show_bug.cgi?id=105602
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This is in preparation for adding GLES2 support.
		9	This patch adds support for EGL with GLX backend. EGL support can be enabled during compile time
		10	by passing -DENABLE_EGL=ON as cmake config parameter. This is disabled by default.
		11
		12	* PlatformEfl.cmake:
		13	* platform/graphics/opengl/GLDefs.h:
		14	(WebCore):
		15	* platform/graphics/opengl/GLPlatformContext.cpp:
		16	(WebCore):
		17	(WebCore::GLPlatformContext::createContext): Added GLX checks.
		18	(WebCore::GLPlatformContext::createOffScreenContext): Added support for creating EGLOffscreen Context.
		19	(WebCore::GLPlatformContext::createCurrentContextWrapper): Added support for creating EGLCurrentContextWrapper.
		20	* platform/graphics/opengl/GLPlatformContext.h:
		21	* platform/graphics/opengl/GLPlatformSurface.cpp:
		22	(WebCore::GLPlatformSurface::createTransportSurface): Added support for creating EGLSurface.
		23
		24	* platform/graphics/surfaces/egl/EGLContext.cpp: Added.
		25	(WebCore):
		26	(WebCore::isRobustnessExtSupported):
		27	(WebCore::EGLCurrentContextWrapper::EGLCurrentContextWrapper):
		28	(WebCore::EGLCurrentContextWrapper::handle):
		29	(WebCore::EGLOffScreenContext::EGLOffScreenContext):
		30	(WebCore::EGLOffScreenContext::initialize):
		31	(WebCore::EGLOffScreenContext::~EGLOffScreenContext):
		32	(WebCore::EGLOffScreenContext::isCurrentContext):
		33	(WebCore::EGLOffScreenContext::platformMakeCurrent):
		34	(WebCore::EGLOffScreenContext::platformReleaseCurrent):
		35	(WebCore::EGLOffScreenContext::freeResources):
		36	(WebCore::EGLOffScreenContext::destroy):
		37	* platform/graphics/surfaces/egl/EGLContext.h:
		38	(WebCore):
		39	(EGLCurrentContextWrapper):
		40	(WebCore::EGLCurrentContextWrapper::~EGLCurrentContextWrapper):
		41	(EGLOffScreenContext):
		42
		43	EGL implementation for Context Management.
		44
		45	* platform/graphics/surfaces/egl/EGLSurface.cpp: Added.
		46	(WebCore):
		47	(WebCore::EGLWindowTransportSurface::EGLWindowTransportSurface):
		48	(WebCore::EGLWindowTransportSurface::~EGLWindowTransportSurface):
		49	(WebCore::EGLWindowTransportSurface::configuration):
		50	(WebCore::EGLWindowTransportSurface::swapBuffers):
		51	(WebCore::EGLWindowTransportSurface::destroy):
		52	(WebCore::EGLWindowTransportSurface::freeEGLResources):
		53	* platform/graphics/surfaces/egl/EGLSurface.h:
		54	(WebCore):
		55	(EGLWindowTransportSurface):
		56
		57	EGL implementation for Offscreen Surface. The surface is backed by native window.
		58
		59	* platform/graphics/surfaces/egl/EGLConfigHelper.cpp: Added.
		60	(WebCore):
		61	(WebCore::SharedEGLDisplay::deref):
		62	(WebCore::SharedEGLDisplay::sharedEGLDisplay):
		63	(WebCore::SharedEGLDisplay::SharedEGLDisplay):
		64	(WebCore::SharedEGLDisplay::cleanup):
65	(WebCore::SharedEGLDisplay::~SharedEGLDisplay):
66	(WebCore::EGLConfigHelper::EGLConfigHelper):
67	(WebCore::EGLConfigHelper::~EGLConfigHelper):
68	(WebCore::EGLConfigHelper::display):
69	(WebCore::EGLConfigHelper::pBufferContextConfig):
70	(WebCore::EGLConfigHelper::surfaceContextConfig):
71	(WebCore::EGLConfigHelper::nativeVisualId):
72	(WebCore::EGLConfigHelper::reset):
73	(WebCore::EGLConfigHelper::createConfig):
74
75	Helper class to initialize EGL resources and choose right EGL configuration.
76
1	2012-12-21 Brady Eidson <beidson@apple.com>	77	2012-12-21 Brady Eidson <beidson@apple.com>
2		78
3	Update localizable strings as a followup to http://trac.webkit.org/changeset/138387	79	Update localizable strings as a followup to http://trac.webkit.org/changeset/138387

Lines 28-39 Source/WebCore/platform/graphics/opengl/GLDefs.h_sec1
- Source/WebCore/platform/graphics/opengl/GLDefs.h -2 / +18 lines
28		28
29	#if USE(ACCELERATED_COMPOSITING)	29	#if USE(ACCELERATED_COMPOSITING)
30		30
31	#include "OpenGLShims.h"
32
33	#if USE(OPENGL_ES_2)	31	#if USE(OPENGL_ES_2)
		32	#include "OpenGLESShims.h"
34	#include <GLES2/gl2.h>	33	#include <GLES2/gl2.h>
35	#include <GLES2/gl2ext.h>	34	#include <GLES2/gl2ext.h>
36	#else	35	#else
		36	#include "OpenGLShims.h"
37	#include <GL/gl.h>	37	#include <GL/gl.h>
38	#include <GL/glext.h>	38	#include <GL/glext.h>
39	#endif	39	#endif
Lines 42-47 Source/WebCore/platform/graphics/opengl/GLDefs.h_sec2
42	#include <GL/glx.h>	42	#include <GL/glx.h>
43	#endif	43	#endif
44		44
		45	#if USE(EGL)
		46	#define EGL_EGLEXT_PROTOTYPES 1
		47	#include <EGL/egl.h>
		48	#include <EGL/eglext.h>
		49	#endif
		50
45	namespace WebCore {	51	namespace WebCore {
46		52
47	typedef uint32_t PlatformBufferHandle;	53	typedef uint32_t PlatformBufferHandle;
Lines 51-56 typedef GLXContext PlatformContext; Source/WebCore/platform/graphics/opengl/GLDefs.h_sec3
51	typedef Display* PlatformDisplay;	57	typedef Display* PlatformDisplay;
52	typedef GLXFBConfig PlatformSurfaceConfig;	58	typedef GLXFBConfig PlatformSurfaceConfig;
53	typedef GLXDrawable PlatformDrawable;	59	typedef GLXDrawable PlatformDrawable;
		60	#elif USE(EGL)
		61	#if USE(OPENGL_ES_2)
		62	static const EGLenum eglAPIVersion = EGL_OPENGL_ES_API;
		63	#else
		64	static const EGLenum eglAPIVersion = EGL_OPENGL_API;
		65	#endif
		66	typedef EGLContext PlatformContext;
		67	typedef EGLDisplay PlatformDisplay;
		68	typedef EGLConfig PlatformSurfaceConfig;
		69	typedef EGLSurface PlatformDrawable;
54	#else	70	#else
55	typedef void* PlatformContext;	71	typedef void* PlatformContext;
56	typedef void* PlatformDisplay;	72	typedef void* PlatformDisplay;

Line 0 Source/WebCore/platform/graphics/surfaces/egl/EGLConfigHelper.cpp_sec1
- Source/WebCore/platform/graphics/surfaces/egl/EGLConfigHelper.cpp +181 lines
		1	/*
		2	* Copyright (C) 2012 Intel Corporation. All rights reserved.
		3	*
		4	* Redistribution and use in source and binary forms, with or without
		5	* modification, are permitted provided that the following conditions
		6	* are met:
		7	* 1. Redistributions of source code must retain the above copyright
		8	* notice, this list of conditions and the following disclaimer.
		9	* 2. Redistributions in binary form must reproduce the above copyright
		10	* notice, this list of conditions and the following disclaimer in the
		11	* documentation and/or other materials provided with the distribution.
		12	*
		13	* THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
		14	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
		15	* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
		16	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
		17	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
		18	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
		19	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
		20	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
		21	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
		22	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
		23	* THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#include "config.h"
		27	#include "EGLConfigHelper.h"
		28
		29	#if USE(EGL)
		30
		31	namespace WebCore {
		32
		33	SharedEGLDisplay* SharedEGLDisplay::m_staticSharedEGLDisplay = 0;
		34
		35	static EGLint configAttributeList[] = {
		36	#if USE(OPENGL_ES_2)
		37	EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
		38	#else
		39	EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
		40	#endif
		41	EGL_RED_SIZE, 8,
		42	EGL_GREEN_SIZE, 8,
		43	EGL_BLUE_SIZE, 8,
		44	EGL_STENCIL_SIZE, 8,
		45	EGL_ALPHA_SIZE, 8,
		46	EGL_SURFACE_TYPE, EGL_NONE,
		47	EGL_NONE
		48	};
		49
		50	void SharedEGLDisplay::deref()
		51	{
		52	if (derefBase()) {
		53	m_staticSharedEGLDisplay = 0;
		54	delete this;
		55	}
		56	}
		57
		58	EGLDisplay SharedEGLDisplay::sharedEGLDisplay()
		59	{
		60	return m_eglDisplay;
		61	}
		62
		63	SharedEGLDisplay::SharedEGLDisplay(NativeSharedDisplay* display)
		64	: m_eglDisplay(EGL_NO_DISPLAY)
65	{
66	if (display)
67	m_eglDisplay = eglGetDisplay(reinterpret_cast<EGLNativeDisplayType>(display));
68	else
69	m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
70
71	if (m_eglDisplay == EGL_NO_DISPLAY) {
72	LOG_ERROR("EGLDisplay Initialization failed.\n");
73	return;
74	}
75
76	EGLBoolean success;
77	success = eglInitialize(m_eglDisplay, 0, 0);
78
79	if (success != EGL_TRUE) {
80	LOG_ERROR("EGLInitialization failed.\n");
81	m_eglDisplay = EGL_NO_DISPLAY;
82	}
83
84	success = eglBindAPI(eglAPIVersion);
85
86	if (success != EGL_TRUE) {
87	LOG_ERROR("Failed to set EGL API(%d).\n", eglGetError());
88	m_eglDisplay = EGL_NO_DISPLAY;
89	}
90	}
91
92	void SharedEGLDisplay::cleanup()
93	{
94	if (m_eglDisplay == EGL_NO_DISPLAY)
95	return;
96
97	eglMakeCurrent(m_eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
98	eglTerminate(m_eglDisplay);
99	m_eglDisplay = EGL_NO_DISPLAY;
100	}
101
102	SharedEGLDisplay::~SharedEGLDisplay()
103	{
104	cleanup();
105	}
106
107	EGLConfigHelper::EGLConfigHelper(NativeSharedDisplay* display)
108	: m_pbufferFBConfig(0)
109	, m_surfaceContextFBConfig(0)
110	{
111	m_sharedDisplay = SharedEGLDisplay::create(display);
112	}
113
114	EGLConfigHelper::~EGLConfigHelper()
115	{
116	}
117
118	PlatformDisplay EGLConfigHelper::display()
119	{
120	return m_sharedDisplay->sharedEGLDisplay();
121	}
122
123	EGLConfig EGLConfigHelper::pBufferContextConfig()
124	{
125	if (!m_pbufferFBConfig) {
126	configAttributeList[13] = EGL_PIXMAP_BIT;
127	m_pbufferFBConfig = createConfig(configAttributeList);
128	}
129
130	return m_pbufferFBConfig;
131	}
132
133	EGLConfig EGLConfigHelper::surfaceContextConfig()
134	{
135	if (!m_surfaceContextFBConfig) {
136	configAttributeList[13] = EGL_WINDOW_BIT;
137	m_surfaceContextFBConfig = createConfig(configAttributeList);
138	}
139
140	return m_surfaceContextFBConfig;
141	}
142
143	EGLint EGLConfigHelper::nativeVisualId(const EGLConfig& config)
144	{
145	if (display() == EGL_NO_DISPLAY)
146	return -1;
147
148	EGLint eglValue = 0;
149	eglGetConfigAttrib(display(), config, EGL_NATIVE_VISUAL_ID, &eglValue);
150
151	return eglValue;
152	}
153
154	void EGLConfigHelper::reset()
155	{
156	m_surfaceContextFBConfig = 0;
157	m_pbufferFBConfig = 0;
158	}
159
160	EGLConfig EGLConfigHelper::createConfig(const int attributes[])
161	{
162	if (display() == EGL_NO_DISPLAY)
163	return 0;
164
165	int numConfigs;
166	EGLConfig rightConfig = 0;
167
168	if (!eglChooseConfig(display(), attributes, &rightConfig, 1, &numConfigs))
169	LOG_ERROR("Failed to get supported configirations.\n");
170
171	if (numConfigs != 1) {
172	LOG_ERROR("EGLChooseConfig didn't return exactly one config but (%d).\n", numConfigs);
173	rightConfig = 0;
174	}
175
176	return rightConfig;
177	}
178
179	}
180
181	#endif

Lines 36-42 static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGH Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec1
- Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp -2 / +8 lines
36	GLXTransportSurface::GLXTransportSurface()	36	GLXTransportSurface::GLXTransportSurface()
37	: X11OffScreenWindow()	37	: X11OffScreenWindow()
38	{	38	{
39	createOffscreenWindow();	39	createOffscreenWindow(&m_bufferHandle);
40	m_drawable = m_bufferHandle;	40	m_drawable = m_bufferHandle;
41	}	41	}
42		42
Lines 49-54 PlatformSurfaceConfig GLXTransportSurface::configuration() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec2
49	return m_sharedResources->surfaceContextConfig();	49	return m_sharedResources->surfaceContextConfig();
50	}	50	}
51		51
		52	void GLXTransportSurface::setGeometry(const IntRect& newRect)
		53	{
		54	GLPlatformSurface::setGeometry(newRect);
		55	reSizeWindow(newRect, m_drawable);
		56	}
		57
52	void GLXTransportSurface::swapBuffers()	58	void GLXTransportSurface::swapBuffers()
53	{	59	{
54	if (!m_drawable)	60	if (!m_drawable)
Lines 66-72 void GLXTransportSurface::swapBuffers() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec3
66		72
67	void GLXTransportSurface::destroy()	73	void GLXTransportSurface::destroy()
68	{	74	{
69	destroyWindow();	75	destroyWindow(m_bufferHandle);
70	m_bufferHandle = 0;	76	m_bufferHandle = 0;
71	}	77	}
72		78

Lines 51-56 public: Source/WebCore/platform/graphics/surfaces/glx/GLXWindowResources.h_sec1
- Source/WebCore/platform/graphics/surfaces/glx/GLXWindowResources.h -1 / +16 lines
51	return SharedX11Resources::x11Display();	51	return SharedX11Resources::x11Display();
52	}	52	}
53		53
		54	XVisualInfo* visualInfo()
		55	{
		56	if (!m_VisualInfo)
		57	surfaceContextConfig();
		58
		59	return m_VisualInfo;
		60	}
		61
54	virtual GLXFBConfig pBufferContextConfig()	62	virtual GLXFBConfig pBufferContextConfig()
55	{	63	{
56	if (!m_pbufferfbConfig) {	64	if (!m_pbufferfbConfig) {
Lines 98-108 public: Source/WebCore/platform/graphics/surfaces/glx/GLXWindowResources.h_sec2
98	return m_surfaceContextfbConfig;	106	return m_surfaceContextfbConfig;
99	}	107	}
100		108
101	private:	109	protected:
102	SharedGLXResources()	110	SharedGLXResources()
103	: SharedX11Resources()	111	: SharedX11Resources()
104	, m_pbufferfbConfig(0)	112	, m_pbufferfbConfig(0)
105	, m_surfaceContextfbConfig(0)	113	, m_surfaceContextfbConfig(0)
		114	, m_VisualInfo(0)
106	{	115	{
107	}	116	}
108		117
Lines 160-169 private: Source/WebCore/platform/graphics/surfaces/glx/GLXWindowResources.h_sec3
160		169
161	if (m_surfaceContextfbConfig)	170	if (m_surfaceContextfbConfig)
162	m_surfaceContextfbConfig = 0;	171	m_surfaceContextfbConfig = 0;
		172
		173	if (m_VisualInfo) {
		174	XFree(m_VisualInfo);
		175	m_VisualInfo = 0;
		176	}
163	}	177	}
164		178
165	GLXFBConfig m_pbufferfbConfig;	179	GLXFBConfig m_pbufferfbConfig;
166	GLXFBConfig m_surfaceContextfbConfig;	180	GLXFBConfig m_surfaceContextfbConfig;
		181	XVisualInfo* m_VisualInfo;
167	};	182	};
168		183
169	}	184	}