Attachment #180124 for bug #105357

View Details Raw Unified Return to Bug 105357

| Differences between



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

        [EFL][WebGL] Refactor GLXSurface.
        https://bugs.webkit.org/show_bug.cgi?id=105357

        Reviewed by NOBODY (OOPS!).

        This is in preparation for adding EGL support.
        There is lot of X related code which could be shared between our current GLX implementation
        and EGL. This patch makes it possible to share the common code but doesn't change any functionality.

        * PlatformEfl.cmake:
        * platform/graphics/surfaces/glx/GLXSurface.cpp:
        (WebCore):
        (WebCore::GLXTransportSurface::GLXTransportSurface):
        (WebCore::GLXTransportSurface::configuration):
        (WebCore::GLXTransportSurface::destroy):
        (WebCore::GLXTransportSurface::freeResources):
        (WebCore::GLXPBuffer::GLXPBuffer):
        (WebCore::GLXPBuffer::initialize):
        (WebCore::GLXPBuffer::configuration):
        (WebCore::GLXPBuffer::setGeometry):
        * platform/graphics/surfaces/glx/GLXSurface.h:
        (GLXTransportSurface):
        (GLXPBuffer):

        GLX related implementation.
        * platform/graphics/surfaces/glx/GLXWindowResources.h: Added.
        (WebCore):
        (SharedGLXResources):
        (WebCore::SharedGLXResources::create):
        (WebCore::SharedGLXResources::nativeDisplay):
        (WebCore::SharedGLXResources::pBufferContextConfig):
        (WebCore::SharedGLXResources::surfaceContextConfig):
        (WebCore::SharedGLXResources::SharedGLXResources):
        (WebCore::SharedGLXResources::createConfig):

        Moving X related code to a seperate class.
        * platform/graphics/surfaces/glx/X11WindowResources.cpp: Added.
        (WebCore):
        (WebCore::X11OffScreenWindow::X11OffScreenWindow):
        (WebCore::X11OffScreenWindow::~X11OffScreenWindow):
        (WebCore::X11OffScreenWindow::setGeometry):
        (WebCore::X11OffScreenWindow::createOffscreenWindow):
        * platform/graphics/surfaces/glx/X11WindowResources.h: Added.
        (WebCore):
        (SharedX11Resources):
        (WebCore::SharedX11Resources::deref):
        (WebCore::SharedX11Resources::x11Display):
        (WebCore::SharedX11Resources::getXWindow):
        (WebCore::SharedX11Resources::visualInfo):
        (WebCore::SharedX11Resources::isXRenderExtensionSupported):
        (WebCore::SharedX11Resources::SharedX11Resources):
        (WebCore::SharedX11Resources::~SharedX11Resources):
        (X11OffScreenWindow):

2012-12-18  Mark Lam  <mark.lam@apple.com>

        Fixed bad merge in "Initial refactoring of database functionality into the manager and server".

Lines 276-281 if (WTF_USE_3D_GRAPHICS) Source/WebCore/PlatformEfl.cmake_sec1
- Source/WebCore/PlatformEfl.cmake +1 lines
276	platform/graphics/surfaces/glx/GLXSurface.cpp	276	platform/graphics/surfaces/glx/GLXSurface.cpp
277	platform/graphics/surfaces/glx/GLXContext.cpp	277	platform/graphics/surfaces/glx/GLXContext.cpp
278	platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp	278	platform/graphics/surfaces/glx/GraphicsSurfaceGLX.cpp
		279	platform/graphics/surfaces/glx/X11WindowResources.cpp
279	platform/graphics/texmap/TextureMapperGL.cpp	280	platform/graphics/texmap/TextureMapperGL.cpp
280	platform/graphics/texmap/TextureMapperShaderManager.cpp	281	platform/graphics/texmap/TextureMapperShaderManager.cpp
281	)	282	)




namespace WebCore {

SharedX11Resources* SharedX11Resources::m_staticSharedResource = 0;

static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };

GLXSurface::GLXSurface()
    : GLPlatformSurface()
{
    m_sharedResources = SharedX11Resources::create();
    m_sharedDisplay = m_sharedResources->display();
}

GLXSurface::~GLXSurface()
{
}

XVisualInfo* GLXSurface::visualInfo()
{
    return m_sharedResources->visualInfo();
}

Window GLXSurface::xWindow()
{
    return m_sharedResources->getXWindow();
}

GLXFBConfig GLXSurface::pBufferConfiguration()
{
    return m_sharedResources->pBufferContextConfig();
}

GLXFBConfig GLXSurface::transportSurfaceConfiguration()
{
    return m_sharedResources->surfaceContextConfig();
}

bool GLXSurface::isXRenderExtensionSupported()
{
    return m_sharedResources->isXRenderExtensionSupported();
}

#if USE(GRAPHICS_SURFACE)
GLXTransportSurface::GLXTransportSurface()
    : X11OffScreenWindow()
{
    createOffscreenWindow();
}

GLXTransportSurface::~GLXTransportSurface()


PlatformSurfaceConfig GLXTransportSurface::configuration()
{
    return m_sharedResources->surfaceContextConfig();
}

void GLXTransportSurface::swapBuffers()

        glXSwapBuffers(sharedDisplay(), m_drawable);
}

