Attachment #252809 for bug #144521

View Details Raw Unified Return to Bug 144521

| Differences between



2015-05-08  Carlos Garcia Campos  <cgarcia@igalia.com>

        [X11] Add XUniquePtr and XUniqueResource to automatically free X resources
        https://bugs.webkit.org/show_bug.cgi?id=144521

        Reviewed by Darin Adler.

        Add XUniquePtr as a template alias of std:unique_ptr to handle X
        resources using pointers and XUniqueResource as a new class to
        handle X resources using a long unsigned identifier. This
        simplifies the code and makes it more difficult to leak X resources.

        * PlatformEfl.cmake: Add new files to compilation.
        * PlatformGTK.cmake: Ditto.
        * platform/graphics/cairo/BackingStoreBackendCairoX11.cpp:
        (WebCore::BackingStoreBackendCairoX11::BackingStoreBackendCairoX11):
        Remove the display member, and use XUnique for Pixmap and GC.
        (WebCore::BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11):
        Remove code to explicitly free Pixmap and GC.
        (WebCore::BackingStoreBackendCairoX11::scroll):
        * platform/graphics/cairo/BackingStoreBackendCairoX11.h:
        * platform/graphics/glx/GLContextGLX.cpp:
        (WebCore::GLContextGLX::createWindowContext): Use XUnique and the
        new constructor that receives a XID, since there's no longer
        conflict with the one receiving a Pbuffer.
        (WebCore::GLContextGLX::createPbufferContext): Use XUnique and the
        new constructor that receives a XUniqueGLXPbuffer&&.
        (WebCore::GLContextGLX::createPixmapContext):
        (WebCore::GLContextGLX::createContext):
        (WebCore::GLContextGLX::GLContextGLX):
        (WebCore::GLContextGLX::~GLContextGLX): Remove code to explicitly
        free X resources.
        (WebCore::GLContextGLX::makeContextCurrent):
        (WebCore::GLContextGLX::cairoDevice):
        (WebCore::GLContextGLX::platformContext):
        * platform/graphics/glx/GLContextGLX.h:
        * platform/graphics/surfaces/egl/EGLXSurface.cpp:
        (WebCore::EGLXTransportSurfaceClient::EGLXTransportSurfaceClient):
        (WebCore::EGLXTransportSurfaceClient::destroy):
        (WebCore::EGLXTransportSurfaceClient::prepareTexture):
        * platform/graphics/surfaces/egl/EGLXSurface.h:
        * platform/graphics/surfaces/glx/GLXConfigSelector.h:
        (WebCore::GLXConfigSelector::findMatchingConfig): Use XUnique
        instead of the custom std::unique X11Deleter.
        (WebCore::GLXConfigSelector::findMatchingConfigWithVisualId): Ditto.
        * platform/graphics/surfaces/glx/GLXSurface.cpp:
        (WebCore::GLXTransportSurface::GLXTransportSurface): Ditto.
        (WebCore::GLXOffScreenSurface::initialize):
        * platform/graphics/surfaces/glx/X11Helper.cpp:
        (WebCore::X11Helper::createOffScreenWindow): Ditto.
        (WebCore::X11Helper::createPixmap): Ditto.
        * platform/graphics/surfaces/glx/X11Helper.h:
        * platform/graphics/x11/XUniquePtr.h: Remove X11Deleter.
        (WebCore::XPtrDeleter::operator()):
        * platform/graphics/x11/XUniqueResource.cpp: Added.
        (WebCore::XUniqueResource<XResource::Colormap>::deleteXResource):
        (WebCore::XUniqueResource<XResource::Damage>::deleteXResource):
        (WebCore::XUniqueResource<XResource::Pixmap>::deleteXResource):
        (WebCore::XUniqueResource<XResource::Window>::deleteXResource):
        (WebCore::XUniqueResource<XResource::GLXPbuffer>::deleteXResource):
        (WebCore::XUniqueResource<XResource::GLXPixmap>::deleteXResource):
        * platform/graphics/x11/XUniqueResource.h: Added.
        (WebCore::XUniqueResource::XUniqueResource):
        (WebCore::XUniqueResource::operator=):
        (WebCore::XUniqueResource::~XUniqueResource):
        (WebCore::XUniqueResource::get):
        (WebCore::XUniqueResource::release):
        (WebCore::XUniqueResource::reset):
        (WebCore::XUniqueResource::operator!):
        (WebCore::XUniqueResource::operator UnspecifiedBoolType*):

2015-05-05  Carlos Garcia Campos  <cgarcia@igalia.com>

        [SOUP] Network Cache: Implement ShareableResource for Soup and enable it for GTK platform

Lines 197-202 list(APPEND WebCore_SOURCES a/Source/WebCore/PlatformEfl.cmake_sec1
- a/Source/WebCore/PlatformEfl.cmake +1 lines
197	platform/graphics/texmap/coordinated/UpdateAtlas.cpp	197	platform/graphics/texmap/coordinated/UpdateAtlas.cpp
198		198
199	platform/graphics/x11/PlatformDisplayX11.cpp	199	platform/graphics/x11/PlatformDisplayX11.cpp
		200	platform/graphics/x11/XUniqueResource.cpp
200		201
201	platform/image-decoders/ImageDecoder.cpp	202	platform/image-decoders/ImageDecoder.cpp
202		203

Lines 126-131 list(APPEND WebCore_SOURCES a/Source/WebCore/PlatformGTK.cmake_sec1
- a/Source/WebCore/PlatformGTK.cmake +1 lines
126	platform/graphics/opentype/OpenTypeVerticalData.cpp	126	platform/graphics/opentype/OpenTypeVerticalData.cpp
127		127
128	platform/graphics/x11/PlatformDisplayX11.cpp	128	platform/graphics/x11/PlatformDisplayX11.cpp
		129	platform/graphics/x11/XUniqueResource.cpp
129		130
130	platform/gtk/ErrorsGtk.cpp	131	platform/gtk/ErrorsGtk.cpp
131	platform/gtk/EventLoopGtk.cpp	132	platform/gtk/EventLoopGtk.cpp




namespace WebCore {

BackingStoreBackendCairoX11::BackingStoreBackendCairoX11(unsigned long rootWindowID, Visual* visual, int depth, const IntSize& size, float deviceScaleFactor)
    : BackingStoreBackendCairo(size)
    , m_display(display)
{
    IntSize scaledSize = size;
    scaledSize.scale(deviceScaleFactor);

    auto* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
    m_pixmap = XCreatePixmap(display, rootWindowID, scaledSize.width(), scaledSize.height(), depth);
    m_gc.reset(XCreateGC(display, m_pixmap.get(), 0, nullptr));

    m_surface = adoptRef(cairo_xlib_surface_create(display, m_pixmap.get(), visual, scaledSize.width(), scaledSize.height()));
    cairoSurfaceSetDeviceScale(m_surface.get(), deviceScaleFactor, deviceScaleFactor);
}


{
    // The pixmap needs to exist when the surface is destroyed, so begin by clearing it.
    m_surface.clear();
    XFreePixmap(m_display, m_pixmap);
    XFreeGC(m_display, m_gc);
}

void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSize& scrollOffset)

    scaledScrollOffset.scale(xScale, yScale);

    cairo_surface_flush(m_surface.get());
    XCopyArea(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), m_pixmap.get(), m_pixmap.get(), m_gc.get(),
        targetRect.x() - scaledScrollOffset.width(), targetRect.y() - scaledScrollOffset.height(),
        targetRect.width(), targetRect.height(), targetRect.x(), targetRect.y());
    cairo_surface_mark_dirty_rectangle(m_surface.get(), targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height());



#include "BackingStoreBackendCairo.h"

#if USE(CAIRO) && PLATFORM(X11)
#include "XUniquePtr.h"
#include "XUniqueResource.h"

namespace WebCore {

class BackingStoreBackendCairoX11 final : public BackingStoreBackendCairo {
public:
    BackingStoreBackendCairoX11(unsigned long rootWindowID, Visual*, int depth, const IntSize&, float deviceScaleFactor);
    virtual ~BackingStoreBackendCairoX11();

    void scroll(const IntRect& scrollRect, const IntSize& scrollOffset) override;

private:
    XUniquePixmap m_pixmap;
    XUniqueGC m_gc;
    GC m_gc;
};

} // namespace WebCore



    visualInfo.visualid = XVisualIDFromVisual(attributes.visual);

    int numReturned = 0;
    XUniquePtr<XVisualInfo> visualInfoList(XGetVisualInfo(display, VisualIDMask, &visualInfo, &numReturned));

    GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context : 0;
    GLXContext context = glXCreateContext(display, visualInfoList, glxSharingContext, True);
    XFree(visualInfoList);

    GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context.get() : nullptr;
    XUniqueGLXContext context(glXCreateContext(display, visualInfoList.get(), glxSharingContext, True));
    if (!context)
        return nullptr;

    return std::make_unique<GLContextGLX>(WTF::move(context), window);
    // a constructor here with the window path.
    auto contextWrapper = std::make_unique<GLContextGLX>(context);
    contextWrapper->m_window = window;
    return WTF::move(contextWrapper);
}

std::unique_ptr<GLContextGLX> GLContextGLX::createPbufferContext(GLXContext sharingContext)
{
    static const int fbConfigAttributes[] = {
        GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
        GLX_RENDER_TYPE, GLX_RGBA_BIT,
        GLX_RED_SIZE, 1,


    int returnedElements;
    Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
    XUniquePtr<GLXFBConfig> configs(glXChooseFBConfig(display, 0, fbConfigAttributes, &returnedElements));
    if (!returnedElements)
        XFree(configs);
        return nullptr;
    }

    // We will be rendering to a texture, so our pbuffer does not need to be large.
    static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };
    XUniqueGLXPbuffer pbuffer(glXCreatePbuffer(display, configs.get()[0], pbufferAttributes));
    if (!pbuffer)
        XFree(configs);
        return nullptr;
    }

    XUniqueGLXContext context(glXCreateNewContext(display, configs.get()[0], GLX_RGBA_TYPE, sharingContext, GL_TRUE));
    if (!context)
    if (!context) {
        glXDestroyPbuffer(display, pbuffer);
        return nullptr;
    }

    return std::make_unique<GLContextGLX>(WTF::move(context), WTF::move(pbuffer));
    // a constructor here with the window path.
    auto contextWrapper = std::make_unique<GLContextGLX>(context);
    contextWrapper->m_pbuffer = pbuffer;
    return WTF::move(contextWrapper);
}

std::unique_ptr<GLContextGLX> GLContextGLX::createPixmapContext(GLXContext sharingContext)

    };

    Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
    XUniquePtr<XVisualInfo> visualInfo(glXChooseVisual(display, DefaultScreen(display), visualAttributes));
    if (!visualInfo)
        return nullptr;

    XUniqueGLXContext context(glXCreateContext(display, visualInfo.get(), sharingContext, GL_TRUE));
    if (!context)
        XFree(visualInfo);
        return nullptr;
    }

    XUniquePixmap pixmap(XCreatePixmap(display, DefaultRootWindow(display), 1, 1, visualInfo->depth));
    if (!pixmap)
        XFree(visualInfo);
        return nullptr;
    }

    XUniqueGLXPixmap glxPixmap(glXCreateGLXPixmap(display, visualInfo.get(), pixmap.get()));
    if (!glxPixmap)
        XFreePixmap(display, pixmap);
        XFree(visualInfo);
        return nullptr;
    }

    return std::make_unique<GLContextGLX>(WTF::move(context), WTF::move(pixmap), WTF::move(glxPixmap));
    return std::make_unique<GLContextGLX>(context, pixmap, glxPixmap);
}

std::unique_ptr<GLContextGLX> GLContextGLX::createContext(XID window, GLContext* sharingContext)

    if (!success)
        return nullptr;

    GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context.get() : nullptr;
    auto context = window ? createWindowContext(window, sharingContext) : nullptr;
    if (!context)
        context = createPbufferContext(glxSharingContext);

    return WTF::move(context);
}

GLContextGLX::GLContextGLX(XUniqueGLXContext&& context, XID window)
    : m_context(WTF::move(context))
    , m_window(window)
    , m_pbuffer(0)
    , m_pixmap(0)
    , m_glxPixmap(0)
    , m_cairoDevice(0)
{
}