void GLXTransportSurface::setGeometry(const IntRect& newRect)
{
    GLPlatformSurface::setGeometry(newRect);
    int width = newRect.width();
    int height = newRect.height();
    XResizeWindow(sharedDisplay(), m_drawable, width, height);
}

void GLXTransportSurface::initialize()
{
    Display* display = sharedDisplay();
    GLXFBConfig config = transportSurfaceConfiguration();
    if (!config)
        return;

    XVisualInfo* visInfo = visualInfo();
    if (!visInfo)
        return;

    Colormap cmap = XCreateColormap(display, xWindow(), visInfo->visual, AllocNone);
    XSetWindowAttributes attribute;
    attribute.background_pixel = WhitePixel(display, 0);
    attribute.border_pixel = BlackPixel(display, 0);
    attribute.colormap = cmap;
    m_drawable = XCreateWindow(display, xWindow(), 0, 0, 1, 1, 0, visInfo->depth, InputOutput, visInfo->visual, CWBackPixel | CWBorderPixel | CWColormap, &attribute);
    if (!m_drawable)
        return;

    XSetWindowBackgroundPixmap(display, m_drawable, 0);
    XCompositeRedirectWindow(display, m_drawable, CompositeRedirectManual);

    if (isXRenderExtensionSupported())
        XMapWindow(display, m_drawable);
}

void GLXTransportSurface::destroy()
{
    destroyWindow();
    GLPlatformSurface::destroy();
}

void GLXTransportSurface::freeResources()
{
    if (!m_drawable)
        return;

    GLPlatformSurface::destroy();
    Display* display = sharedDisplay();
    if (!display)
        return;

    XDestroyWindow(display, m_drawable);
    m_drawable = 0;
}
#endif

GLXPBuffer::GLXPBuffer()
    : X11OffScreenWindow()
{
    initialize();
}

void GLXPBuffer::initialize()
{
    Display* display = sharedDisplay();
    GLXFBConfig config = m_sharedResources->pBufferContextConfig();
    if (!config)
        return;



PlatformSurfaceConfig GLXPBuffer::configuration()
{
    return m_sharedResources->pBufferContextConfig();
}

void GLXPBuffer::destroy()

    m_drawable = 0;
}

void GLXPBuffer::setGeometry(const IntRect& newRect)
{
    GLPlatformSurface::setGeometry(newRect);
}

}

#endif




#if USE(ACCELERATED_COMPOSITING) && HAVE(GLX)

#include "GLXWindowResources.h"

#include <X11/extensions/Xcomposite.h>
#include <X11/extensions/Xrender.h>
#endif
#include <wtf/Noncopyable.h>
#include <wtf/RefCounted.h>

namespace WebCore {

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

public:
    static PassRefPtr<SharedX11Resources> create()
    {
        if (!m_staticSharedResource)
            m_staticSharedResource = new SharedX11Resources();
        else
            m_staticSharedResource->ref();

        return adoptRef(m_staticSharedResource);
    }

    void deref()
    {
        if (derefBase()) {
            m_staticSharedResource = 0;
            delete this;
        }
    }

    Window getXWindow()
    {
        if (!m_window) {
            Display* dpy = display();
            XSetWindowAttributes attributes;
            attributes.override_redirect = true;
            m_window = XCreateSimpleWindow(dpy, XDefaultRootWindow(dpy), -1, -1, 1, 1, 0, BlackPixel(dpy, 0), WhitePixel(dpy, 0));
            // From http://tronche.com/gui/x/xlib/window/attributes/
            XChangeWindowAttributes(dpy, m_window, CWOverrideRedirect, &attributes);
            XMapWindow(dpy, m_window);
        }

        return m_window;
    }

    Display* display()
    {
        if (!m_display)
            m_display = XOpenDisplay(0);

        return m_display;
    }

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

        return m_VisualInfo;
    }

    GLXFBConfig createConfig(const int attributes[])
    {
        int numReturned;
        m_VisualInfo = 0;
        GLXFBConfig* temp = glXChooseFBConfig(display(), DefaultScreen(display()), attributes, &numReturned);

        if (!numReturned)
            return 0;

        GLXFBConfig selectedConfig = 0;
        bool found = false;

        for (int i = 0; i < numReturned; ++i) {
            m_VisualInfo = glXGetVisualFromFBConfig(display(), temp[i]);
            if (!m_VisualInfo)
                continue;
#if USE(GRAPHICS_SURFACE)
class GLXTransportSurface : public X11OffScreenWindow {
                XRenderPictFormat* format = XRenderFindVisualFormat(display(), m_VisualInfo->visual);
                if (format && format->direct.alphaMask > 0) {
                    selectedConfig = temp[i];
                    found = true;
                    break;
                }
            } else if (m_VisualInfo->depth == 32) {
#else
            if (m_VisualInfo->depth == 32) {
#endif
                selectedConfig = temp[i];
                found = true;
            }
        }

        // Did not find any visual supporting alpha, select the first available config.
        if (!found) {
            selectedConfig = temp[0];
            m_VisualInfo = glXGetVisualFromFBConfig(m_display, temp[0]);
        }

        XFree(temp);

        return selectedConfig;
    }

    GLXFBConfig pBufferContextConfig()
    {
        if (!m_pbufferfbConfig) {
            static const int attributes[] = {
                GLX_LEVEL, 0,
                GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
                GLX_RENDER_TYPE,   GLX_RGBA_BIT,
                GLX_RED_SIZE,      1,
                GLX_GREEN_SIZE,    1,
                GLX_BLUE_SIZE,     1,
                GLX_DOUBLEBUFFER,  GL_FALSE,
                None
            };

            int numReturned;
            GLXFBConfig* temp = glXChooseFBConfig(display(), DefaultScreen(display()), attributes, &numReturned);
            if (numReturned)
                m_pbufferfbConfig = temp[0];
            XFree(temp);
        }

        return m_pbufferfbConfig;
    }

    GLXFBConfig surfaceContextConfig()
    {
        if (!m_surfaceContextfbConfig) {
            static int attributes[] = {
                GLX_LEVEL, 0,
                GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
                GLX_RENDER_TYPE,   GLX_RGBA_BIT,
                GLX_RED_SIZE,      1,
                GLX_GREEN_SIZE,    1,
                GLX_BLUE_SIZE,     1,
                GLX_ALPHA_SIZE,    1,
                GLX_DEPTH_SIZE,    1,
                GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
                GLX_DOUBLEBUFFER,  True,
                None
            };
#if USE(GRAPHICS_SURFACE)
            int eventBasep, errorBasep;
            m_supportsXRenderExtension = XRenderQueryExtension(display(), &eventBasep, &errorBasep);
#endif
            m_surfaceContextfbConfig = createConfig(attributes);
        }

        return m_surfaceContextfbConfig;
    }

    bool isXRenderExtensionSupported()
    {
        return m_supportsXRenderExtension;
    }

private:
    SharedX11Resources()
        : m_supportsXRenderExtension(false)
        , m_markForDeletion(false)
        , m_window(0)
        , m_display(0)
        , m_pbufferfbConfig(0)
        , m_surfaceContextfbConfig(0)
        , m_VisualInfo(0)
    {
    }

    ~SharedX11Resources()
    {
        if (!m_display)
            return;

        if (m_window) {
            XUnmapWindow(m_display, m_window);
            XDestroyWindow(m_display, m_window);
            m_window = 0;
        }

        if (m_pbufferfbConfig)
            m_pbufferfbConfig = 0;

        if (m_surfaceContextfbConfig)
            m_surfaceContextfbConfig = 0;

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

        XCloseDisplay(m_display);
        m_display = 0;
    }

    static SharedX11Resources* m_staticSharedResource;
    bool m_supportsXRenderExtension;
    bool m_markForDeletion;
    Window m_window;
    Display* m_display;
    GLXFBConfig m_pbufferfbConfig;
    GLXFBConfig m_surfaceContextfbConfig;
    XVisualInfo* m_VisualInfo;
};

class GLXSurface : public GLPlatformSurface {
    WTF_MAKE_NONCOPYABLE(GLXSurface);

public:
    GLXSurface();
    virtual ~GLXSurface();

protected:
    XVisualInfo* visualInfo();
    Window xWindow();
    GLXFBConfig pBufferConfiguration();
    GLXFBConfig transportSurfaceConfiguration();
    bool isXRenderExtensionSupported();

private:
    RefPtr<SharedX11Resources> m_sharedResources;
};

#if USE(GRAPHICS_SURFACE)
class GLXTransportSurface : public GLXSurface {
    WTF_MAKE_NONCOPYABLE(GLXTransportSurface);

public:

    virtual ~GLXTransportSurface();
    PlatformSurfaceConfig configuration();
    void swapBuffers();
    void setGeometry(const IntRect& newRect);
    void destroy();

private:
    void initialize();
    void freeResources();
};
#endif