GLContextGLX::GLContextGLX(XUniqueGLXContext&& context, XUniqueGLXPbuffer&& pbuffer)
    : m_context(WTF::move(context))
    , m_pbuffer(WTF::move(pbuffer))
{
}

GLContextGLX::GLContextGLX(XUniqueGLXContext&& context, XUniquePixmap&& pixmap, XUniqueGLXPixmap&& glxPixmap)
    : m_context(WTF::move(context))
    , m_pixmap(WTF::move(pixmap))
    , m_glxPixmap(WTF::move(glxPixmap))
{
}


    if (m_cairoDevice)
        cairo_device_destroy(m_cairoDevice);

    Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
    if (m_context) {
        // This may be necessary to prevent crashes with NVidia's closed source drivers. Originally
        // from Mozilla's 3D canvas implementation at: http://bitbucket.org/ilmari/canvas3d/
        Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
        glXMakeCurrent(display, None, None);
        glXDestroyContext(display, m_context);
    }

    if (m_pbuffer) {
        glXDestroyPbuffer(display, m_pbuffer);
        m_pbuffer = 0;
    }
    if (m_glxPixmap) {
        glXDestroyGLXPixmap(display, m_glxPixmap);
        m_glxPixmap = 0;
    }
    if (m_pixmap) {
        XFreePixmap(display, m_pixmap);
        m_pixmap = 0;
    }
}


    ASSERT(m_context && (m_window || m_pbuffer || m_glxPixmap));

    GLContext::makeContextCurrent();
    if (glXGetCurrentContext() == m_context.get())
        return true;

    Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
    if (m_window)
        return glXMakeCurrent(display, m_window, m_context.get());

    if (m_pbuffer)
        return glXMakeCurrent(display, m_pbuffer.get(), m_context.get());

    return ::glXMakeCurrent(display, m_glxPixmap.get(), m_context.get());
}

void GLContextGLX::swapBuffers()

        return m_cairoDevice;

#if ENABLE(ACCELERATED_2D_CANVAS)
    m_cairoDevice = cairo_glx_device_create(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), m_context.get());
#endif

    return m_cairoDevice;

#if ENABLE(GRAPHICS_CONTEXT_3D)
PlatformGraphicsContext3D GLContextGLX::platformContext()
{
    return m_context.get();
}
#endif


Lines 23-34 a/Source/WebCore/platform/graphics/glx/GLContextGLX.h_sec1
- a/Source/WebCore/platform/graphics/glx/GLContextGLX.h -12 / +11 lines
23	#if USE(GLX)	23	#if USE(GLX)
24		24
25	#include "GLContext.h"	25	#include "GLContext.h"
		26	#include "XUniquePtr.h"
		27	#include "XUniqueResource.h"
26		28
27	typedef struct __GLXcontextRec* GLXContext;
28	typedef unsigned long GLXPbuffer;
29	typedef unsigned long GLXPixmap;
30	typedef unsigned char GLubyte;	29	typedef unsigned char GLubyte;
31	typedef unsigned long Pixmap;
32	typedef unsigned long XID;	30	typedef unsigned long XID;
33	typedef void* ContextKeyType;	31	typedef void* ContextKeyType;
34		32
Lines 40-47 public: a/Source/WebCore/platform/graphics/glx/GLContextGLX.h_sec2
40	static std::unique_ptr<GLContextGLX> createContext(XID window, GLContext* sharingContext);	38	static std::unique_ptr<GLContextGLX> createContext(XID window, GLContext* sharingContext);
41	static std::unique_ptr<GLContextGLX> createWindowContext(XID window, GLContext* sharingContext);	39	static std::unique_ptr<GLContextGLX> createWindowContext(XID window, GLContext* sharingContext);
42		40
43	GLContextGLX(GLXContext);	41	GLContextGLX(XUniqueGLXContext&&, XID);
44	GLContextGLX(GLXContext, Pixmap, GLXPixmap);	42	GLContextGLX(XUniqueGLXContext&&, XUniqueGLXPbuffer&&);
		43	GLContextGLX(XUniqueGLXContext&&, XUniquePixmap&&, XUniqueGLXPixmap&&);
45	virtual ~GLContextGLX();	44	virtual ~GLContextGLX();
46	virtual bool makeContextCurrent();	45	virtual bool makeContextCurrent();
47	virtual void swapBuffers();	46	virtual void swapBuffers();
Lines 59-70 private: a/Source/WebCore/platform/graphics/glx/GLContextGLX.h_sec3
59	static std::unique_ptr<GLContextGLX> createPbufferContext(GLXContext sharingContext);	58	static std::unique_ptr<GLContextGLX> createPbufferContext(GLXContext sharingContext);
60	static std::unique_ptr<GLContextGLX> createPixmapContext(GLXContext sharingContext);	59	static std::unique_ptr<GLContextGLX> createPixmapContext(GLXContext sharingContext);
61		60
62	GLXContext m_context;	61	XUniqueGLXContext m_context;
63	XID m_window;	62	XID m_window { 0 };
64	GLXPbuffer m_pbuffer;	63	XUniqueGLXPbuffer m_pbuffer;
65	Pixmap m_pixmap;	64	XUniquePixmap m_pixmap;
66	GLXPixmap m_glxPixmap;	65	XUniqueGLXPixmap m_glxPixmap;
67	cairo_device_t* m_cairoDevice;	66	cairo_device_t* m_cairoDevice { nullptr };
68	};	67	};
69		68
70	} // namespace WebCore	69	} // namespace WebCore




EGLXTransportSurfaceClient::EGLXTransportSurfaceClient(const PlatformBufferHandle handle, const IntSize& size, bool hasAlpha)
    : GLTransportSurfaceClient()
    , m_image(0)
    , m_size(size)
    , m_totalBytes(0)
{

    }

    eglWaitGL();
    m_image = nullptr;
    if (m_image) {
        XDestroyImage(m_image);
        m_image = 0;
    }
}

void EGLXTransportSurfaceClient::prepareTexture()

    }

    // Fallback to use XImage in case EGLImage and TextureToPixmap are not supported.
    m_image.reset(XGetImage(NativeWrapper::nativeDisplay(), m_handle, 0, 0, m_size.width(), m_size.height(), AllPlanes, ZPixmap));

#if USE(OPENGL_ES_2)
    if (m_format != GraphicsContext3D::BGRA) {


    glTexImage2D(GL_TEXTURE_2D, 0, m_format, m_size.width(), m_size.height(), 0, m_format, GL_UNSIGNED_BYTE, m_image->data);

    m_image = nullptr;
        XDestroyImage(m_image);
        m_image = 0;
    }
}

EGLTextureFromPixmap::EGLTextureFromPixmap(const NativePixmap handle, bool hasAlpha, EGLConfig config)



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

#include "EGLSurface.h"
#include "XUniquePtr.h"
#include <glx/X11Helper.h>

namespace WebCore {

typedef X11Helper NativeWrapper;
typedef Pixmap NativePixmap;

// Contents of the surface are backed by native window.

    virtual void destroy() override;

private:
    XUniquePtr<XImage> m_image;
    IntSize m_size;
    PlatformBufferHandle m_handle;
    GLuint m_format;



#if USE(GLX)

#include "X11Helper.h"
#include "XUniquePtr.h"
#include <opengl/GLDefs.h>
#include <opengl/GLPlatformSurface.h>


    GLXFBConfig findMatchingConfig(const int attributes[], int depth = 32)
    {
        int numAvailableConfigs;
        XUniquePtr<GLXFBConfig> temp(glXChooseFBConfig(X11Helper::nativeDisplay(), DefaultScreen(X11Helper::nativeDisplay()), attributes, &numAvailableConfigs));

        if (!numAvailableConfigs || !temp.get())
            return 0;

        for (int i = 0; i < numAvailableConfigs; ++i) {
            XUniquePtr<XVisualInfo> scopedVisualInfo { glXGetVisualFromFBConfig(X11Helper::nativeDisplay(), temp.get()[i]) };
            if (!scopedVisualInfo.get())
                continue;


                if (format) {
                    if (m_attributes & GLPlatformSurface::SupportAlpha) {
                        if (scopedVisualInfo->depth == depth && format->direct.alphaMask > 0)
                            return temp.get()[i];
                    } else if (!format->direct.alphaMask)
                        return temp.get()[i];
                }
            }
#endif
            if (scopedVisualInfo->depth == depth)
                return temp.get()[i];
        }

        // Did not find any visual supporting alpha, select the first available config.
        XUniquePtr<XVisualInfo> scopedVisualInfo { glXGetVisualFromFBConfig(X11Helper::nativeDisplay(), temp.get()[0]) };

        if ((m_attributes & GLPlatformSurface::SupportAlpha) && (scopedVisualInfo->depth != 32))
            m_attributes &= ~GLPlatformSurface::SupportAlpha;