class GLXPBuffer : public X11OffScreenWindow {
    WTF_MAKE_NONCOPYABLE(GLXPBuffer);

public:
    GLXPBuffer();
    virtual ~GLXPBuffer();
    PlatformSurfaceConfig configuration();
    void setGeometry(const IntRect&);
    void destroy();

private:



/*
 * 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 GLXWindowResources_h
#define GLXWindowResources_h

#include "X11WindowResources.h"

#if USE(ACCELERATED_COMPOSITING) && HAVE(GLX)

namespace WebCore {

class SharedGLXResources : public SharedX11Resources {
    WTF_MAKE_NONCOPYABLE(SharedGLXResources);

public:
    static PassRefPtr<SharedGLXResources> create()
    {
        if (!m_staticSharedResource)
            m_staticSharedResource = new SharedGLXResources();
        else
            m_staticSharedResource->ref();

        return adoptRef(m_staticSharedResource);
    }

    PlatformDisplay nativeDisplay()
    {
        return SharedX11Resources::x11Display();
    }

    virtual GLXFBConfig pBufferContextConfig()
    {
        if (!m_pbufferfbConfig) {
            static const int attributes[] = {
                GLX_LEVEL, 0,
                GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
                GLX_RENDER_TYPE,   GLX_RGBA_BIT,
                GLX_RED_SIZE,      1,
                GLX_GREEN_SIZE,    1,
                GLX_BLUE_SIZE,     1,
                GLX_DOUBLEBUFFER,  GL_FALSE,
                None
            };

            int numReturned;
            GLXFBConfig* temp = glXChooseFBConfig(nativeDisplay(), DefaultScreen(nativeDisplay()), attributes, &numReturned);
            if (numReturned)
                m_pbufferfbConfig = temp[0];
            XFree(temp);
        }

        return m_pbufferfbConfig;
    }

    virtual GLXFBConfig surfaceContextConfig()
    {
        if (!m_surfaceContextfbConfig) {
            static int attributes[] = {
                GLX_LEVEL, 0,
                GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
                GLX_RENDER_TYPE,   GLX_RGBA_BIT,
                GLX_RED_SIZE,      1,
                GLX_GREEN_SIZE,    1,
                GLX_BLUE_SIZE,     1,
                GLX_ALPHA_SIZE,    1,
                GLX_DEPTH_SIZE,    1,
                GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
                GLX_DOUBLEBUFFER,  True,
                None
            };

            m_surfaceContextfbConfig = createConfig(attributes);
        }

        return m_surfaceContextfbConfig;
    }

private:
    SharedGLXResources()
        : SharedX11Resources()
        , m_pbufferfbConfig(0)
        , m_surfaceContextfbConfig(0)
    {
    }

    GLXFBConfig createConfig(const int attributes[])
    {
        int numReturned;
        m_VisualInfo = 0;
        GLXFBConfig* temp = glXChooseFBConfig(nativeDisplay(), DefaultScreen(nativeDisplay()), attributes, &numReturned);

        if (!numReturned)
            return 0;

        GLXFBConfig selectedConfig = 0;
        bool found = false;

        for (int i = 0; i < numReturned; ++i) {
            m_VisualInfo = glXGetVisualFromFBConfig(nativeDisplay(), temp[i]);
            if (!m_VisualInfo)
                continue;
#if USE(GRAPHICS_SURFACE)
            if (m_supportsXRenderExtension) {
                XRenderPictFormat* format = XRenderFindVisualFormat(nativeDisplay(), m_VisualInfo->visual);
                if (format && format->direct.alphaMask > 0) {
                    selectedConfig = temp[i];
                    found = true;
                    break;
                }
            } else if (m_VisualInfo->depth == 32) {
#else
            if (m_VisualInfo->depth == 32) {
#endif
                selectedConfig = temp[i];
                found = true;
            }
        }

        // Did not find any visual supporting alpha, select the first available config.
        if (!found) {
            selectedConfig = temp[0];
            m_VisualInfo = glXGetVisualFromFBConfig(m_display, temp[0]);
        }

        XFree(temp);

        return selectedConfig;
    }

    virtual ~SharedGLXResources()
    {
        if (!m_display)
            return;

        if (m_pbufferfbConfig)
            m_pbufferfbConfig = 0;

        if (m_surfaceContextfbConfig)
            m_surfaceContextfbConfig = 0;
    }

    GLXFBConfig m_pbufferfbConfig;
    GLXFBConfig m_surfaceContextfbConfig;
};

}

#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 "X11WindowResources.h"

#if USE(ACCELERATED_COMPOSITING)

#include "GLXWindowResources.h"

namespace WebCore {

PlatformSharedResources* SharedX11Resources::m_staticSharedResource = 0;

X11OffScreenWindow::X11OffScreenWindow()
    : GLPlatformSurface()
{
    m_sharedResources = PlatformSharedResources::create();
    m_sharedDisplay = m_sharedResources->nativeDisplay();
}

X11OffScreenWindow::~X11OffScreenWindow()
{
}

void X11OffScreenWindow::setGeometry(const IntRect& newRect)
{
    GLPlatformSurface::setGeometry(newRect);
    XResizeWindow(m_sharedResources->x11Display(), m_drawable, newRect.width(), newRect.height());
}

void X11OffScreenWindow::createOffscreenWindow()
{
    Display* display = m_sharedResources->x11Display();
    if (!display)
        return;

    GLXFBConfig config = m_sharedResources->surfaceContextConfig();

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

    XVisualInfo* visInfo = m_sharedResources->visualInfo();

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

    Window xWindow = m_sharedResources->getXWindow();
    if (!xWindow)
        return;

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

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

    XSetWindowBackgroundPixmap(display, m_drawable, 0);
    XCompositeRedirectWindow(display, m_drawable, CompositeRedirectManual);

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

}

void X11OffScreenWindow::destroyWindow()
{
    if (!m_drawable)
        return;

    GLPlatformSurface::destroy();
    Display* display = sharedDisplay();
    if (!display)
        return;

    XDestroyWindow(display, m_drawable);
    m_drawable = 0;
}

}

#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 X11WindowResources_h
#define X11WindowResources_h

#if USE(ACCELERATED_COMPOSITING)

#include "GLPlatformSurface.h"

#if USE(GRAPHICS_SURFACE)
#include <X11/extensions/Xcomposite.h>
#include <X11/extensions/Xrender.h>
#endif

#include <wtf/Noncopyable.h>
#include <wtf/RefCounted.h>

namespace WebCore {

class SharedGLXResources;
typedef SharedGLXResources PlatformSharedResources;

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

public:
    void deref()
    {
        if (derefBase()) {
            m_staticSharedResource = 0;
            delete this;
        }
    }

    Display* x11Display()
    {
        if (!m_display) {
            m_display = XOpenDisplay(0);
            if (!m_display) {
                LOG_ERROR("Failed to make connection with X");
                return 0;
            }
#if USE(GRAPHICS_SURFACE)
            if (m_display) {
                int eventBasep, errorBasep;
                m_supportsXRenderExtension = XRenderQueryExtension(m_display, &eventBasep, &errorBasep);
            }
#endif
        }

        return m_display;
    }

    Window getXWindow()
    {
        if (!m_window) {
            Display* dpy = x11Display();
            XSetWindowAttributes attributes;
            attributes.override_redirect = true;
            m_window = XCreateSimpleWindow(dpy, XDefaultRootWindow(dpy), -1, -1, 1, 1, 0, BlackPixel(dpy, 0), WhitePixel(dpy, 0));
            // From http://tronche.com/gui/x/xlib/window/attributes/
            XChangeWindowAttributes(dpy, m_window, CWOverrideRedirect, &attributes);
            XMapWindow(dpy, m_window);

            if (!m_window) {
                LOG_ERROR("Failed to create SimpleWindow");
                return 0;
            }
        }

        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)
    {
    }

    virtual ~SharedX11Resources()
    {
        if (!m_display)
            return;

        if (m_window) {
            XUnmapWindow(m_display, m_window);
            XDestroyWindow(m_display, m_window);
            m_window = 0;
        }

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

        XCloseDisplay(m_display);
        m_display = 0;
    }

    static PlatformSharedResources* m_staticSharedResource;
    bool m_supportsXRenderExtension;
    Window m_window;
    Display* m_display;
    XVisualInfo* m_VisualInfo;
};

class X11OffScreenWindow : public GLPlatformSurface {
    WTF_MAKE_NONCOPYABLE(X11OffScreenWindow);

public:
    X11OffScreenWindow();
    virtual ~X11OffScreenWindow();
    void setGeometry(const IntRect&);
    void createOffscreenWindow();
    void destroyWindow();

protected:
    RefPtr<PlatformSharedResources> m_sharedResources;
};

}

#endif

#endif

Return to Bug 105357

Lines 30-80 Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec1
- Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp -94 / +12 lines
30		30
31	namespace WebCore {	31	namespace WebCore {
32		32
33	SharedX11Resources* SharedX11Resources::m_staticSharedResource = 0;
34
35	static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };	33	static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };
36		34
37	GLXSurface::GLXSurface()
38	: GLPlatformSurface()
39	{
40	m_sharedResources = SharedX11Resources::create();
41	m_sharedDisplay = m_sharedResources->display();
42	}
43
44	GLXSurface::~GLXSurface()
45	{
46	}
47
48	XVisualInfo* GLXSurface::visualInfo()
49	{
50	return m_sharedResources->visualInfo();
51	}
52
53	Window GLXSurface::xWindow()
54	{
55	return m_sharedResources->getXWindow();
56	}
57
58	GLXFBConfig GLXSurface::pBufferConfiguration()
59	{
60	return m_sharedResources->pBufferContextConfig();
61	}
62
63	GLXFBConfig GLXSurface::transportSurfaceConfiguration()
64	{
65	return m_sharedResources->surfaceContextConfig();
66	}
67
68	bool GLXSurface::isXRenderExtensionSupported()
69	{
70	return m_sharedResources->isXRenderExtensionSupported();
71	}
72
73	#if USE(GRAPHICS_SURFACE)	35	#if USE(GRAPHICS_SURFACE)
74	GLXTransportSurface::GLXTransportSurface()	36	GLXTransportSurface::GLXTransportSurface()
75	: GLXSurface()	37	: X11OffScreenWindow()
76	{	38	{
77	initialize();	39	createOffscreenWindow();
78	}	40	}
79		41
80	GLXTransportSurface::~GLXTransportSurface()	42	GLXTransportSurface::~GLXTransportSurface()
Lines 83-89 GLXTransportSurface::~GLXTransportSurface() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec2
83		45
84	PlatformSurfaceConfig GLXTransportSurface::configuration()	46	PlatformSurfaceConfig GLXTransportSurface::configuration()
85	{	47	{
86	return transportSurfaceConfiguration();	48	return m_sharedResources->surfaceContextConfig();
87	}	49	}
88		50
89	void GLXTransportSurface::swapBuffers()	51	void GLXTransportSurface::swapBuffers()
Lines 101-164 void GLXTransportSurface::swapBuffers() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec3
101	glXSwapBuffers(sharedDisplay(), m_drawable);	63	glXSwapBuffers(sharedDisplay(), m_drawable);
102	}	64	}
103		65
104	void GLXTransportSurface::setGeometry(const IntRect& newRect)
105	{
106	GLPlatformSurface::setGeometry(newRect);
107	int width = newRect.width();
108	int height = newRect.height();
109	XResizeWindow(sharedDisplay(), m_drawable, width, height);
110	}
111
112	void GLXTransportSurface::initialize()
113	{
114	Display* display = sharedDisplay();
115	GLXFBConfig config = transportSurfaceConfiguration();
116	if (!config)
117	return;
118
119	XVisualInfo* visInfo = visualInfo();
120	if (!visInfo)
121	return;
122
123	Colormap cmap = XCreateColormap(display, xWindow(), visInfo->visual, AllocNone);
124	XSetWindowAttributes attribute;
125	attribute.background_pixel = WhitePixel(display, 0);
126	attribute.border_pixel = BlackPixel(display, 0);
127	attribute.colormap = cmap;
128	m_drawable = XCreateWindow(display, xWindow(), 0, 0, 1, 1, 0, visInfo->depth, InputOutput, visInfo->visual, CWBackPixel \| CWBorderPixel \| CWColormap, &attribute);
129	if (!m_drawable)
130	return;
131
132	XSetWindowBackgroundPixmap(display, m_drawable, 0);
133	XCompositeRedirectWindow(display, m_drawable, CompositeRedirectManual);
134
135	if (isXRenderExtensionSupported())
136	XMapWindow(display, m_drawable);
137	}
138
139	void GLXTransportSurface::destroy()	66	void GLXTransportSurface::destroy()
140	{	67	{
141	freeResources();	68	destroyWindow();
142	GLPlatformSurface::destroy();
143	}	69	}
144		70
145	void GLXTransportSurface::freeResources()
146	{
147	if (!m_drawable)
148	return;
149
150	GLPlatformSurface::destroy();
151	Display* display = sharedDisplay();
152	if (!display)
153	return;
154
155	XDestroyWindow(display, m_drawable);
156	m_drawable = 0;
157	}
158	#endif	71	#endif
159		72
160	GLXPBuffer::GLXPBuffer()	73	GLXPBuffer::GLXPBuffer()
161	: GLXSurface()	74	: X11OffScreenWindow()
162	{	75	{
163	initialize();	76	initialize();
164	}	77	}
Lines 170-176 GLXPBuffer::~GLXPBuffer() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec4
170	void GLXPBuffer::initialize()	83	void GLXPBuffer::initialize()
171	{	84	{
172	Display* display = sharedDisplay();	85	Display* display = sharedDisplay();
173	GLXFBConfig config = pBufferConfiguration();	86	GLXFBConfig config = m_sharedResources->pBufferContextConfig();
174	if (!config)	87	if (!config)
175	return;	88	return;
176		89
Lines 179-185 void GLXPBuffer::initialize() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec5
179		92
180	PlatformSurfaceConfig GLXPBuffer::configuration()	93	PlatformSurfaceConfig GLXPBuffer::configuration()
181	{	94	{
182	return pBufferConfiguration();	95	return m_sharedResources->pBufferContextConfig();
183	}	96	}
184		97
185	void GLXPBuffer::destroy()	98	void GLXPBuffer::destroy()
Lines 201-206 void GLXPBuffer::freeResources() Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec6
201	m_drawable = 0;	114	m_drawable = 0;
202	}	115	}
203		116
		117	void GLXPBuffer::setGeometry(const IntRect& newRect)
		118	{
		119	GLPlatformSurface::setGeometry(newRect);
		120	}
		121
204	}	122	}
205		123
206	#endif	124	#endif

Line 0 Source/WebCore/platform/graphics/surfaces/glx/GLXWindowResources.h_sec1
- Source/WebCore/platform/graphics/surfaces/glx/GLXWindowResources.h +173 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	#ifndef GLXWindowResources_h
		27	#define GLXWindowResources_h
		28
		29	#include "X11WindowResources.h"
		30
		31	#if USE(ACCELERATED_COMPOSITING) && HAVE(GLX)
		32
		33	namespace WebCore {
		34
		35	class SharedGLXResources : public SharedX11Resources {
		36	WTF_MAKE_NONCOPYABLE(SharedGLXResources);
		37
		38	public:
		39	static PassRefPtr<SharedGLXResources> create()
		40	{
		41	if (!m_staticSharedResource)
		42	m_staticSharedResource = new SharedGLXResources();
		43	else
		44	m_staticSharedResource->ref();
		45
		46	return adoptRef(m_staticSharedResource);
		47	}
		48
		49	PlatformDisplay nativeDisplay()
		50	{
		51	return SharedX11Resources::x11Display();
		52	}
		53
		54	virtual GLXFBConfig pBufferContextConfig()
		55	{
		56	if (!m_pbufferfbConfig) {
		57	static const int attributes[] = {
		58	GLX_LEVEL, 0,
		59	GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
		60	GLX_RENDER_TYPE, GLX_RGBA_BIT,
		61	GLX_RED_SIZE, 1,
		62	GLX_GREEN_SIZE, 1,
		63	GLX_BLUE_SIZE, 1,
		64	GLX_DOUBLEBUFFER, GL_FALSE,
65	None
66	};
67
68	int numReturned;
69	GLXFBConfig* temp = glXChooseFBConfig(nativeDisplay(), DefaultScreen(nativeDisplay()), attributes, &numReturned);
70	if (numReturned)
71	m_pbufferfbConfig = temp[0];
72	XFree(temp);
73	}
74
75	return m_pbufferfbConfig;
76	}
77
78	virtual GLXFBConfig surfaceContextConfig()
79	{
80	if (!m_surfaceContextfbConfig) {
81	static int attributes[] = {
82	GLX_LEVEL, 0,
83	GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
84	GLX_RENDER_TYPE, GLX_RGBA_BIT,
85	GLX_RED_SIZE, 1,
86	GLX_GREEN_SIZE, 1,
87	GLX_BLUE_SIZE, 1,
88	GLX_ALPHA_SIZE, 1,
89	GLX_DEPTH_SIZE, 1,
90	GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
91	GLX_DOUBLEBUFFER, True,
92	None
93	};
94
95	m_surfaceContextfbConfig = createConfig(attributes);
96	}
97
98	return m_surfaceContextfbConfig;
99	}
100
101	private:
102	SharedGLXResources()
103	: SharedX11Resources()
104	, m_pbufferfbConfig(0)
105	, m_surfaceContextfbConfig(0)
106	{
107	}
108
109	GLXFBConfig createConfig(const int attributes[])
110	{
111	int numReturned;
112	m_VisualInfo = 0;
113	GLXFBConfig* temp = glXChooseFBConfig(nativeDisplay(), DefaultScreen(nativeDisplay()), attributes, &numReturned);
114
115	if (!numReturned)
116	return 0;
117
118	GLXFBConfig selectedConfig = 0;
119	bool found = false;
120
121	for (int i = 0; i < numReturned; ++i) {
122	m_VisualInfo = glXGetVisualFromFBConfig(nativeDisplay(), temp[i]);
123	if (!m_VisualInfo)
124	continue;
125	#if USE(GRAPHICS_SURFACE)
126	if (m_supportsXRenderExtension) {
127	XRenderPictFormat* format = XRenderFindVisualFormat(nativeDisplay(), m_VisualInfo->visual);
128	if (format && format->direct.alphaMask > 0) {
129	selectedConfig = temp[i];
130	found = true;
131	break;
132	}
133	} else if (m_VisualInfo->depth == 32) {
134	#else
135	if (m_VisualInfo->depth == 32) {
136	#endif
137	selectedConfig = temp[i];
138	found = true;
139	}
140	}
141
142	// Did not find any visual supporting alpha, select the first available config.
143	if (!found) {
144	selectedConfig = temp[0];
145	m_VisualInfo = glXGetVisualFromFBConfig(m_display, temp[0]);
146	}
147
148	XFree(temp);
149
150	return selectedConfig;
151	}
152
153	virtual ~SharedGLXResources()
154	{
155	if (!m_display)
156	return;
157
158	if (m_pbufferfbConfig)
159	m_pbufferfbConfig = 0;
160
161	if (m_surfaceContextfbConfig)
162	m_surfaceContextfbConfig = 0;
163	}
164
165	GLXFBConfig m_pbufferfbConfig;
166	GLXFBConfig m_surfaceContextfbConfig;
167	};
168
169	}
170
171	#endif
172
173	#endif

Line 0 Source/WebCore/platform/graphics/surfaces/glx/X11WindowResources.h_sec1
- Source/WebCore/platform/graphics/surfaces/glx/X11WindowResources.h +168 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	#ifndef X11WindowResources_h
		27	#define X11WindowResources_h
		28
		29	#if USE(ACCELERATED_COMPOSITING)
		30
		31	#include "GLPlatformSurface.h"
		32
		33	#if USE(GRAPHICS_SURFACE)
		34	#include <X11/extensions/Xcomposite.h>
		35	#include <X11/extensions/Xrender.h>
		36	#endif
		37
		38	#include <wtf/Noncopyable.h>
		39	#include <wtf/RefCounted.h>
		40
		41	namespace WebCore {
		42
		43	class SharedGLXResources;
		44	typedef SharedGLXResources PlatformSharedResources;
		45
		46	class SharedX11Resources : public WTF::RefCountedBase {
		47	WTF_MAKE_NONCOPYABLE(SharedX11Resources);
		48
		49	public:
		50	void deref()
		51	{
		52	if (derefBase()) {
		53	m_staticSharedResource = 0;
		54	delete this;
		55	}
		56	}
		57
		58	Display* x11Display()
		59	{
		60	if (!m_display) {
		61	m_display = XOpenDisplay(0);
		62	if (!m_display) {
		63	LOG_ERROR("Failed to make connection with X");
		64	return 0;
65	}
66	#if USE(GRAPHICS_SURFACE)
67	if (m_display) {
68	int eventBasep, errorBasep;
69	m_supportsXRenderExtension = XRenderQueryExtension(m_display, &eventBasep, &errorBasep);
70	}
71	#endif
72	}
73
74	return m_display;
75	}
76
77	Window getXWindow()
78	{
79	if (!m_window) {
80	Display* dpy = x11Display();
81	XSetWindowAttributes attributes;
82	attributes.override_redirect = true;
83	m_window = XCreateSimpleWindow(dpy, XDefaultRootWindow(dpy), -1, -1, 1, 1, 0, BlackPixel(dpy, 0), WhitePixel(dpy, 0));
84	// From http://tronche.com/gui/x/xlib/window/attributes/
85	XChangeWindowAttributes(dpy, m_window, CWOverrideRedirect, &attributes);
86	XMapWindow(dpy, m_window);
87
88	if (!m_window) {
89	LOG_ERROR("Failed to create SimpleWindow");
90	return 0;
91	}
92	}
93
94	return m_window;
95	}
96
97	XVisualInfo* visualInfo()
98	{
99	if (!m_VisualInfo)
100	surfaceContextConfig();
101
102	return m_VisualInfo;
103	}
104
105	bool isXRenderExtensionSupported()
106	{
107	return m_supportsXRenderExtension;
108	}
109
110	virtual PlatformSurfaceConfig pBufferContextConfig() = 0;
111	virtual PlatformSurfaceConfig surfaceContextConfig() = 0;
112	virtual PlatformDisplay nativeDisplay() = 0;
113
114	protected:
115	SharedX11Resources()
116	: m_supportsXRenderExtension(false)
117	, m_window(0)
118	, m_display(0)
119	, m_VisualInfo(0)
120	{
121	}
122
123	virtual ~SharedX11Resources()
124	{
125	if (!m_display)
126	return;
127
128	if (m_window) {
129	XUnmapWindow(m_display, m_window);
130	XDestroyWindow(m_display, m_window);
131	m_window = 0;
132	}
133
134	if (m_VisualInfo) {
135	XFree(m_VisualInfo);
136	m_VisualInfo = 0;
137	}
138
139	XCloseDisplay(m_display);
140	m_display = 0;
141	}
142
143	static PlatformSharedResources* m_staticSharedResource;
144	bool m_supportsXRenderExtension;
145	Window m_window;
146	Display* m_display;
147	XVisualInfo* m_VisualInfo;
148	};
149
150	class X11OffScreenWindow : public GLPlatformSurface {
151	WTF_MAKE_NONCOPYABLE(X11OffScreenWindow);
152
153	public:
154	X11OffScreenWindow();
155	virtual ~X11OffScreenWindow();
156	void setGeometry(const IntRect&);
157	void createOffscreenWindow();
158	void destroyWindow();
159
160	protected:
161	RefPtr<PlatformSharedResources> m_sharedResources;
162	};
163
164	}
165
166	#endif
167
168	#endif

Lines 1-3 Source/WebCore/ChangeLog_sec1
- Source/WebCore/ChangeLog +56 lines
		1	2012-12-19 Kondapally Kalyan <kalyan.kondapally@intel.com>
		2
		3	[EFL][WebGL] Refactor GLXSurface.
		4	https://bugs.webkit.org/show_bug.cgi?id=105357
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	This is in preparation for adding EGL support.
		9	There is lot of X related code which could be shared between our current GLX implementation
		10	and EGL. This patch makes it possible to share the common code but doesn't change any functionality.
		11
		12	* PlatformEfl.cmake:
		13	* platform/graphics/surfaces/glx/GLXSurface.cpp:
		14	(WebCore):
		15	(WebCore::GLXTransportSurface::GLXTransportSurface):
		16	(WebCore::GLXTransportSurface::configuration):
		17	(WebCore::GLXTransportSurface::destroy):
		18	(WebCore::GLXTransportSurface::freeResources):
		19	(WebCore::GLXPBuffer::GLXPBuffer):
		20	(WebCore::GLXPBuffer::initialize):
		21	(WebCore::GLXPBuffer::configuration):
		22	(WebCore::GLXPBuffer::setGeometry):
		23	* platform/graphics/surfaces/glx/GLXSurface.h:
		24	(GLXTransportSurface):
		25	(GLXPBuffer):
		26
		27	GLX related implementation.
		28	* platform/graphics/surfaces/glx/GLXWindowResources.h: Added.
		29	(WebCore):
		30	(SharedGLXResources):
		31	(WebCore::SharedGLXResources::create):
		32	(WebCore::SharedGLXResources::nativeDisplay):
		33	(WebCore::SharedGLXResources::pBufferContextConfig):
		34	(WebCore::SharedGLXResources::surfaceContextConfig):
		35	(WebCore::SharedGLXResources::SharedGLXResources):
		36	(WebCore::SharedGLXResources::createConfig):
		37
		38	Moving X related code to a seperate class.
		39	* platform/graphics/surfaces/glx/X11WindowResources.cpp: Added.
		40	(WebCore):
		41	(WebCore::X11OffScreenWindow::X11OffScreenWindow):
		42	(WebCore::X11OffScreenWindow::~X11OffScreenWindow):
		43	(WebCore::X11OffScreenWindow::setGeometry):
		44	(WebCore::X11OffScreenWindow::createOffscreenWindow):
		45	* platform/graphics/surfaces/glx/X11WindowResources.h: Added.
		46	(WebCore):
		47	(SharedX11Resources):
		48	(WebCore::SharedX11Resources::deref):
		49	(WebCore::SharedX11Resources::x11Display):
		50	(WebCore::SharedX11Resources::getXWindow):
		51	(WebCore::SharedX11Resources::visualInfo):
		52	(WebCore::SharedX11Resources::isXRenderExtensionSupported):
		53	(WebCore::SharedX11Resources::SharedX11Resources):
		54	(WebCore::SharedX11Resources::~SharedX11Resources):
		55	(X11OffScreenWindow):
		56
1	2012-12-18 Mark Lam <mark.lam@apple.com>	57	2012-12-18 Mark Lam <mark.lam@apple.com>
2		58
3	Fixed bad merge in "Initial refactoring of database functionality into the manager and server".	59	Fixed bad merge in "Initial refactoring of database functionality into the manager and server".