        return temp.get()[0];
    }

    GLXFBConfig findMatchingConfigWithVisualId(const int attributes[], int depth, VisualID id)
    {
        int numAvailableConfigs;
        XUniquePtr<GLXFBConfig> temp(glXChooseFBConfig(X11Helper::nativeDisplay(), DefaultScreen(X11Helper::nativeDisplay()), attributes, &numAvailableConfigs));

        if (!numAvailableConfigs || !temp.get())
            return 0;

        for (int i = 0; i < numAvailableConfigs; ++i) {
            XUniquePtr<XVisualInfo> scopedVisualInfo { glXGetVisualFromFBConfig(X11Helper::nativeDisplay(), temp.get()[i]) };
            if (!scopedVisualInfo.get())
                continue;

            if (id && scopedVisualInfo->depth == depth && scopedVisualInfo->visualid == id)
                return temp.get()[i];
        }

        return 0;

Lines 28-33 a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec1
- a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp -2 / +4 lines
28		28
29	#if USE(GLX)	29	#if USE(GLX)
30		30
		31	#include "XUniquePtr.h"
		32
31	namespace WebCore {	33	namespace WebCore {
32		34
33	static PFNGLXBINDTEXIMAGEEXTPROC pGlXBindTexImageEXT = 0;	35	static PFNGLXBINDTEXIMAGEEXTPROC pGlXBindTexImageEXT = 0;
Lines 66-72 GLXTransportSurface::GLXTransportSurface(const IntSize& size, SurfaceAttributes a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec2
66	{	68	{
67	attributes \|= GLPlatformSurface::DoubleBuffered;	69	attributes \|= GLPlatformSurface::DoubleBuffered;
68	m_configSelector = std::make_unique<GLXConfigSelector>(attributes);	70	m_configSelector = std::make_unique<GLXConfigSelector>(attributes);
69	std::unique_ptr<XVisualInfo, X11Deleter> visInfo(m_configSelector->visualInfo(m_configSelector->surfaceContextConfig()));	71	XUniquePtr<XVisualInfo> visInfo(m_configSelector->visualInfo(m_configSelector->surfaceContextConfig()));
70		72
71	if (!visInfo.get()) {	73	if (!visInfo.get()) {
72	destroy();	74	destroy();
Lines 142-148 void GLXOffScreenSurface::initialize(SurfaceAttributes attributes) a/Source/WebCore/platform/graphics/surfaces/glx/GLXSurface.cpp_sec3
142	{	144	{
143	m_configSelector = std::make_unique<GLXConfigSelector>(attributes);	145	m_configSelector = std::make_unique<GLXConfigSelector>(attributes);
144		146
145	std::unique_ptr<XVisualInfo, X11Deleter> visualInfo(m_configSelector->visualInfo(m_configSelector->pixmapContextConfig()));	147	XUniquePtr<XVisualInfo> visualInfo(m_configSelector->visualInfo(m_configSelector->pixmapContextConfig()));
146	X11Helper::createPixmap(&m_pixmap, *visualInfo.get());	148	X11Helper::createPixmap(&m_pixmap, *visualInfo.get());
147		149
148	if (!m_pixmap) {	150	if (!m_pixmap) {



#include "X11Helper.h"

#include "PlatformDisplayX11.h"
#include "XUniquePtr.h"

namespace WebCore {


    memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
    visualInfoTemplate.visualid = visualId;
    int matchingCount = 0;
    XUniquePtr<XVisualInfo> matchingVisuals(XGetVisualInfo(nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount));
    XVisualInfo* foundVisual = 0;

    if (matchingVisuals) {

    memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
    visualInfoTemplate.visualid = visualId;
    int matchingCount = 0;
    XUniquePtr<XVisualInfo> matchingVisuals(XGetVisualInfo(nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount));
    XVisualInfo* foundVisual = 0;
    int requiredDepth = hasAlpha ? 32 : 24;





namespace WebCore {

class X11Deleter {
public:
    template<typename T> void operator()(T* resource)
    {
        if (resource)
            XFree(resource);
    }
};

class X11Helper {
public:
    static void createPixmap(Pixmap*, const XVisualInfo&, const IntSize& = IntSize(1, 1));



/*
 * Copyright (C) 2015 Igalia S.L
 *
 * 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 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 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 XUniquePtr_h
#define XUniquePtr_h

#if PLATFORM(X11)
#include "PlatformDisplayX11.h"
#include <X11/Xutil.h>

#if USE(GLX)
typedef struct __GLXcontextRec* GLXContext;
extern "C" void glXDestroyContext(Display*, GLXContext);
#endif

namespace WebCore {

template<typename T>
struct XPtrDeleter {
    void operator()(T* ptr) const
    {
        if (ptr)
            XFree(ptr);
    }
};

template<typename T>
using XUniquePtr = std::unique_ptr<T, XPtrDeleter<T>>;

template<> struct XPtrDeleter<XImage> {
    void operator() (XImage* ptr) const
    {
        if (ptr)
            XDestroyImage(ptr);
    }
};

template<> struct XPtrDeleter<_XGC> {
    void operator() (_XGC* ptr) const
    {
        if (ptr)
            XFreeGC(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), ptr);
    }
};
// Give a name to this to avoid having to use the internal struct name.
using XUniqueGC = XUniquePtr<_XGC>;

#if USE(GLX)
template<> struct XPtrDeleter<__GLXcontextRec> {
    void operator() (__GLXcontextRec* ptr)
    {
        if (ptr)
            glXDestroyContext(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), ptr);
    }
};
// Give a name to this to avoid having to use the internal struct name.
using XUniqueGLXContext = XUniquePtr<__GLXcontextRec>;
#endif

} // namespace WebCore

#endif // PLATFORM(X11)

#endif // XUniquePtr_h



/*
 * Copyright (C) 2015 Igalia S.L
 *
 * 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 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 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 "XUniqueResource.h"

#if PLATFORM(X11)
#include "PlatformDisplayX11.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>

#if PLATFORM(GTK)
#include <X11/extensions/Xdamage.h>
#endif

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

namespace WebCore {

static inline Display* sharedDisplay()
{
    return downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
}

template<> void XUniqueResource<XResource::Colormap>::deleteXResource(unsigned long resource)
{
    if (resource)
        XFreeColormap(sharedDisplay(), resource);
}

#if PLATFORM(GTK)
template<> void XUniqueResource<XResource::Damage>::deleteXResource(unsigned long resource)
{
    if (resource)
        XDamageDestroy(sharedDisplay(), resource);
}
#endif

template<> void XUniqueResource<XResource::Pixmap>::deleteXResource(unsigned long resource)
{
    if (resource)
        XFreePixmap(sharedDisplay(), resource);
}

template<> void XUniqueResource<XResource::Window>::deleteXResource(unsigned long resource)
{
    if (resource)
        XDestroyWindow(sharedDisplay(), resource);
}

#if USE(GLX)
template<> void XUniqueResource<XResource::GLXPbuffer>::deleteXResource(unsigned long resource)
{
    if (resource)
        glXDestroyPbuffer(sharedDisplay(), resource);
}

template<> void XUniqueResource<XResource::GLXPixmap>::deleteXResource(unsigned long resource)
{
    if (resource)
        glXDestroyGLXPixmap(sharedDisplay(), resource);
}
#endif // USE(GLX)

} // namespace WebCore

#endif // PLATFORM(X11)



/*
 * Copyright (C) 2015 Igalia S.L
 *
 * 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 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 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 XUniqueResource_h
#define XUniqueResource_h

#if PLATFORM(X11)

#if USE(GLX)
typedef unsigned long GLXPbuffer;
typedef unsigned long GLXPixmap;
#endif

namespace WebCore {

enum class XResource {
    Colormap,
#if PLATFORM(GTK)
    Damage,
#endif
    Pixmap,
    Window,
#if USE(GLX)
    GLXPbuffer,
    GLXPixmap,
#endif
};

template <XResource T> class XUniqueResource {
public:
    XUniqueResource()
    {
    }

    XUniqueResource(unsigned long resource)
        : m_resource(resource)
    {
    }

    XUniqueResource(XUniqueResource&& uniqueResource)
        : m_resource(uniqueResource.release())
    {
    }

    XUniqueResource& operator=(XUniqueResource&& uniqueResource)
    {
        reset(uniqueResource.release());
        return *this;
    }

    ~XUniqueResource()
    {
        reset();
    }

    unsigned long get() const { return m_resource; }
    unsigned long release() { return std::exchange(m_resource, 0); }

    void reset(unsigned long resource = 0)
    {
        std::swap(m_resource, resource);
        deleteXResource(resource);
    }

    explicit operator bool() const { return m_resource; }

private:
    static void deleteXResource(unsigned long resource);

    unsigned long m_resource { 0 };
};

using XUniqueColormap = XUniqueResource<XResource::Colormap>;
#if PLATFORM(GTK)
using XUniqueDamage = XUniqueResource<XResource::Damage>;
#endif
using XUniquePixmap = XUniqueResource<XResource::Pixmap>;
using XUniqueWindow = XUniqueResource<XResource::Window>;
#if USE(GLX)
using XUniqueGLXPbuffer = XUniqueResource<XResource::GLXPbuffer>;
using XUniqueGLXPixmap = XUniqueResource<XResource::GLXPixmap>;
#endif

} // namespace WebCore

#endif // PLATFORM(X11)

#endif // XUniqueResource_h



2015-05-08  Carlos Garcia Campos  <cgarcia@igalia.com>

        [X11] Add XUniquePtr and XUniqueResource to automatically free X resources
        https://bugs.webkit.org/show_bug.cgi?id=144521

        Reviewed by Darin Adler.

        Use XUniquePtr and XUniqueResource to free X resources.

        * PlatformEfl.cmake: Add Source/WebCore/platform/graphics/x11 dir
        to the include dir list.
        * PlatformGTK.cmake: Ditto.
        * UIProcess/cairo/BackingStoreCairo.cpp:
        (WebKit::BackingStore::createBackend): Do not pass the display to
        the BackingStoreBackendCairoX11 constructor.
        * UIProcess/gtk/RedirectedXCompositeWindow.cpp:
        (WebKit::RedirectedXCompositeWindow::RedirectedXCompositeWindow):
        (WebKit::RedirectedXCompositeWindow::~RedirectedXCompositeWindow):
        (WebKit::RedirectedXCompositeWindow::resize):
        (WebKit::RedirectedXCompositeWindow::cleanupPixmapAndPixmapSurface):
        (WebKit::RedirectedXCompositeWindow::surface):
        * UIProcess/gtk/RedirectedXCompositeWindow.h:
        (WebKit::RedirectedXCompositeWindow::windowID):
        * WebProcess/Plugins/Netscape/NetscapePlugin.h:
        * WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:
        (WebKit::NetscapePlugin::platformPostInitializeWindowless):
        (WebKit::NetscapePlugin::platformDestroy):
        (WebKit::NetscapePlugin::platformGeometryDidChange):
        (WebKit::NetscapePlugin::platformPaint):

2015-05-05  Carlos Garcia Campos  <cgarcia@igalia.com>

        [SOUP] Network Cache: Implement ShareableResource for Soup and enable it for GTK platform

Lines 226-231 list(APPEND WebKit2_INCLUDE_DIRECTORIES a/Source/WebKit2/PlatformEfl.cmake_sec1
- a/Source/WebKit2/PlatformEfl.cmake +1 lines
226	"${WEBCORE_DIR}/platform/graphics/cairo"	226	"${WEBCORE_DIR}/platform/graphics/cairo"
227	"${WEBCORE_DIR}/platform/graphics/efl"	227	"${WEBCORE_DIR}/platform/graphics/efl"
228	"${WEBCORE_DIR}/platform/graphics/opentype"	228	"${WEBCORE_DIR}/platform/graphics/opentype"
		229	"${WEBCORE_DIR}/platform/graphics/x11"
229	"${WEBCORE_DIR}/platform/network/soup"	230	"${WEBCORE_DIR}/platform/network/soup"
230	"${WEBCORE_DIR}/platform/text/enchant"	231	"${WEBCORE_DIR}/platform/text/enchant"
231	"${WEBKIT2_DIR}/NetworkProcess/efl"	232	"${WEBKIT2_DIR}/NetworkProcess/efl"

Lines 456-461 list(APPEND WebKit2_INCLUDE_DIRECTORIES a/Source/WebKit2/PlatformGTK.cmake_sec1
- a/Source/WebKit2/PlatformGTK.cmake +1 lines
456	"${WEBCORE_DIR}/platform/gtk"	456	"${WEBCORE_DIR}/platform/gtk"
457	"${WEBCORE_DIR}/platform/graphics/cairo"	457	"${WEBCORE_DIR}/platform/graphics/cairo"
458	"${WEBCORE_DIR}/platform/graphics/opentype"	458	"${WEBCORE_DIR}/platform/graphics/opentype"
		459	"${WEBCORE_DIR}/platform/graphics/x11"
459	"${WEBCORE_DIR}/platform/network/soup"	460	"${WEBCORE_DIR}/platform/network/soup"
460	"${WEBCORE_DIR}/platform/text/enchant"	461	"${WEBCORE_DIR}/platform/text/enchant"
461	"${WEBKIT2_DIR}/DatabaseProcess/unix"	462	"${WEBKIT2_DIR}/DatabaseProcess/unix"

Lines 54-60 std::unique_ptr<BackingStoreBackendCairo> BackingStore::createBackend() a/Source/WebKit2/UIProcess/cairo/BackingStoreCairo.cpp_sec1
- a/Source/WebKit2/UIProcess/cairo/BackingStoreCairo.cpp -1 / +1 lines
54	GdkVisual* visual = gtk_widget_get_visual(m_webPageProxy.viewWidget());	54	GdkVisual* visual = gtk_widget_get_visual(m_webPageProxy.viewWidget());
55	GdkScreen* screen = gdk_visual_get_screen(visual);	55	GdkScreen* screen = gdk_visual_get_screen(visual);
56	ASSERT(downcast<PlatformDisplayX11>(sharedDisplay).native() == GDK_SCREEN_XDISPLAY(screen));	56	ASSERT(downcast<PlatformDisplayX11>(sharedDisplay).native() == GDK_SCREEN_XDISPLAY(screen));
57	return std::make_unique<BackingStoreBackendCairoX11>(downcast<PlatformDisplayX11>(sharedDisplay).native(), GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),	57	return std::make_unique<BackingStoreBackendCairoX11>(GDK_WINDOW_XID(gdk_screen_get_root_window(screen)),
58	GDK_VISUAL_XVISUAL(visual), gdk_visual_get_depth(visual), m_size, m_deviceScaleFactor);	58	GDK_VISUAL_XVISUAL(visual), gdk_visual_get_depth(visual), m_size, m_deviceScaleFactor);
59	}	59	}
60	#endif	60	#endif




#if USE(REDIRECTED_XCOMPOSITE_WINDOW)

#include <X11/Xlib.h>
#include <X11/extensions/Xcomposite.h>
#include <X11/extensions/Xdamage.h>
#include <cairo-xlib.h>


RedirectedXCompositeWindow::RedirectedXCompositeWindow(GdkWindow* parentWindow, std::function<void()> damageNotify)
    : m_display(GDK_DISPLAY_XDISPLAY(gdk_window_get_display(parentWindow)))
    , m_window(0)
    , m_parentWindow(0)
    , m_pixmap(0)
    , m_damage(0)
    , m_needsNewPixmapAfterResize(false)
{
    ASSERT(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native() == m_display);
    Screen* screen = DefaultScreenOfDisplay(m_display);

    GdkVisual* visual = gdk_window_get_visual(parentWindow);
    XUniqueColormap colormap(XCreateColormap(m_display, RootWindowOfScreen(screen), GDK_VISUAL_XVISUAL(visual), AllocNone));

    // This is based on code from Chromium: src/content/common/gpu/image_transport_surface_linux.cc
    XSetWindowAttributes windowAttributes;
    windowAttributes.override_redirect = True;
    windowAttributes.colormap = colormap.get();

    // CWBorderPixel must be present when the depth doesn't match the parent's one.
    // See http://cgit.freedesktop.org/xorg/xserver/tree/dix/window.c?id=xorg-server-1.16.0#n703.

        GDK_VISUAL_XVISUAL(visual),
        CWOverrideRedirect | CWColormap | CWBorderPixel,
        &windowAttributes);
    XMapWindow(m_display, m_parentWindow.get());

    windowAttributes.event_mask = StructureNotifyMask;
    windowAttributes.override_redirect = False;
    // Create the window of at last 1x1 since X doesn't allow to create empty windows.
    m_window = XCreateWindow(m_display,
        m_parentWindow.get(),
        0, 0,
        std::max(1, m_size.width()),
        std::max(1, m_size.height()),

        CopyFromParent,
        CWEventMask,
        &windowAttributes);
    XMapWindow(m_display, m_window.get());

    xDamageNotifier().add(m_window.get(), WTF::move(damageNotify));

    xDamageNotifier().add(m_window, WTF::move(damageNotify));

    while (1) {
        XEvent event;
        XWindowEvent(m_display, m_window.get(), StructureNotifyMask, &event);
        if (event.type == MapNotify && event.xmap.window == m_window.get())
            break;
    }
    XSelectInput(m_display, m_window.get(), NoEventMask);
    XCompositeRedirectWindow(m_display, m_window.get(), CompositeRedirectManual);
    m_damage = XDamageCreate(m_display, m_window.get(), XDamageReportNonEmpty);
}

RedirectedXCompositeWindow::~RedirectedXCompositeWindow()

    ASSERT(m_window);
    ASSERT(m_parentWindow);

    xDamageNotifier().remove(m_window.get());

    // Explicitly reset these because we need to ensure it happens in this order.
    m_damage.reset();
    m_window.reset();
    m_parentWindow.reset();
}

void RedirectedXCompositeWindow::resize(const IntSize& size)

        return;

    // Resize the window to at last 1x1 since X doesn't allow to create empty windows.
    XResizeWindow(m_display, m_window.get(), std::max(1, size.width()), std::max(1, size.height()));
    XFlush(m_display);

    m_size = size;

    if (!m_pixmap)
        return;

    XFreePixmap(m_display, m_pixmap);
    m_pixmap = 0;
    m_surface = nullptr;
    m_pixmap.reset();
}

cairo_surface_t* RedirectedXCompositeWindow::surface()


    m_needsNewPixmapAfterResize = false;

    XUniquePixmap newPixmap(XCompositeNameWindowPixmap(m_display, m_window.get()));
    if (!newPixmap) {
        cleanupPixmapAndPixmapSurface();
        return nullptr;
    }

    XWindowAttributes windowAttributes;
    if (!XGetWindowAttributes(m_display, m_window.get(), &windowAttributes)) {
        cleanupPixmapAndPixmapSurface();
        XFreePixmap(m_display, newPixmap);
        return nullptr;
    }

    RefPtr<cairo_surface_t> newSurface = adoptRef(cairo_xlib_surface_create(m_display, newPixmap.get(), windowAttributes.visual, m_size.width(), m_size.height()));

    // Nvidia drivers seem to prepare their redirected window pixmap asynchronously, so for a few fractions
    // of a second after each resize, while doing continuous resizing (which constantly destroys and creates

    }

    cleanupPixmapAndPixmapSurface();
    m_pixmap = WTF::move(newPixmap);
    m_surface = newSurface;
    return m_surface.get();
}




#include <WebCore/IntSize.h>
#include <WebCore/RefPtrCairo.h>
#include <WebCore/XUniqueResource.h>
#include <functional>

typedef struct _GdkWindow GdkWindow;
typedef struct _XDisplay Display;
typedef unsigned long Window;

namespace WebKit {


    static std::unique_ptr<RedirectedXCompositeWindow> create(GdkWindow*, std::function<void()> damageNotify);
    ~RedirectedXCompositeWindow();

    Window windowID() const { return m_window.get(); }
    void resize(const WebCore::IntSize&);
    cairo_surface_t* surface();



    Display* m_display;
    WebCore::IntSize m_size;
    WebCore::XUniqueWindow m_window;
    WebCore::XUniqueWindow m_parentWindow;
    WebCore::XUniquePixmap m_pixmap;
    WebCore::XUniqueDamage m_damage;
    RefPtr<cairo_surface_t> m_surface;
    bool m_needsNewPixmapAfterResize;
};

Lines 42-47 a/Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePlugin.h_sec1
- a/Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePlugin.h -1 / +5 lines
42	#include "WebHitTestResult.h"	42	#include "WebHitTestResult.h"
43	#endif	43	#endif
44		44
		45	#if PLUGIN_ARCHITECTURE(X11)
		46	#include <WebCore/XUniqueResource.h>
		47	#endif
		48
45	namespace WebCore {	49	namespace WebCore {
46	class MachSendRight;	50	class MachSendRight;
47	class HTTPHeaderMap;	51	class HTTPHeaderMap;
Lines 388-394 private: a/Source/WebKit2/WebProcess/Plugins/Netscape/NetscapePlugin.h_sec2
388	NP_CGContext m_npCGContext;	392	NP_CGContext m_npCGContext;
389	#endif	393	#endif
390	#elif PLUGIN_ARCHITECTURE(X11)	394	#elif PLUGIN_ARCHITECTURE(X11)
391	Pixmap m_drawable;	395	WebCore::XUniquePixmap m_drawable;
392	Display* m_pluginDisplay;	396	Display* m_pluginDisplay;
393	#if PLATFORM(GTK)	397	#if PLATFORM(GTK)
394	GtkWidget* m_platformPluginWidget;	398	GtkWidget* m_platformPluginWidget;



#include <WebCore/GraphicsContext.h>
#include <WebCore/NotImplemented.h>
#include <WebCore/PlatformDisplayX11.h>
#include <WebCore/XUniquePtr.h>

#if PLATFORM(GTK)
#include <gtk/gtk.h>

    visualTemplate.depth = depth;
    visualTemplate.c_class = TrueColor;
    int numMatching;
    XUniquePtr<XVisualInfo> visualInfo(XGetVisualInfo(display, VisualScreenMask | VisualDepthMask | VisualClassMask, &visualTemplate, &numMatching));
                                             &visualTemplate, &numMatching);
    ASSERT(visualInfo);
    Visual* visual = visualInfo.get()[0].visual;
    ASSERT(visual);
    XFree(visualInfo);

    callbackStruct->visual = visual;
    callbackStruct->colormap = XCreateColormap(display, rootWindowID(), visual, AllocNone);

    XFreeColormap(hostDisplay, callbackStruct->colormap);
    delete callbackStruct;

    m_drawable.reset();
        XFreePixmap(hostDisplay, m_drawable);
        m_drawable = 0;
    }

#if PLATFORM(GTK)
    if (m_platformPluginWidget) {

        return;
    }

    m_drawable.reset();
    if (m_pluginSize.isEmpty())
        XFreePixmap(display, m_drawable);

    if (m_pluginSize.isEmpty()) {
        m_drawable = 0;
        return;
    }

    m_drawable = XCreatePixmap(display, rootWindowID(), m_pluginSize.width(), m_pluginSize.height(), displayDepth());

    m_drawable = XCreatePixmap(x11HostDisplay(), rootWindowID(), m_pluginSize.width(), m_pluginSize.height(), displayDepth());
    XSync(x11HostDisplay(), false); // Make sure that the server knows about the Drawable.
}

void NetscapePlugin::platformVisibilityDidChange()

    XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;
    exposeEvent.type = GraphicsExpose;
    exposeEvent.display = x11HostDisplay();
    exposeEvent.drawable = m_drawable.get();

    IntRect exposedRect(dirtyRect);
    exposeEvent.x = exposedRect.x();

        XSync(m_pluginDisplay, false);

#if PLATFORM(GTK) || (PLATFORM(EFL) && USE(CAIRO))
    RefPtr<cairo_surface_t> drawableSurface = adoptRef(cairo_xlib_surface_create(m_pluginDisplay, m_drawable.get(),
        static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info)->visual, m_pluginSize.width(), m_pluginSize.height()));
                                                                                 static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info)->visual,
                                                                                 m_pluginSize.width(),
                                                                                 m_pluginSize.height()));
    cairo_t* cr = context->platformContext()->cr();
    cairo_save(cr);


Return to Bug 144521

Lines 29-34 a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec1
- a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp -30 / +24 lines
29		29
30	#if USE(REDIRECTED_XCOMPOSITE_WINDOW)	30	#if USE(REDIRECTED_XCOMPOSITE_WINDOW)
31		31
		32	#include <X11/Xlib.h>
32	#include <X11/extensions/Xcomposite.h>	33	#include <X11/extensions/Xcomposite.h>
33	#include <X11/extensions/Xdamage.h>	34	#include <X11/extensions/Xdamage.h>
34	#include <cairo-xlib.h>	35	#include <cairo-xlib.h>
Lines 135-155 std::unique_ptr<RedirectedXCompositeWindow> RedirectedXCompositeWindow::create(G a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec2
135		136
136	RedirectedXCompositeWindow::RedirectedXCompositeWindow(GdkWindow* parentWindow, std::function<void()> damageNotify)	137	RedirectedXCompositeWindow::RedirectedXCompositeWindow(GdkWindow* parentWindow, std::function<void()> damageNotify)
137	: m_display(GDK_DISPLAY_XDISPLAY(gdk_window_get_display(parentWindow)))	138	: m_display(GDK_DISPLAY_XDISPLAY(gdk_window_get_display(parentWindow)))
138	, m_window(0)
139	, m_parentWindow(0)
140	, m_pixmap(0)
141	, m_damage(0)
142	, m_needsNewPixmapAfterResize(false)	139	, m_needsNewPixmapAfterResize(false)
143	{	140	{
		141	ASSERT(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native() == m_display);
144	Screen* screen = DefaultScreenOfDisplay(m_display);	142	Screen* screen = DefaultScreenOfDisplay(m_display);
145		143
146	GdkVisual* visual = gdk_window_get_visual(parentWindow);	144	GdkVisual* visual = gdk_window_get_visual(parentWindow);
147	Colormap colormap = XCreateColormap(m_display, RootWindowOfScreen(screen), GDK_VISUAL_XVISUAL(visual), AllocNone);	145	XUniqueColormap colormap(XCreateColormap(m_display, RootWindowOfScreen(screen), GDK_VISUAL_XVISUAL(visual), AllocNone));
148		146
149	// This is based on code from Chromium: src/content/common/gpu/image_transport_surface_linux.cc	147	// This is based on code from Chromium: src/content/common/gpu/image_transport_surface_linux.cc
150	XSetWindowAttributes windowAttributes;	148	XSetWindowAttributes windowAttributes;
151	windowAttributes.override_redirect = True;	149	windowAttributes.override_redirect = True;
152	windowAttributes.colormap = colormap;	150	windowAttributes.colormap = colormap.get();
153		151
154	// CWBorderPixel must be present when the depth doesn't match the parent's one.	152	// CWBorderPixel must be present when the depth doesn't match the parent's one.
155	// See http://cgit.freedesktop.org/xorg/xserver/tree/dix/window.c?id=xorg-server-1.16.0#n703.	153	// See http://cgit.freedesktop.org/xorg/xserver/tree/dix/window.c?id=xorg-server-1.16.0#n703.
Lines 164-176 RedirectedXCompositeWindow::RedirectedXCompositeWindow(GdkWindow* parentWindow, a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec3
164	GDK_VISUAL_XVISUAL(visual),	162	GDK_VISUAL_XVISUAL(visual),
165	CWOverrideRedirect \| CWColormap \| CWBorderPixel,	163	CWOverrideRedirect \| CWColormap \| CWBorderPixel,
166	&windowAttributes);	164	&windowAttributes);
167	XMapWindow(m_display, m_parentWindow);	165	XMapWindow(m_display, m_parentWindow.get());
168		166
169	windowAttributes.event_mask = StructureNotifyMask;	167	windowAttributes.event_mask = StructureNotifyMask;
170	windowAttributes.override_redirect = False;	168	windowAttributes.override_redirect = False;
171	// Create the window of at last 1x1 since X doesn't allow to create empty windows.	169	// Create the window of at last 1x1 since X doesn't allow to create empty windows.
172	m_window = XCreateWindow(m_display,	170	m_window = XCreateWindow(m_display,
173	m_parentWindow,	171	m_parentWindow.get(),
174	0, 0,	172	0, 0,
175	std::max(1, m_size.width()),	173	std::max(1, m_size.width()),
176	std::max(1, m_size.height()),	174	std::max(1, m_size.height()),
Lines 180-200 RedirectedXCompositeWindow::RedirectedXCompositeWindow(GdkWindow* parentWindow, a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec4
180	CopyFromParent,	178	CopyFromParent,
181	CWEventMask,	179	CWEventMask,
182	&windowAttributes);	180	&windowAttributes);
183	XMapWindow(m_display, m_window);	181	XMapWindow(m_display, m_window.get());
184		182
185	XFreeColormap(m_display, colormap);	183	xDamageNotifier().add(m_window.get(), WTF::move(damageNotify));
186
187	xDamageNotifier().add(m_window, WTF::move(damageNotify));
188		184
189	while (1) {	185	while (1) {
190	XEvent event;	186	XEvent event;
191	XWindowEvent(m_display, m_window, StructureNotifyMask, &event);	187	XWindowEvent(m_display, m_window.get(), StructureNotifyMask, &event);
192	if (event.type == MapNotify && event.xmap.window == m_window)	188	if (event.type == MapNotify && event.xmap.window == m_window.get())
193	break;	189	break;
194	}	190	}
195	XSelectInput(m_display, m_window, NoEventMask);	191	XSelectInput(m_display, m_window.get(), NoEventMask);
196	XCompositeRedirectWindow(m_display, m_window, CompositeRedirectManual);	192	XCompositeRedirectWindow(m_display, m_window.get(), CompositeRedirectManual);
197	m_damage = XDamageCreate(m_display, m_window, XDamageReportNonEmpty);	193	m_damage = XDamageCreate(m_display, m_window.get(), XDamageReportNonEmpty);
198	}	194	}
199		195
200	RedirectedXCompositeWindow::~RedirectedXCompositeWindow()	196	RedirectedXCompositeWindow::~RedirectedXCompositeWindow()
Lines 204-215 RedirectedXCompositeWindow::~RedirectedXCompositeWindow() a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec5
204	ASSERT(m_window);	200	ASSERT(m_window);
205	ASSERT(m_parentWindow);	201	ASSERT(m_parentWindow);
206		202
207	xDamageNotifier().remove(m_window);	203	xDamageNotifier().remove(m_window.get());
208		204
209	XDamageDestroy(m_display, m_damage);	205	// Explicitly reset these because we need to ensure it happens in this order.
210	XDestroyWindow(m_display, m_window);	206	m_damage.reset();
211	XDestroyWindow(m_display, m_parentWindow);	207	m_window.reset();
212	cleanupPixmapAndPixmapSurface();	208	m_parentWindow.reset();
213	}	209	}
214		210
215	void RedirectedXCompositeWindow::resize(const IntSize& size)	211	void RedirectedXCompositeWindow::resize(const IntSize& size)
Lines 218-224 void RedirectedXCompositeWindow::resize(const IntSize& size) a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec6
218	return;	214	return;
219		215
220	// Resize the window to at last 1x1 since X doesn't allow to create empty windows.	216	// Resize the window to at last 1x1 since X doesn't allow to create empty windows.
221	XResizeWindow(m_display, m_window, std::max(1, size.width()), std::max(1, size.height()));	217	XResizeWindow(m_display, m_window.get(), std::max(1, size.width()), std::max(1, size.height()));
222	XFlush(m_display);	218	XFlush(m_display);
223		219
224	m_size = size;	220	m_size = size;
Lines 232-240 void RedirectedXCompositeWindow::cleanupPixmapAndPixmapSurface() a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec7
232	if (!m_pixmap)	228	if (!m_pixmap)
233	return;	229	return;
234		230
235	XFreePixmap(m_display, m_pixmap);
236	m_pixmap = 0;
237	m_surface = nullptr;	231	m_surface = nullptr;
		232	m_pixmap.reset();
238	}	233	}
239		234
240	cairo_surface_t* RedirectedXCompositeWindow::surface()	235	cairo_surface_t* RedirectedXCompositeWindow::surface()
Lines 247-266 cairo_surface_t* RedirectedXCompositeWindow::surface() a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec8
247		242
248	m_needsNewPixmapAfterResize = false;	243	m_needsNewPixmapAfterResize = false;
249		244
250	Pixmap newPixmap = XCompositeNameWindowPixmap(m_display, m_window);	245	XUniquePixmap newPixmap(XCompositeNameWindowPixmap(m_display, m_window.get()));
251	if (!newPixmap) {	246	if (!newPixmap) {
252	cleanupPixmapAndPixmapSurface();	247	cleanupPixmapAndPixmapSurface();
253	return nullptr;	248	return nullptr;
254	}	249	}
255		250
256	XWindowAttributes windowAttributes;	251	XWindowAttributes windowAttributes;
257	if (!XGetWindowAttributes(m_display, m_window, &windowAttributes)) {	252	if (!XGetWindowAttributes(m_display, m_window.get(), &windowAttributes)) {
258	cleanupPixmapAndPixmapSurface();	253	cleanupPixmapAndPixmapSurface();
259	XFreePixmap(m_display, newPixmap);
260	return nullptr;	254	return nullptr;
261	}	255	}
262		256
263	RefPtr<cairo_surface_t> newSurface = adoptRef(cairo_xlib_surface_create(m_display, newPixmap, windowAttributes.visual, m_size.width(), m_size.height()));	257	RefPtr<cairo_surface_t> newSurface = adoptRef(cairo_xlib_surface_create(m_display, newPixmap.get(), windowAttributes.visual, m_size.width(), m_size.height()));
264		258
265	// Nvidia drivers seem to prepare their redirected window pixmap asynchronously, so for a few fractions	259	// Nvidia drivers seem to prepare their redirected window pixmap asynchronously, so for a few fractions
266	// of a second after each resize, while doing continuous resizing (which constantly destroys and creates	260	// of a second after each resize, while doing continuous resizing (which constantly destroys and creates
Lines 275-281 cairo_surface_t* RedirectedXCompositeWindow::surface() a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.cpp_sec9
275	}	269	}
276		270
277	cleanupPixmapAndPixmapSurface();	271	cleanupPixmapAndPixmapSurface();
278	m_pixmap = newPixmap;	272	m_pixmap = WTF::move(newPixmap);
279	m_surface = newSurface;	273	m_surface = newSurface;
280	return m_surface.get();	274	return m_surface.get();
281	}	275	}

Lines 34-39 a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp_sec1
- a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp -24 / +11 lines
34	#include <WebCore/GraphicsContext.h>	34	#include <WebCore/GraphicsContext.h>
35	#include <WebCore/NotImplemented.h>	35	#include <WebCore/NotImplemented.h>
36	#include <WebCore/PlatformDisplayX11.h>	36	#include <WebCore/PlatformDisplayX11.h>
		37	#include <WebCore/XUniquePtr.h>
37		38
38	#if PLATFORM(GTK)	39	#if PLATFORM(GTK)
39	#include <gtk/gtk.h>	40	#include <gtk/gtk.h>
Lines 175-186 bool NetscapePlugin::platformPostInitializeWindowless() a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp_sec2
175	visualTemplate.depth = depth;	176	visualTemplate.depth = depth;
176	visualTemplate.c_class = TrueColor;	177	visualTemplate.c_class = TrueColor;
177	int numMatching;	178	int numMatching;
178	XVisualInfo* visualInfo = XGetVisualInfo(display, VisualScreenMask \| VisualDepthMask \| VisualClassMask,	179	XUniquePtr<XVisualInfo> visualInfo(XGetVisualInfo(display, VisualScreenMask \| VisualDepthMask \| VisualClassMask, &visualTemplate, &numMatching));
179	&visualTemplate, &numMatching);
180	ASSERT(visualInfo);	180	ASSERT(visualInfo);
181	Visual* visual = visualInfo[0].visual;	181	Visual* visual = visualInfo.get()[0].visual;
182	ASSERT(visual);	182	ASSERT(visual);
183	XFree(visualInfo);
184		183
185	callbackStruct->visual = visual;	184	callbackStruct->visual = visual;
186	callbackStruct->colormap = XCreateColormap(display, rootWindowID(), visual, AllocNone);	185	callbackStruct->colormap = XCreateColormap(display, rootWindowID(), visual, AllocNone);
Lines 232-241 void NetscapePlugin::platformDestroy() a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp_sec3
232	XFreeColormap(hostDisplay, callbackStruct->colormap);	231	XFreeColormap(hostDisplay, callbackStruct->colormap);
233	delete callbackStruct;	232	delete callbackStruct;
234		233
235	if (m_drawable) {	234	m_drawable.reset();
236	XFreePixmap(hostDisplay, m_drawable);
237	m_drawable = 0;
238	}
239		235
240	#if PLATFORM(GTK)	236	#if PLATFORM(GTK)
241	if (m_platformPluginWidget) {	237	if (m_platformPluginWidget) {
Lines 262-279 void NetscapePlugin::platformGeometryDidChange() a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp_sec4
262	return;	258	return;
263	}	259	}
264		260
265	Display* display = x11HostDisplay();	261	m_drawable.reset();
266	if (m_drawable)	262	if (m_pluginSize.isEmpty())
267	XFreePixmap(display, m_drawable);
268
269	if (m_pluginSize.isEmpty()) {
270	m_drawable = 0;
271	return;	263	return;
272	}
273
274	m_drawable = XCreatePixmap(display, rootWindowID(), m_pluginSize.width(), m_pluginSize.height(), displayDepth());
275		264
276	XSync(display, false); // Make sure that the server knows about the Drawable.	265	m_drawable = XCreatePixmap(x11HostDisplay(), rootWindowID(), m_pluginSize.width(), m_pluginSize.height(), displayDepth());
		266	XSync(x11HostDisplay(), false); // Make sure that the server knows about the Drawable.
277	}	267	}
278		268
279	void NetscapePlugin::platformVisibilityDidChange()	269	void NetscapePlugin::platformVisibilityDidChange()
Lines 307-313 void NetscapePlugin::platformPaint(GraphicsContext* context, const IntRect& dirt a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp_sec5
307	XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;	297	XGraphicsExposeEvent& exposeEvent = xevent.xgraphicsexpose;
308	exposeEvent.type = GraphicsExpose;	298	exposeEvent.type = GraphicsExpose;
309	exposeEvent.display = x11HostDisplay();	299	exposeEvent.display = x11HostDisplay();
310	exposeEvent.drawable = m_drawable;	300	exposeEvent.drawable = m_drawable.get();
311		301
312	IntRect exposedRect(dirtyRect);	302	IntRect exposedRect(dirtyRect);
313	exposeEvent.x = exposedRect.x();	303	exposeEvent.x = exposedRect.x();
Lines 324-334 void NetscapePlugin::platformPaint(GraphicsContext* context, const IntRect& dirt a/Source/WebKit2/WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp_sec6
324	XSync(m_pluginDisplay, false);	314	XSync(m_pluginDisplay, false);
325		315
326	#if PLATFORM(GTK) \|\| (PLATFORM(EFL) && USE(CAIRO))	316	#if PLATFORM(GTK) \|\| (PLATFORM(EFL) && USE(CAIRO))
327	RefPtr<cairo_surface_t> drawableSurface = adoptRef(cairo_xlib_surface_create(m_pluginDisplay,	317	RefPtr<cairo_surface_t> drawableSurface = adoptRef(cairo_xlib_surface_create(m_pluginDisplay, m_drawable.get(),
328	m_drawable,	318	static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info)->visual, m_pluginSize.width(), m_pluginSize.height()));
329	static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info)->visual,
330	m_pluginSize.width(),
331	m_pluginSize.height()));
332	cairo_t* cr = context->platformContext()->cr();	319	cairo_t* cr = context->platformContext()->cr();
333	cairo_save(cr);	320	cairo_save(cr);
334		321

Lines 1-3 a/Source/WebCore/ChangeLog_sec1
- a/Source/WebCore/ChangeLog +71 lines
		1	2015-05-08 Carlos Garcia Campos <cgarcia@igalia.com>
		2
		3	[X11] Add XUniquePtr and XUniqueResource to automatically free X resources
		4	https://bugs.webkit.org/show_bug.cgi?id=144521
		5
		6	Reviewed by Darin Adler.
		7
		8	Add XUniquePtr as a template alias of std:unique_ptr to handle X
		9	resources using pointers and XUniqueResource as a new class to
		10	handle X resources using a long unsigned identifier. This
		11	simplifies the code and makes it more difficult to leak X resources.
		12
		13	* PlatformEfl.cmake: Add new files to compilation.
		14	* PlatformGTK.cmake: Ditto.
		15	* platform/graphics/cairo/BackingStoreBackendCairoX11.cpp:
		16	(WebCore::BackingStoreBackendCairoX11::BackingStoreBackendCairoX11):
		17	Remove the display member, and use XUnique for Pixmap and GC.
		18	(WebCore::BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11):
		19	Remove code to explicitly free Pixmap and GC.
		20	(WebCore::BackingStoreBackendCairoX11::scroll):
		21	* platform/graphics/cairo/BackingStoreBackendCairoX11.h:
		22	* platform/graphics/glx/GLContextGLX.cpp:
		23	(WebCore::GLContextGLX::createWindowContext): Use XUnique and the
		24	new constructor that receives a XID, since there's no longer
		25	conflict with the one receiving a Pbuffer.
		26	(WebCore::GLContextGLX::createPbufferContext): Use XUnique and the
		27	new constructor that receives a XUniqueGLXPbuffer&&.
		28	(WebCore::GLContextGLX::createPixmapContext):
		29	(WebCore::GLContextGLX::createContext):
		30	(WebCore::GLContextGLX::GLContextGLX):
		31	(WebCore::GLContextGLX::~GLContextGLX): Remove code to explicitly
		32	free X resources.
		33	(WebCore::GLContextGLX::makeContextCurrent):
		34	(WebCore::GLContextGLX::cairoDevice):
		35	(WebCore::GLContextGLX::platformContext):
		36	* platform/graphics/glx/GLContextGLX.h:
		37	* platform/graphics/surfaces/egl/EGLXSurface.cpp:
		38	(WebCore::EGLXTransportSurfaceClient::EGLXTransportSurfaceClient):
		39	(WebCore::EGLXTransportSurfaceClient::destroy):
		40	(WebCore::EGLXTransportSurfaceClient::prepareTexture):
		41	* platform/graphics/surfaces/egl/EGLXSurface.h:
		42	* platform/graphics/surfaces/glx/GLXConfigSelector.h:
		43	(WebCore::GLXConfigSelector::findMatchingConfig): Use XUnique
		44	instead of the custom std::unique X11Deleter.
		45	(WebCore::GLXConfigSelector::findMatchingConfigWithVisualId): Ditto.
		46	* platform/graphics/surfaces/glx/GLXSurface.cpp:
		47	(WebCore::GLXTransportSurface::GLXTransportSurface): Ditto.
		48	(WebCore::GLXOffScreenSurface::initialize):
		49	* platform/graphics/surfaces/glx/X11Helper.cpp:
		50	(WebCore::X11Helper::createOffScreenWindow): Ditto.
		51	(WebCore::X11Helper::createPixmap): Ditto.
		52	* platform/graphics/surfaces/glx/X11Helper.h:
		53	* platform/graphics/x11/XUniquePtr.h: Remove X11Deleter.
		54	(WebCore::XPtrDeleter::operator()):
		55	* platform/graphics/x11/XUniqueResource.cpp: Added.
		56	(WebCore::XUniqueResource<XResource::Colormap>::deleteXResource):
		57	(WebCore::XUniqueResource<XResource::Damage>::deleteXResource):
		58	(WebCore::XUniqueResource<XResource::Pixmap>::deleteXResource):
		59	(WebCore::XUniqueResource<XResource::Window>::deleteXResource):
		60	(WebCore::XUniqueResource<XResource::GLXPbuffer>::deleteXResource):
		61	(WebCore::XUniqueResource<XResource::GLXPixmap>::deleteXResource):
		62	* platform/graphics/x11/XUniqueResource.h: Added.
		63	(WebCore::XUniqueResource::XUniqueResource):
		64	(WebCore::XUniqueResource::operator=):
65	(WebCore::XUniqueResource::~XUniqueResource):
66	(WebCore::XUniqueResource::get):
67	(WebCore::XUniqueResource::release):
68	(WebCore::XUniqueResource::reset):
69	(WebCore::XUniqueResource::operator!):
70	(WebCore::XUniqueResource::operator UnspecifiedBoolType*):
71
1	2015-05-05 Carlos Garcia Campos <cgarcia@igalia.com>	72	2015-05-05 Carlos Garcia Campos <cgarcia@igalia.com>
2		73
3	[SOUP] Network Cache: Implement ShareableResource for Soup and enable it for GTK platform	74	[SOUP] Network Cache: Implement ShareableResource for Soup and enable it for GTK platform

Lines 26-42 a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp_sec1
- a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp -8 / +6 lines
26		26
27	namespace WebCore {	27	namespace WebCore {
28		28
29	BackingStoreBackendCairoX11::BackingStoreBackendCairoX11(Display* display, unsigned long rootWindowID, Visual* visual, int depth, const IntSize& size, float deviceScaleFactor)	29	BackingStoreBackendCairoX11::BackingStoreBackendCairoX11(unsigned long rootWindowID, Visual* visual, int depth, const IntSize& size, float deviceScaleFactor)
30	: BackingStoreBackendCairo(size)	30	: BackingStoreBackendCairo(size)
31	, m_display(display)
32	{	31	{
33	IntSize scaledSize = size;	32	IntSize scaledSize = size;
34	scaledSize.scale(deviceScaleFactor);	33	scaledSize.scale(deviceScaleFactor);
35		34
36	m_pixmap = XCreatePixmap(m_display, rootWindowID, scaledSize.width(), scaledSize.height(), depth);	35	auto* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
37	m_gc = XCreateGC(m_display, m_pixmap, 0, nullptr);	36	m_pixmap = XCreatePixmap(display, rootWindowID, scaledSize.width(), scaledSize.height(), depth);
		37	m_gc.reset(XCreateGC(display, m_pixmap.get(), 0, nullptr));
38		38
39	m_surface = adoptRef(cairo_xlib_surface_create(m_display, m_pixmap, visual, scaledSize.width(), scaledSize.height()));	39	m_surface = adoptRef(cairo_xlib_surface_create(display, m_pixmap.get(), visual, scaledSize.width(), scaledSize.height()));
40	cairoSurfaceSetDeviceScale(m_surface.get(), deviceScaleFactor, deviceScaleFactor);	40	cairoSurfaceSetDeviceScale(m_surface.get(), deviceScaleFactor, deviceScaleFactor);
41	}	41	}
42		42
Lines 44-51 BackingStoreBackendCairoX11::~BackingStoreBackendCairoX11() a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp_sec2
44	{	44	{
45	// The pixmap needs to exist when the surface is destroyed, so begin by clearing it.	45	// The pixmap needs to exist when the surface is destroyed, so begin by clearing it.
46	m_surface.clear();	46	m_surface.clear();
47	XFreePixmap(m_display, m_pixmap);
48	XFreeGC(m_display, m_gc);
49	}	47	}
50		48
51	void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSize& scrollOffset)	49	void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSize& scrollOffset)
Lines 65-71 void BackingStoreBackendCairoX11::scroll(const IntRect& scrollRect, const IntSiz a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.cpp_sec3
65	scaledScrollOffset.scale(xScale, yScale);	63	scaledScrollOffset.scale(xScale, yScale);
66		64
67	cairo_surface_flush(m_surface.get());	65	cairo_surface_flush(m_surface.get());
68	XCopyArea(m_display, m_pixmap, m_pixmap, m_gc,	66	XCopyArea(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), m_pixmap.get(), m_pixmap.get(), m_gc.get(),
69	targetRect.x() - scaledScrollOffset.width(), targetRect.y() - scaledScrollOffset.height(),	67	targetRect.x() - scaledScrollOffset.width(), targetRect.y() - scaledScrollOffset.height(),
70	targetRect.width(), targetRect.height(), targetRect.x(), targetRect.y());	68	targetRect.width(), targetRect.height(), targetRect.x(), targetRect.y());
71	cairo_surface_mark_dirty_rectangle(m_surface.get(), targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height());	69	cairo_surface_mark_dirty_rectangle(m_surface.get(), targetRect.x(), targetRect.y(), targetRect.width(), targetRect.height());

Lines 22-42 a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.h_sec1
- a/Source/WebCore/platform/graphics/cairo/BackingStoreBackendCairoX11.h -5 / +5 lines
22	#include "BackingStoreBackendCairo.h"	22	#include "BackingStoreBackendCairo.h"
23		23
24	#if USE(CAIRO) && PLATFORM(X11)	24	#if USE(CAIRO) && PLATFORM(X11)
25	#include <X11/Xlib.h>	25	#include "XUniquePtr.h"
		26	#include "XUniqueResource.h"
26		27
27	namespace WebCore {	28	namespace WebCore {
28		29
29	class BackingStoreBackendCairoX11 final : public BackingStoreBackendCairo {	30	class BackingStoreBackendCairoX11 final : public BackingStoreBackendCairo {
30	public:	31	public:
31	BackingStoreBackendCairoX11(Display, unsigned long rootWindowID, Visual, int depth, const IntSize&, float deviceScaleFactor);	32	BackingStoreBackendCairoX11(unsigned long rootWindowID, Visual*, int depth, const IntSize&, float deviceScaleFactor);
32	virtual ~BackingStoreBackendCairoX11();	33	virtual ~BackingStoreBackendCairoX11();
33		34
34	void scroll(const IntRect& scrollRect, const IntSize& scrollOffset) override;	35	void scroll(const IntRect& scrollRect, const IntSize& scrollOffset) override;
35		36
36	private:	37	private:
37	Display* m_display;	38	XUniquePixmap m_pixmap;
38	Pixmap m_pixmap;	39	XUniqueGC m_gc;
39	GC m_gc;
40	};	40	};
41		41
42	} // namespace WebCore	42	} // namespace WebCore

Lines 43-67 std::unique_ptr<GLContextGLX> GLContextGLX::createWindowContext(XID window, GLCo a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec1
- a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp -81 / +41 lines
43	visualInfo.visualid = XVisualIDFromVisual(attributes.visual);	43	visualInfo.visualid = XVisualIDFromVisual(attributes.visual);
44		44
45	int numReturned = 0;	45	int numReturned = 0;
46	XVisualInfo* visualInfoList = XGetVisualInfo(display, VisualIDMask, &visualInfo, &numReturned);	46	XUniquePtr<XVisualInfo> visualInfoList(XGetVisualInfo(display, VisualIDMask, &visualInfo, &numReturned));
47
48	GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context : 0;
49	GLXContext context = glXCreateContext(display, visualInfoList, glxSharingContext, True);
50	XFree(visualInfoList);
51		47
		48	GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context.get() : nullptr;
		49	XUniqueGLXContext context(glXCreateContext(display, visualInfoList.get(), glxSharingContext, True));
52	if (!context)	50	if (!context)
53	return nullptr;	51	return nullptr;
54		52
55	// GLXPbuffer and XID are both the same types underneath, so we have to share	53	return std::make_unique<GLContextGLX>(WTF::move(context), window);
56	// a constructor here with the window path.
57	auto contextWrapper = std::make_unique<GLContextGLX>(context);
58	contextWrapper->m_window = window;
59	return WTF::move(contextWrapper);
60	}	54	}
61		55
62	std::unique_ptr<GLContextGLX> GLContextGLX::createPbufferContext(GLXContext sharingContext)	56	std::unique_ptr<GLContextGLX> GLContextGLX::createPbufferContext(GLXContext sharingContext)
63	{	57	{
64	int fbConfigAttributes[] = {	58	static const int fbConfigAttributes[] = {
65	GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,	59	GLX_DRAWABLE_TYPE, GLX_PBUFFER_BIT,
66	GLX_RENDER_TYPE, GLX_RGBA_BIT,	60	GLX_RENDER_TYPE, GLX_RGBA_BIT,
67	GLX_RED_SIZE, 1,	61	GLX_RED_SIZE, 1,
Lines 74-105 std::unique_ptr<GLContextGLX> GLContextGLX::createPbufferContext(GLXContext shar a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec2
74		68
75	int returnedElements;	69	int returnedElements;
76	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();	70	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
77	GLXFBConfig* configs = glXChooseFBConfig(display, 0, fbConfigAttributes, &returnedElements);	71	XUniquePtr<GLXFBConfig> configs(glXChooseFBConfig(display, 0, fbConfigAttributes, &returnedElements));
78	if (!returnedElements) {	72	if (!returnedElements)
79	XFree(configs);
80	return nullptr;	73	return nullptr;
81	}
82		74
83	// We will be rendering to a texture, so our pbuffer does not need to be large.	75	// We will be rendering to a texture, so our pbuffer does not need to be large.
84	static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };	76	static const int pbufferAttributes[] = { GLX_PBUFFER_WIDTH, 1, GLX_PBUFFER_HEIGHT, 1, 0 };
85	GLXPbuffer pbuffer = glXCreatePbuffer(display, configs[0], pbufferAttributes);	77	XUniqueGLXPbuffer pbuffer(glXCreatePbuffer(display, configs.get()[0], pbufferAttributes));
86	if (!pbuffer) {	78	if (!pbuffer)
87	XFree(configs);
88	return nullptr;	79	return nullptr;
89	}
90		80
91	GLXContext context = glXCreateNewContext(display, configs[0], GLX_RGBA_TYPE, sharingContext, GL_TRUE);	81	XUniqueGLXContext context(glXCreateNewContext(display, configs.get()[0], GLX_RGBA_TYPE, sharingContext, GL_TRUE));
92	XFree(configs);	82	if (!context)
93	if (!context) {
94	glXDestroyPbuffer(display, pbuffer);
95	return nullptr;	83	return nullptr;
96	}
97		84
98	// GLXPbuffer and XID are both the same types underneath, so we have to share	85	return std::make_unique<GLContextGLX>(WTF::move(context), WTF::move(pbuffer));
99	// a constructor here with the window path.
100	auto contextWrapper = std::make_unique<GLContextGLX>(context);
101	contextWrapper->m_pbuffer = pbuffer;
102	return WTF::move(contextWrapper);
103	}	86	}
104		87
105	std::unique_ptr<GLContextGLX> GLContextGLX::createPixmapContext(GLXContext sharingContext)	88	std::unique_ptr<GLContextGLX> GLContextGLX::createPixmapContext(GLXContext sharingContext)
Lines 114-144 std::unique_ptr<GLContextGLX> GLContextGLX::createPixmapContext(GLXContext shari a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec3
114	};	97	};
115		98
116	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();	99	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
117	XVisualInfo* visualInfo = glXChooseVisual(display, DefaultScreen(display), visualAttributes);	100	XUniquePtr<XVisualInfo> visualInfo(glXChooseVisual(display, DefaultScreen(display), visualAttributes));
118	if (!visualInfo)	101	if (!visualInfo)
119	return nullptr;	102	return nullptr;
120		103
121	GLXContext context = glXCreateContext(display, visualInfo, sharingContext, GL_TRUE);	104	XUniqueGLXContext context(glXCreateContext(display, visualInfo.get(), sharingContext, GL_TRUE));
122	if (!context) {	105	if (!context)
123	XFree(visualInfo);
124	return nullptr;	106	return nullptr;
125	}
126		107
127	Pixmap pixmap = XCreatePixmap(display, DefaultRootWindow(display), 1, 1, visualInfo->depth);	108	XUniquePixmap pixmap(XCreatePixmap(display, DefaultRootWindow(display), 1, 1, visualInfo->depth));
128	if (!pixmap) {	109	if (!pixmap)
129	XFree(visualInfo);
130	return nullptr;	110	return nullptr;
131	}
132		111
133	GLXPixmap glxPixmap = glXCreateGLXPixmap(display, visualInfo, pixmap);	112	XUniqueGLXPixmap glxPixmap(glXCreateGLXPixmap(display, visualInfo.get(), pixmap.get()));
134	if (!glxPixmap) {	113	if (!glxPixmap)
135	XFreePixmap(display, pixmap);
136	XFree(visualInfo);
137	return nullptr;	114	return nullptr;
138	}
139		115
140	XFree(visualInfo);	116	return std::make_unique<GLContextGLX>(WTF::move(context), WTF::move(pixmap), WTF::move(glxPixmap));
141	return std::make_unique<GLContextGLX>(context, pixmap, glxPixmap);
142	}	117	}
143		118
144	std::unique_ptr<GLContextGLX> GLContextGLX::createContext(XID window, GLContext* sharingContext)	119	std::unique_ptr<GLContextGLX> GLContextGLX::createContext(XID window, GLContext* sharingContext)
Lines 152-158 std::unique_ptr<GLContextGLX> GLContextGLX::createContext(XID window, GLContext* a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec4
152	if (!success)	127	if (!success)
153	return nullptr;	128	return nullptr;
154		129
155	GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context : 0;	130	GLXContext glxSharingContext = sharingContext ? static_cast<GLContextGLX*>(sharingContext)->m_context.get() : nullptr;
156	auto context = window ? createWindowContext(window, sharingContext) : nullptr;	131	auto context = window ? createWindowContext(window, sharingContext) : nullptr;
157	if (!context)	132	if (!context)
158	context = createPbufferContext(glxSharingContext);	133	context = createPbufferContext(glxSharingContext);
Lines 164-186 std::unique_ptr<GLContextGLX> GLContextGLX::createContext(XID window, GLContext* a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec5
164	return WTF::move(context);	139	return WTF::move(context);
165	}	140	}
166		141
167	GLContextGLX::GLContextGLX(GLXContext context)	142	GLContextGLX::GLContextGLX(XUniqueGLXContext&& context, XID window)
168	: m_context(context)	143	: m_context(WTF::move(context))
169	, m_window(0)	144	, m_window(window)
170	, m_pbuffer(0)
171	, m_pixmap(0)
172	, m_glxPixmap(0)
173	, m_cairoDevice(0)
174	{	145	{
175	}	146	}
176		147
177	GLContextGLX::GLContextGLX(GLXContext context, Pixmap pixmap, GLXPixmap glxPixmap)	148	GLContextGLX::GLContextGLX(XUniqueGLXContext&& context, XUniqueGLXPbuffer&& pbuffer)
178	: m_context(context)	149	: m_context(WTF::move(context))
179	, m_window(0)	150	, m_pbuffer(WTF::move(pbuffer))
180	, m_pbuffer(0)	151	{
181	, m_pixmap(pixmap)	152	}
182	, m_glxPixmap(glxPixmap)	153
183	, m_cairoDevice(0)	154	GLContextGLX::GLContextGLX(XUniqueGLXContext&& context, XUniquePixmap&& pixmap, XUniqueGLXPixmap&& glxPixmap)
		155	: m_context(WTF::move(context))
		156	, m_pixmap(WTF::move(pixmap))
		157	, m_glxPixmap(WTF::move(glxPixmap))
184	{	158	{
185	}	159	}
186		160
Lines 189-214 GLContextGLX::~GLContextGLX() a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec6
189	if (m_cairoDevice)	163	if (m_cairoDevice)
190	cairo_device_destroy(m_cairoDevice);	164	cairo_device_destroy(m_cairoDevice);
191		165
192	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
193	if (m_context) {	166	if (m_context) {
194	// This may be necessary to prevent crashes with NVidia's closed source drivers. Originally	167	// This may be necessary to prevent crashes with NVidia's closed source drivers. Originally
195	// from Mozilla's 3D canvas implementation at: http://bitbucket.org/ilmari/canvas3d/	168	// from Mozilla's 3D canvas implementation at: http://bitbucket.org/ilmari/canvas3d/
		169	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
196	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);	170	glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
197	glXMakeCurrent(display, None, None);	171	glXMakeCurrent(display, None, None);
198	glXDestroyContext(display, m_context);
199	}
200
201	if (m_pbuffer) {
202	glXDestroyPbuffer(display, m_pbuffer);
203	m_pbuffer = 0;
204	}
205	if (m_glxPixmap) {
206	glXDestroyGLXPixmap(display, m_glxPixmap);
207	m_glxPixmap = 0;
208	}
209	if (m_pixmap) {
210	XFreePixmap(display, m_pixmap);
211	m_pixmap = 0;
212	}	172	}
213	}	173	}
214		174
Lines 237-253 bool GLContextGLX::makeContextCurrent() a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec7
237	ASSERT(m_context && (m_window \|\| m_pbuffer \|\| m_glxPixmap));	197	ASSERT(m_context && (m_window \|\| m_pbuffer \|\| m_glxPixmap));
238		198
239	GLContext::makeContextCurrent();	199	GLContext::makeContextCurrent();
240	if (glXGetCurrentContext() == m_context)	200	if (glXGetCurrentContext() == m_context.get())
241	return true;	201	return true;
242		202
243	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();	203	Display* display = downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native();
244	if (m_window)	204	if (m_window)
245	return glXMakeCurrent(display, m_window, m_context);	205	return glXMakeCurrent(display, m_window, m_context.get());
246		206
247	if (m_pbuffer)	207	if (m_pbuffer)
248	return glXMakeCurrent(display, m_pbuffer, m_context);	208	return glXMakeCurrent(display, m_pbuffer.get(), m_context.get());
249		209
250	return ::glXMakeCurrent(display, m_glxPixmap, m_context);	210	return ::glXMakeCurrent(display, m_glxPixmap.get(), m_context.get());
251	}	211	}
252		212
253	void GLContextGLX::swapBuffers()	213	void GLContextGLX::swapBuffers()
Lines 267-273 cairo_device_t* GLContextGLX::cairoDevice() a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec8
267	return m_cairoDevice;	227	return m_cairoDevice;
268		228
269	#if ENABLE(ACCELERATED_2D_CANVAS)	229	#if ENABLE(ACCELERATED_2D_CANVAS)
270	m_cairoDevice = cairo_glx_device_create(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), m_context);	230	m_cairoDevice = cairo_glx_device_create(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), m_context.get());
271	#endif	231	#endif
272		232
273	return m_cairoDevice;	233	return m_cairoDevice;
Lines 276-282 cairo_device_t* GLContextGLX::cairoDevice() a/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp_sec9
276	#if ENABLE(GRAPHICS_CONTEXT_3D)	236	#if ENABLE(GRAPHICS_CONTEXT_3D)
277	PlatformGraphicsContext3D GLContextGLX::platformContext()	237	PlatformGraphicsContext3D GLContextGLX::platformContext()
278	{	238	{
279	return m_context;	239	return m_context.get();
280	}	240	}
281	#endif	241	#endif
282		242

Lines 141-147 void EGLPixmapSurface::destroy() a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.cpp_sec1
- a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.cpp -11 / +3 lines
141		141
142	EGLXTransportSurfaceClient::EGLXTransportSurfaceClient(const PlatformBufferHandle handle, const IntSize& size, bool hasAlpha)	142	EGLXTransportSurfaceClient::EGLXTransportSurfaceClient(const PlatformBufferHandle handle, const IntSize& size, bool hasAlpha)
143	: GLTransportSurfaceClient()	143	: GLTransportSurfaceClient()
144	, m_image(0)
145	, m_size(size)	144	, m_size(size)
146	, m_totalBytes(0)	145	, m_totalBytes(0)
147	{	146	{
Lines 197-207 void EGLXTransportSurfaceClient::destroy() a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.cpp_sec2
197	}	196	}
198		197
199	eglWaitGL();	198	eglWaitGL();
200		199	m_image = nullptr;
201	if (m_image) {
202	XDestroyImage(m_image);
203	m_image = 0;
204	}
205	}	200	}
206		201
207	void EGLXTransportSurfaceClient::prepareTexture()	202	void EGLXTransportSurfaceClient::prepareTexture()
Lines 214-220 void EGLXTransportSurfaceClient::prepareTexture() a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.cpp_sec3
214	}	209	}
215		210
216	// Fallback to use XImage in case EGLImage and TextureToPixmap are not supported.	211	// Fallback to use XImage in case EGLImage and TextureToPixmap are not supported.
217	m_image = XGetImage(NativeWrapper::nativeDisplay(), m_handle, 0, 0, m_size.width(), m_size.height(), AllPlanes, ZPixmap);	212	m_image.reset(XGetImage(NativeWrapper::nativeDisplay(), m_handle, 0, 0, m_size.width(), m_size.height(), AllPlanes, ZPixmap));
218		213
219	#if USE(OPENGL_ES_2)	214	#if USE(OPENGL_ES_2)
220	if (m_format != GraphicsContext3D::BGRA) {	215	if (m_format != GraphicsContext3D::BGRA) {
Lines 225-234 void EGLXTransportSurfaceClient::prepareTexture() a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.cpp_sec4
225		220
226	glTexImage2D(GL_TEXTURE_2D, 0, m_format, m_size.width(), m_size.height(), 0, m_format, GL_UNSIGNED_BYTE, m_image->data);	221	glTexImage2D(GL_TEXTURE_2D, 0, m_format, m_size.width(), m_size.height(), 0, m_format, GL_UNSIGNED_BYTE, m_image->data);
227		222
228	if (m_image) {	223	m_image = nullptr;
229	XDestroyImage(m_image);
230	m_image = 0;
231	}
232	}	224	}
233		225
234	EGLTextureFromPixmap::EGLTextureFromPixmap(const NativePixmap handle, bool hasAlpha, EGLConfig config)	226	EGLTextureFromPixmap::EGLTextureFromPixmap(const NativePixmap handle, bool hasAlpha, EGLConfig config)

Lines 29-39 a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.h_sec1
- a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.h -2 / +2 lines
29	#if PLATFORM(X11) && USE(EGL) && USE(GRAPHICS_SURFACE)	29	#if PLATFORM(X11) && USE(EGL) && USE(GRAPHICS_SURFACE)
30		30
31	#include "EGLSurface.h"	31	#include "EGLSurface.h"
		32	#include "XUniquePtr.h"
32	#include <glx/X11Helper.h>	33	#include <glx/X11Helper.h>
33		34
34	namespace WebCore {	35	namespace WebCore {
35		36
36	typedef X11Helper NativeWrapper;
37	typedef Pixmap NativePixmap;	37	typedef Pixmap NativePixmap;
38		38
39	// Contents of the surface are backed by native window.	39	// Contents of the surface are backed by native window.
Lines 74-80 public: a/Source/WebCore/platform/graphics/surfaces/egl/EGLXSurface.h_sec2
74	virtual void destroy() override;	74	virtual void destroy() override;
75		75
76	private:	76	private:
77	XImage* m_image;	77	XUniquePtr<XImage> m_image;
78	IntSize m_size;	78	IntSize m_size;
79	PlatformBufferHandle m_handle;	79	PlatformBufferHandle m_handle;
80	GLuint m_format;	80	GLuint m_format;

Lines 27-32 a/Source/WebCore/platform/graphics/surfaces/glx/X11Helper.cpp_sec1
- a/Source/WebCore/platform/graphics/surfaces/glx/X11Helper.cpp -2 / +3 lines
27	#include "X11Helper.h"	27	#include "X11Helper.h"
28		28
29	#include "PlatformDisplayX11.h"	29	#include "PlatformDisplayX11.h"
		30	#include "XUniquePtr.h"
30		31
31	namespace WebCore {	32	namespace WebCore {
32		33
Lines 223-229 void X11Helper::createOffScreenWindow(uint32_t* handleId, const EGLint id, bool a/Source/WebCore/platform/graphics/surfaces/glx/X11Helper.cpp_sec2
223	memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));	224	memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
224	visualInfoTemplate.visualid = visualId;	225	visualInfoTemplate.visualid = visualId;
225	int matchingCount = 0;	226	int matchingCount = 0;
226	std::unique_ptr<XVisualInfo, X11Deleter> matchingVisuals(XGetVisualInfo(nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount));	227	XUniquePtr<XVisualInfo> matchingVisuals(XGetVisualInfo(nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount));
227	XVisualInfo* foundVisual = 0;	228	XVisualInfo* foundVisual = 0;
228		229
229	if (matchingVisuals) {	230	if (matchingVisuals) {
Lines 260-266 void X11Helper::createPixmap(Pixmap* handleId, const EGLint id, bool hasAlpha, c a/Source/WebCore/platform/graphics/surfaces/glx/X11Helper.cpp_sec3
260	memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));	261	memset(&visualInfoTemplate, 0, sizeof(XVisualInfo));
261	visualInfoTemplate.visualid = visualId;	262	visualInfoTemplate.visualid = visualId;
262	int matchingCount = 0;	263	int matchingCount = 0;
263	std::unique_ptr<XVisualInfo, X11Deleter> matchingVisuals(XGetVisualInfo(nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount));	264	XUniquePtr<XVisualInfo> matchingVisuals(XGetVisualInfo(nativeDisplay(), VisualIDMask, &visualInfoTemplate, &matchingCount));
264	XVisualInfo* foundVisual = 0;	265	XVisualInfo* foundVisual = 0;
265	int requiredDepth = hasAlpha ? 32 : 24;	266	int requiredDepth = hasAlpha ? 32 : 24;
266		267

Line 0 a/Source/WebCore/platform/graphics/x11/XUniquePtr.h_sec1
- a/Source/WebCore/platform/graphics/x11/XUniquePtr.h +86 lines
		1	/*
		2	* Copyright (C) 2015 Igalia S.L
		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	*
		8	* 1. Redistributions of source code must retain the above copyright
		9	* notice, this list of conditions and the following disclaimer.
		10	* 2. Redistributions in binary form must reproduce the above copyright
		11	* notice, this list of conditions and the following disclaimer in the
		12	* documentation and/or other materials provided with the distribution.
		13	*
		14	* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
		15	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
		16	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
		17	* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
		18	* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
		19	* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
		20	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
		21	* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
		22	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
		23	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
		24	*/
		25
		26	#ifndef XUniquePtr_h
		27	#define XUniquePtr_h
		28
		29	#if PLATFORM(X11)
		30	#include "PlatformDisplayX11.h"
		31	#include <X11/Xutil.h>
		32
		33	#if USE(GLX)
		34	typedef struct __GLXcontextRec* GLXContext;
		35	extern "C" void glXDestroyContext(Display*, GLXContext);
		36	#endif
		37
		38	namespace WebCore {
		39
		40	template<typename T>
		41	struct XPtrDeleter {
		42	void operator()(T* ptr) const
		43	{
		44	if (ptr)
		45	XFree(ptr);
		46	}
		47	};
		48
		49	template<typename T>
		50	using XUniquePtr = std::unique_ptr<T, XPtrDeleter<T>>;
		51
		52	template<> struct XPtrDeleter<XImage> {
		53	void operator() (XImage* ptr) const
		54	{
		55	if (ptr)
		56	XDestroyImage(ptr);
		57	}
		58	};
		59
		60	template<> struct XPtrDeleter<_XGC> {
		61	void operator() (_XGC* ptr) const
		62	{
		63	if (ptr)
		64	XFreeGC(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), ptr);
65	}
66	};
67	// Give a name to this to avoid having to use the internal struct name.
68	using XUniqueGC = XUniquePtr<_XGC>;
69
70	#if USE(GLX)
71	template<> struct XPtrDeleter<__GLXcontextRec> {
72	void operator() (__GLXcontextRec* ptr)
73	{
74	if (ptr)
75	glXDestroyContext(downcast<PlatformDisplayX11>(PlatformDisplay::sharedDisplay()).native(), ptr);
76	}
77	};
78	// Give a name to this to avoid having to use the internal struct name.
79	using XUniqueGLXContext = XUniquePtr<__GLXcontextRec>;
80	#endif
81
82	} // namespace WebCore
83
84	#endif // PLATFORM(X11)
85
86	#endif // XUniquePtr_h

Lines 1-3 a/Source/WebKit2/ChangeLog_sec1
- a/Source/WebKit2/ChangeLog +30 lines
		1	2015-05-08 Carlos Garcia Campos <cgarcia@igalia.com>
		2
		3	[X11] Add XUniquePtr and XUniqueResource to automatically free X resources
		4	https://bugs.webkit.org/show_bug.cgi?id=144521
		5
		6	Reviewed by Darin Adler.
		7
		8	Use XUniquePtr and XUniqueResource to free X resources.
		9
		10	* PlatformEfl.cmake: Add Source/WebCore/platform/graphics/x11 dir
		11	to the include dir list.
		12	* PlatformGTK.cmake: Ditto.
		13	* UIProcess/cairo/BackingStoreCairo.cpp:
		14	(WebKit::BackingStore::createBackend): Do not pass the display to
		15	the BackingStoreBackendCairoX11 constructor.
		16	* UIProcess/gtk/RedirectedXCompositeWindow.cpp:
		17	(WebKit::RedirectedXCompositeWindow::RedirectedXCompositeWindow):
		18	(WebKit::RedirectedXCompositeWindow::~RedirectedXCompositeWindow):
		19	(WebKit::RedirectedXCompositeWindow::resize):
		20	(WebKit::RedirectedXCompositeWindow::cleanupPixmapAndPixmapSurface):
		21	(WebKit::RedirectedXCompositeWindow::surface):
		22	* UIProcess/gtk/RedirectedXCompositeWindow.h:
		23	(WebKit::RedirectedXCompositeWindow::windowID):
		24	* WebProcess/Plugins/Netscape/NetscapePlugin.h:
		25	* WebProcess/Plugins/Netscape/x11/NetscapePluginX11.cpp:
		26	(WebKit::NetscapePlugin::platformPostInitializeWindowless):
		27	(WebKit::NetscapePlugin::platformDestroy):
		28	(WebKit::NetscapePlugin::platformGeometryDidChange):
		29	(WebKit::NetscapePlugin::platformPaint):
		30
1	2015-05-05 Carlos Garcia Campos <cgarcia@igalia.com>	31	2015-05-05 Carlos Garcia Campos <cgarcia@igalia.com>
2		32
3	[SOUP] Network Cache: Implement ShareableResource for Soup and enable it for GTK platform	33	[SOUP] Network Cache: Implement ShareableResource for Soup and enable it for GTK platform

Lines 31-41 a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.h_sec1
- a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.h -7 / +8 lines
31		31
32	#include <WebCore/IntSize.h>	32	#include <WebCore/IntSize.h>
33	#include <WebCore/RefPtrCairo.h>	33	#include <WebCore/RefPtrCairo.h>
34	#include <X11/Xlib.h>	34	#include <WebCore/XUniqueResource.h>
35	#include <functional>	35	#include <functional>
36		36
37	typedef struct _GdkWindow GdkWindow;	37	typedef struct _GdkWindow GdkWindow;
38	typedef unsigned long Damage;	38	typedef struct _XDisplay Display;
		39	typedef unsigned long Window;
39		40
40	namespace WebKit {	41	namespace WebKit {
41		42
Lines 44-50 public: a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.h_sec2
44	static std::unique_ptr<RedirectedXCompositeWindow> create(GdkWindow*, std::function<void()> damageNotify);	45	static std::unique_ptr<RedirectedXCompositeWindow> create(GdkWindow*, std::function<void()> damageNotify);
45	~RedirectedXCompositeWindow();	46	~RedirectedXCompositeWindow();
46		47
47	Window windowID() const { return m_window; }	48	Window windowID() const { return m_window.get(); }
48	void resize(const WebCore::IntSize&);	49	void resize(const WebCore::IntSize&);
49	cairo_surface_t* surface();	50	cairo_surface_t* surface();
50		51
Lines 54-63 private: a/Source/WebKit2/UIProcess/gtk/RedirectedXCompositeWindow.h_sec3
54		55
55	Display* m_display;	56	Display* m_display;
56	WebCore::IntSize m_size;	57	WebCore::IntSize m_size;
57	Window m_window;	58	WebCore::XUniqueWindow m_window;
58	Window m_parentWindow;	59	WebCore::XUniqueWindow m_parentWindow;
59	Pixmap m_pixmap;	60	WebCore::XUniquePixmap m_pixmap;
60	Damage m_damage;	61	WebCore::XUniqueDamage m_damage;
61	RefPtr<cairo_surface_t> m_surface;	62	RefPtr<cairo_surface_t> m_surface;
62	bool m_needsNewPixmapAfterResize;	63	bool m_needsNewPixmapAfterResize;
63	};	64	};