Diff
Modified: trunk/Source/WebCore/ChangeLog (120261 => 120262)
--- trunk/Source/WebCore/ChangeLog 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebCore/ChangeLog 2012-06-14 00:13:48 UTC (rev 120262)
@@ -1,3 +1,22 @@
+2012-06-13 Martin Robinson <[email protected]>
+
+ [GTK] Add an accelerated compositing implementation for WebKit2
+ https://bugs.webkit.org/show_bug.cgi?id=86037
+
+ Reviewed by Alejandro G. Castro.
+
+ No new tests. These changes are covered by the compositing tests, which
+ we will gradually try to turn on for the bots.
+
+ Add a new GLContext method for getting to current default framebuffer size, which
+ is quite useful for preventing composited content quivering while resizing.
+
+ * platform/graphics/cairo/GLContext.h:
+ * platform/graphics/glx/GLContextGLX.cpp:
+ (WebCore::GLContextGLX::defaultFrameBufferSize): Added this implementation for X11
+ which asks the X server for the window size.
+ * platform/graphics/glx/GLContextGLX.h:
+
2012-06-13 Shawn Singh <[email protected]>
[chromium] Implement hit-testing for impl-side input handling in accelerated compositor
Modified: trunk/Source/WebCore/platform/graphics/cairo/GLContext.h (120261 => 120262)
--- trunk/Source/WebCore/platform/graphics/cairo/GLContext.h 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebCore/platform/graphics/cairo/GLContext.h 2012-06-14 00:13:48 UTC (rev 120262)
@@ -40,6 +40,7 @@
virtual bool makeContextCurrent();
virtual void swapBuffers() = 0;
virtual bool canRenderToDefaultFramebuffer() = 0;
+ virtual IntSize defaultFrameBufferSize() = 0;
#if ENABLE(WEBGL)
virtual PlatformGraphicsContext3D platformContext() = 0;
Modified: trunk/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp (120261 => 120262)
--- trunk/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebCore/platform/graphics/glx/GLContextGLX.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -262,6 +262,20 @@
return m_window;
}
+IntSize GLContextGLX::defaultFrameBufferSize()
+{
+ if (!canRenderToDefaultFramebuffer() || !m_window)
+ return IntSize();
+
+ int x, y;
+ Window rootWindow;
+ unsigned int width, height, borderWidth, depth;
+ if (!XGetGeometry(sharedDisplay(), m_window, &rootWindow, &x, &y, &width, &height, &borderWidth, &depth))
+ return IntSize();
+
+ return IntSize(width, height);
+}
+
bool GLContextGLX::makeContextCurrent()
{
ASSERT(m_context && (m_window || m_pbuffer || m_glxPixmap));
Modified: trunk/Source/WebCore/platform/graphics/glx/GLContextGLX.h (120261 => 120262)
--- trunk/Source/WebCore/platform/graphics/glx/GLContextGLX.h 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebCore/platform/graphics/glx/GLContextGLX.h 2012-06-14 00:13:48 UTC (rev 120262)
@@ -46,6 +46,7 @@
virtual bool makeContextCurrent();
virtual void swapBuffers();
virtual bool canRenderToDefaultFramebuffer();
+ virtual IntSize defaultFrameBufferSize();
#if ENABLE(WEBGL)
virtual PlatformGraphicsContext3D platformContext();
Modified: trunk/Source/WebKit2/ChangeLog (120261 => 120262)
--- trunk/Source/WebKit2/ChangeLog 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/ChangeLog 2012-06-14 00:13:48 UTC (rev 120262)
@@ -1,3 +1,26 @@
+2012-06-13 Martin Robinson <[email protected]>
+
+ [GTK] Add an accelerated compositing implementation for WebKit2
+ https://bugs.webkit.org/show_bug.cgi?id=86037
+
+ Reviewed by Alejandro G. Castro.
+
+ Add an implementation of LayerTreeHost for GTK+ that uses TextureMapperGL.
+ Later this implementation will fall back to using the ImageBuffer TextureMapper.
+
+ * GNUmakefile.am: Add new files to the compilation.
+ * Shared/LayerTreeContext.h:
+ (LayerTreeContext): The GTK+ version of the LayerTreeContext just holds window handle.
+ * Shared/gtk/LayerTreeContextGtk.cpp: Copied from Source/WebKit2/WebProcess/WebPage/LayerTreeHost.cpp.
+ * WebProcess/WebPage/gtk/LayerTreeHostGtk.h: Added.
+ * WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp: Added.
+ Add this LayerTreeHost implementation that just creates a GL context from the widget X11 window ID.
+ Later implementations might find a more cross-platform solution.
+ * WebProcess/WebPage/gtk/WebPageGtk.cpp:
+ (WebKit::WebPage::platformInitialize): Initialize the native window handle to be zero.
+ (WebKit::WebPage::widgetMapped): When mapping the widget, try to get the native window
+ handle and send it to the WebProcess.
+
2012-06-13 Andras Becsi <[email protected]>
[Qt][WK2] ASSERT(m_rawAttributes.initialScale > 0) in QtViewportHandler::initialRect()
Modified: trunk/Source/WebKit2/GNUmakefile.list.am (120261 => 120262)
--- trunk/Source/WebKit2/GNUmakefile.list.am 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/GNUmakefile.list.am 2012-06-14 00:13:48 UTC (rev 120262)
@@ -344,10 +344,10 @@
Source/WebKit2/Shared/EditorState.h \
Source/WebKit2/Shared/FontSmoothingLevel.h \
Source/WebKit2/Shared/ProcessExecutablePath.h \
- Source/WebKit2/Shared/cairo/LayerTreeContextCairo.cpp \
Source/WebKit2/Shared/cairo/ShareableBitmapCairo.cpp \
Source/WebKit2/Shared/gtk/ArgumentCodersGtk.h \
Source/WebKit2/Shared/gtk/ArgumentCodersGtk.cpp \
+ Source/WebKit2/Shared/gtk/LayerTreeContextGtk.cpp \
Source/WebKit2/Shared/gtk/NativeWebKeyboardEventGtk.cpp \
Source/WebKit2/Shared/gtk/NativeWebMouseEventGtk.cpp \
Source/WebKit2/Shared/gtk/NativeWebWheelEventGtk.cpp \
@@ -1059,6 +1059,12 @@
Source/WebKit2/WebProcess/WebProcess.cpp \
Source/WebKit2/WebProcess/WebProcess.h
+if USE_TEXTURE_MAPPER_GL
+webkit2_sources += \
+ Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp \
+ Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.h
+endif # END USE_TEXTURE_MAPPER_GL
+
if ENABLE_PLUGIN_PROCESS
webkit2_plugin_process_built_sources += \
Modified: trunk/Source/WebKit2/Shared/LayerTreeContext.h (120261 => 120262)
--- trunk/Source/WebKit2/Shared/LayerTreeContext.h 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/Shared/LayerTreeContext.h 2012-06-14 00:13:48 UTC (rev 120262)
@@ -56,6 +56,8 @@
HWND window;
#elif PLATFORM(QT)
uint32_t webLayerID;
+#elif PLATFORM(GTK)
+ uint64_t windowHandle;
#endif
};
Copied: trunk/Source/WebKit2/Shared/gtk/LayerTreeContextGtk.cpp (from rev 120261, trunk/Source/WebKit2/WebProcess/WebPage/LayerTreeHost.cpp) (0 => 120262)
--- trunk/Source/WebKit2/Shared/gtk/LayerTreeContextGtk.cpp (rev 0)
+++ trunk/Source/WebKit2/Shared/gtk/LayerTreeContextGtk.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "LayerTreeContext.h"
+
+#include "ArgumentDecoder.h"
+#include "ArgumentEncoder.h"
+
+namespace WebKit {
+
+LayerTreeContext::LayerTreeContext()
+ : windowHandle(0)
+{
+}
+
+LayerTreeContext::~LayerTreeContext()
+{
+}
+
+void LayerTreeContext::encode(CoreIPC::ArgumentEncoder* encoder) const
+{
+ encoder->encode(windowHandle);
+}
+
+bool LayerTreeContext::decode(CoreIPC::ArgumentDecoder* decoder, LayerTreeContext& context)
+{
+ return decoder->decode(context.windowHandle);
+}
+
+bool LayerTreeContext::isEmpty() const
+{
+ return !windowHandle;
+}
+
+bool operator==(const LayerTreeContext& a, const LayerTreeContext& b)
+{
+ return a.windowHandle == b.windowHandle;
+}
+
+} // namespace WebKit
+
Modified: trunk/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp (120261 => 120262)
--- trunk/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/UIProcess/API/gtk/WebKitWebViewBase.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -65,6 +65,10 @@
#include "WebFullScreenManagerProxy.h"
#endif
+#if USE(TEXTURE_MAPPER_GL) && defined(GDK_WINDOWING_X11)
+#include <gdk/gdkx.h>
+#endif
+
using namespace WebKit;
using namespace WebCore;
@@ -154,6 +158,9 @@
gint attributesMask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
GdkWindow* window = gdk_window_new(gtk_widget_get_parent_window(widget), &attributes, attributesMask);
+#if USE(TEXTURE_MAPPER_GL)
+ gdk_window_ensure_native(window);
+#endif
gtk_widget_set_window(widget, window);
gdk_window_set_user_data(window, widget);
@@ -339,6 +346,13 @@
GTK_WIDGET_CLASS(webkit_web_view_base_parent_class)->map(widget);
WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
+#if USE(TEXTURE_MAPPER_GL) && defined(GDK_WINDOWING_X11)
+ GdkWindow* gdkWindow = gtk_widget_get_window(widget);
+ ASSERT(gdkWindow);
+ if (gdk_window_has_native(gdkWindow))
+ webViewBase->priv->pageProxy->widgetMapped(GDK_WINDOW_XID(gdkWindow));
+#endif
+
if (!webViewBase->priv->needsResizeOnMap)
return;
Modified: trunk/Source/WebKit2/UIProcess/WebPageProxy.h (120261 => 120262)
--- trunk/Source/WebKit2/UIProcess/WebPageProxy.h 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/UIProcess/WebPageProxy.h 2012-06-14 00:13:48 UTC (rev 120262)
@@ -668,6 +668,10 @@
// WebPopupMenuProxy::Client
virtual NativeWebMouseEvent* currentlyProcessedMouseDownEvent();
+#if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
+ void widgetMapped(uint64_t nativeWindowId);
+#endif
+
private:
WebPageProxy(PageClient*, PassRefPtr<WebProcessProxy>, WebPageGroup*, uint64_t pageID);
Modified: trunk/Source/WebKit2/UIProcess/gtk/WebPageProxyGtk.cpp (120261 => 120262)
--- trunk/Source/WebKit2/UIProcess/gtk/WebPageProxyGtk.cpp 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/UIProcess/gtk/WebPageProxyGtk.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -31,6 +31,8 @@
#include "NotImplemented.h"
#include "PageClientImpl.h"
#include "WebKitWebViewBasePrivate.h"
+#include "WebPageMessages.h"
+#include "WebProcessProxy.h"
#include <gtk/gtkx.h>
namespace WebKit {
@@ -107,4 +109,11 @@
webkitWebViewBaseChildMoveResize(WEBKIT_WEB_VIEW_BASE(viewWidget()), plugin, frameRect);
}
+#if USE(TEXTURE_MAPPER_GL)
+void WebPageProxy::widgetMapped(uint64_t nativeWindowId)
+{
+ process()->send(Messages::WebPage::WidgetMapped(nativeWindowId), m_pageID);
+}
+#endif
+
} // namespace WebKit
Modified: trunk/Source/WebKit2/WebProcess/WebPage/LayerTreeHost.cpp (120261 => 120262)
--- trunk/Source/WebKit2/WebProcess/WebPage/LayerTreeHost.cpp 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/WebProcess/WebPage/LayerTreeHost.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -38,6 +38,10 @@
#include "qt/LayerTreeHostQt.h"
#endif
+#if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
+#include "LayerTreeHostGtk.h"
+#endif
+
using namespace WebCore;
namespace WebKit {
@@ -50,6 +54,8 @@
return LayerTreeHostCAWin::create(webPage);
#elif PLATFORM(QT)
return LayerTreeHostQt::create(webPage);
+#elif PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
+ return LayerTreeHostGtk::create(webPage);
#else
return 0;
#endif
Modified: trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h (120261 => 120262)
--- trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/WebProcess/WebPage/WebPage.h 2012-06-14 00:13:48 UTC (rev 120262)
@@ -432,7 +432,10 @@
#elif PLATFORM(GTK)
void updateAccessibilityTree();
+#if USE(TEXTURE_MAPPER_GL)
+ void widgetMapped(int64_t nativeWindowHandle);
#endif
+#endif
void setCompositionForTesting(const String& compositionString, uint64_t from, uint64_t length);
bool hasCompositionForTesting();
@@ -539,6 +542,10 @@
void setVisibilityState(int visibilityState, bool isInitialState);
#endif
+#if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
+ uint64_t nativeWindowHandle() { return m_nativeWindowHandle; }
+#endif
+
private:
WebPage(uint64_t pageID, const WebPageCreationParameters&);
@@ -753,7 +760,12 @@
RefPtr<WebCore::Node> m_gestureTargetNode;
#elif PLATFORM(GTK)
WebPageAccessibilityObject* m_accessibilityObject;
+
+#if USE(TEXTURE_MAPPER_GL)
+ // Our view's window in the UI process.
+ uint64_t m_nativeWindowHandle;
#endif
+#endif
WebCore::RunLoop::Timer<WebPage> m_setCanStartMediaTimer;
Modified: trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in (120261 => 120262)
--- trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/WebProcess/WebPage/WebPage.messages.in 2012-06-14 00:13:48 UTC (rev 120262)
@@ -273,4 +273,8 @@
#if ENABLE(PAGE_VISIBILITY_API)
SetVisibilityState(int visibilityState, bool isInitialState);
#endif
+
+#if PLATFORM(GTK) && USE(TEXTURE_MAPPER_GL)
+ WidgetMapped(int64_t id)
+#endif
}
Added: trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp (0 => 120262)
--- trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp (rev 0)
+++ trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -0,0 +1,399 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2012 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 INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "LayerTreeHostGtk.h"
+
+#include "DrawingAreaImpl.h"
+#include "TextureMapperGL.h"
+#include "WebPage.h"
+#include "WebProcess.h"
+#include <GL/gl.h>
+#include <WebCore/Frame.h>
+#include <WebCore/FrameView.h>
+#include <WebCore/GLContextGLX.h>
+#include <WebCore/Page.h>
+#include <WebCore/Settings.h>
+
+#include <gdk/gdk.h>
+#if defined(GDK_WINDOWING_X11)
+#define Region XRegion
+#define Font XFont
+#define Cursor XCursor
+#define Screen XScreen
+#include <gdk/gdkx.h>
+#endif
+
+using namespace WebCore;
+
+namespace WebKit {
+
+PassRefPtr<LayerTreeHostGtk> LayerTreeHostGtk::create(WebPage* webPage)
+{
+ RefPtr<LayerTreeHostGtk> host = adoptRef(new LayerTreeHostGtk(webPage));
+ host->initialize();
+ return host.release();
+}
+
+LayerTreeHostGtk::LayerTreeHostGtk(WebPage* webPage)
+ : LayerTreeHost(webPage)
+ , m_isValid(true)
+ , m_notifyAfterScheduledLayerFlush(false)
+ , m_layerFlushSchedulingEnabled(true)
+ , m_layerFlushTimerCallbackId(0)
+{
+}
+
+GLContext* LayerTreeHostGtk::glContext()
+{
+ if (m_context)
+ return m_context.get();
+
+ uint64_t windowHandle = m_webPage->nativeWindowHandle();
+ if (!windowHandle)
+ return 0;
+
+ m_context = GLContext::createContextForWindow(windowHandle, GLContext::sharingContext());
+ return m_context.get();
+}
+
+void LayerTreeHostGtk::initialize()
+{
+ m_rootLayer = GraphicsLayer::create(this);
+ m_rootLayer->setDrawsContent(false);
+ m_rootLayer->setSize(m_webPage->size());
+
+ // The non-composited contents are a child of the root layer.
+ m_nonCompositedContentLayer = GraphicsLayer::create(this);
+ m_nonCompositedContentLayer->setDrawsContent(true);
+ m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground() && !m_webPage->drawsTransparentBackground());
+ m_nonCompositedContentLayer->setSize(m_webPage->size());
+ if (m_webPage->corePage()->settings()->acceleratedDrawingEnabled())
+ m_nonCompositedContentLayer->setAcceleratesDrawing(true);
+
+#ifndef NDEBUG
+ m_rootLayer->setName("LayerTreeHost root layer");
+ m_nonCompositedContentLayer->setName("LayerTreeHost non-composited content");
+#endif
+
+ m_rootLayer->addChild(m_nonCompositedContentLayer.get());
+ m_nonCompositedContentLayer->setNeedsDisplay();
+
+ m_layerTreeContext.windowHandle = m_webPage->nativeWindowHandle();
+
+ GLContext* context = glContext();
+ if (!context) {
+ m_isValid = false;
+ return;
+ }
+
+ // The creation of the TextureMapper needs an active OpenGL context.
+ context->makeContextCurrent();
+ m_textureMapper = TextureMapperGL::create();
+ toTextureMapperLayer(m_rootLayer.get())->setTextureMapper(m_textureMapper.get());
+
+ if (m_webPage->hasPageOverlay())
+ createPageOverlayLayer();
+
+ scheduleLayerFlush();
+}
+
+LayerTreeHostGtk::~LayerTreeHostGtk()
+{
+ ASSERT(!m_isValid);
+ ASSERT(!m_rootLayer);
+ cancelPendingLayerFlush();
+}
+
+const LayerTreeContext& LayerTreeHostGtk::layerTreeContext()
+{
+ return m_layerTreeContext;
+}
+
+void LayerTreeHostGtk::setShouldNotifyAfterNextScheduledLayerFlush(bool notifyAfterScheduledLayerFlush)
+{
+ m_notifyAfterScheduledLayerFlush = notifyAfterScheduledLayerFlush;
+}
+
+void LayerTreeHostGtk::setRootCompositingLayer(GraphicsLayer* graphicsLayer)
+{
+ m_nonCompositedContentLayer->removeAllChildren();
+
+ // Add the accelerated layer tree hierarchy.
+ if (graphicsLayer)
+ m_nonCompositedContentLayer->addChild(graphicsLayer);
+
+ scheduleLayerFlush();
+}
+
+void LayerTreeHostGtk::invalidate()
+{
+ ASSERT(m_isValid);
+
+ cancelPendingLayerFlush();
+ m_rootLayer = nullptr;
+ m_nonCompositedContentLayer = nullptr;
+ m_pageOverlayLayer = nullptr;
+ m_textureMapper = nullptr;
+
+ m_context = nullptr;
+ m_isValid = false;
+}
+
+void LayerTreeHostGtk::setNonCompositedContentsNeedDisplay(const IntRect& rect)
+{
+ m_nonCompositedContentLayer->setNeedsDisplayInRect(rect);
+ if (m_pageOverlayLayer)
+ m_pageOverlayLayer->setNeedsDisplayInRect(rect);
+
+ scheduleLayerFlush();
+}
+
+void LayerTreeHostGtk::scrollNonCompositedContents(const IntRect& scrollRect, const IntSize& scrollOffset)
+{
+ setNonCompositedContentsNeedDisplay(scrollRect);
+}
+
+void LayerTreeHostGtk::sizeDidChange(const IntSize& newSize)
+{
+ if (m_rootLayer->size() == newSize)
+ return;
+ m_rootLayer->setSize(newSize);
+
+ // If the newSize exposes new areas of the non-composited content a setNeedsDisplay is needed
+ // for those newly exposed areas.
+ FloatSize oldSize = m_nonCompositedContentLayer->size();
+ m_nonCompositedContentLayer->setSize(newSize);
+
+ if (newSize.width() > oldSize.width()) {
+ float height = std::min(static_cast<float>(newSize.height()), oldSize.height());
+ m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(oldSize.width(), 0, newSize.width() - oldSize.width(), height));
+ }
+
+ if (newSize.height() > oldSize.height())
+ m_nonCompositedContentLayer->setNeedsDisplayInRect(FloatRect(0, oldSize.height(), newSize.width(), newSize.height() - oldSize.height()));
+ m_nonCompositedContentLayer->setNeedsDisplay();
+
+ if (m_pageOverlayLayer)
+ m_pageOverlayLayer->setSize(newSize);
+}
+
+void LayerTreeHostGtk::deviceScaleFactorDidChange()
+{
+ // Other layers learn of the scale factor change via WebPage::setDeviceScaleFactor.
+ m_nonCompositedContentLayer->deviceOrPageScaleFactorChanged();
+}
+
+void LayerTreeHostGtk::forceRepaint()
+{
+ scheduleLayerFlush();
+}
+
+void LayerTreeHostGtk::didInstallPageOverlay()
+{
+ createPageOverlayLayer();
+ scheduleLayerFlush();
+}
+
+void LayerTreeHostGtk::didUninstallPageOverlay()
+{
+ destroyPageOverlayLayer();
+ scheduleLayerFlush();
+}
+
+void LayerTreeHostGtk::setPageOverlayNeedsDisplay(const IntRect& rect)
+{
+ ASSERT(m_pageOverlayLayer);
+ m_pageOverlayLayer->setNeedsDisplayInRect(rect);
+ scheduleLayerFlush();
+}
+
+void LayerTreeHostGtk::notifyAnimationStarted(const WebCore::GraphicsLayer*, double time)
+{
+}
+
+void LayerTreeHostGtk::notifySyncRequired(const WebCore::GraphicsLayer*)
+{
+}
+
+void LayerTreeHostGtk::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const IntRect& clipRect)
+{
+ if (graphicsLayer == m_nonCompositedContentLayer) {
+ m_webPage->drawRect(graphicsContext, clipRect);
+ return;
+ }
+
+ if (graphicsLayer == m_pageOverlayLayer) {
+ m_webPage->drawPageOverlay(graphicsContext, clipRect);
+ return;
+ }
+}
+
+bool LayerTreeHostGtk::showDebugBorders(const GraphicsLayer*) const
+{
+ return m_webPage->corePage()->settings()->showDebugBorders();
+}
+
+bool LayerTreeHostGtk::showRepaintCounter(const GraphicsLayer*) const
+{
+ return m_webPage->corePage()->settings()->showRepaintCounter();
+}
+
+float LayerTreeHostGtk::deviceScaleFactor() const
+{
+ return m_webPage->corePage()->deviceScaleFactor();
+}
+
+gboolean LayerTreeHostGtk::layerFlushTimerFiredCallback(LayerTreeHostGtk* layerTreeHost)
+{
+ layerTreeHost->layerFlushTimerFired();
+ return FALSE;
+}
+
+void LayerTreeHostGtk::layerFlushTimerFired()
+{
+ ASSERT(m_layerFlushTimerCallbackId);
+ m_layerFlushTimerCallbackId = 0;
+
+ flushAndRenderLayers();
+
+ if (toTextureMapperLayer(m_rootLayer.get())->descendantsOrSelfHaveRunningAnimations() && !m_layerFlushTimerCallbackId)
+ m_layerFlushTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, 1000.0 / 60.0, reinterpret_cast<GSourceFunc>(layerFlushTimerFiredCallback), this, 0);
+}
+
+bool LayerTreeHostGtk::flushPendingLayerChanges()
+{
+ m_rootLayer->syncCompositingStateForThisLayerOnly();
+ m_nonCompositedContentLayer->syncCompositingStateForThisLayerOnly();
+ if (m_pageOverlayLayer)
+ m_pageOverlayLayer->syncCompositingStateForThisLayerOnly();
+
+ return m_webPage->corePage()->mainFrame()->view()->syncCompositingStateIncludingSubframes();
+}
+
+void LayerTreeHostGtk::compositeLayersToContext()
+{
+ GLContext* context = glContext();
+ if (!context || !context->makeContextCurrent())
+ return;
+
+ // The window size may be out of sync with the page size at this point, and getting
+ // the viewport parameters incorrect, means that the content will be misplaced. Thus
+ // we set the viewport parameters directly from the window size.
+ IntSize contextSize = m_context->defaultFrameBufferSize();
+ glViewport(0, 0, contextSize.width(), contextSize.height());
+
+ m_textureMapper->beginPainting();
+ toTextureMapperLayer(m_rootLayer.get())->paint();
+ m_textureMapper->endPainting();
+
+ context->swapBuffers();
+}
+
+void LayerTreeHostGtk::flushAndRenderLayers()
+{
+ {
+ RefPtr<LayerTreeHostGtk> protect(this);
+ m_webPage->layoutIfNeeded();
+
+ if (!m_isValid)
+ return;
+ }
+
+ GLContext* context = glContext();
+ if (!context || !context->makeContextCurrent())
+ return;
+
+ if (!flushPendingLayerChanges())
+ return;
+
+ // Our model is very simple. We always composite and render the tree immediately after updating it.
+ compositeLayersToContext();
+
+ if (m_notifyAfterScheduledLayerFlush) {
+ // Let the drawing area know that we've done a flush of the layer changes.
+ static_cast<DrawingAreaImpl*>(m_webPage->drawingArea())->layerHostDidFlushLayers();
+ m_notifyAfterScheduledLayerFlush = false;
+ }
+}
+
+void LayerTreeHostGtk::createPageOverlayLayer()
+{
+ ASSERT(!m_pageOverlayLayer);
+
+ m_pageOverlayLayer = GraphicsLayer::create(this);
+#ifndef NDEBUG
+ m_pageOverlayLayer->setName("LayerTreeHost page overlay content");
+#endif
+
+ m_pageOverlayLayer->setDrawsContent(true);
+ m_pageOverlayLayer->setSize(m_webPage->size());
+
+ m_rootLayer->addChild(m_pageOverlayLayer.get());
+}
+
+void LayerTreeHostGtk::destroyPageOverlayLayer()
+{
+ ASSERT(m_pageOverlayLayer);
+ m_pageOverlayLayer->removeFromParent();
+ m_pageOverlayLayer = nullptr;
+}
+
+void LayerTreeHostGtk::scheduleLayerFlush()
+{
+ if (!m_layerFlushSchedulingEnabled)
+ return;
+
+ // We use a GLib timer because otherwise GTK+ event handling during dragging can starve WebCore timers, which have a lower priority.
+ if (!m_layerFlushTimerCallbackId)
+ m_layerFlushTimerCallbackId = g_timeout_add_full(GDK_PRIORITY_EVENTS, 0, reinterpret_cast<GSourceFunc>(layerFlushTimerFiredCallback), this, 0);
+}
+
+void LayerTreeHostGtk::setLayerFlushSchedulingEnabled(bool layerFlushingEnabled)
+{
+ if (m_layerFlushSchedulingEnabled == layerFlushingEnabled)
+ return;
+
+ m_layerFlushSchedulingEnabled = layerFlushingEnabled;
+
+ if (m_layerFlushSchedulingEnabled) {
+ scheduleLayerFlush();
+ return;
+ }
+
+ cancelPendingLayerFlush();
+}
+
+void LayerTreeHostGtk::cancelPendingLayerFlush()
+{
+ if (!m_layerFlushTimerCallbackId)
+ return;
+
+ g_source_remove(m_layerFlushTimerCallbackId);
+ m_layerFlushTimerCallbackId = 0;
+}
+
+} // namespace WebKit
Property changes on: trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp
___________________________________________________________________
Added: svn:eol-style
Added: trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.h (0 => 120262)
--- trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.h (rev 0)
+++ trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.h 2012-06-14 00:13:48 UTC (rev 120262)
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2012 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 INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LayerTreeHostGtk_h
+#define LayerTreeHostGtk_h
+
+#include "LayerTreeContext.h"
+#include "LayerTreeHost.h"
+#include "TextureMapperLayer.h"
+#include <WebCore/GLContext.h>
+#include <WebCore/GraphicsLayerClient.h>
+#include <wtf/OwnPtr.h>
+
+namespace WebKit {
+
+class LayerTreeHostGtk : public LayerTreeHost, WebCore::GraphicsLayerClient {
+public:
+ static PassRefPtr<LayerTreeHostGtk> create(WebPage*);
+ virtual ~LayerTreeHostGtk();
+
+protected:
+ explicit LayerTreeHostGtk(WebPage*);
+
+ WebCore::GraphicsLayer* rootLayer() const { return m_rootLayer.get(); }
+
+ void initialize();
+
+ // LayerTreeHost.
+ virtual void invalidate();
+ virtual void sizeDidChange(const WebCore::IntSize& newSize);
+ virtual void deviceScaleFactorDidChange();
+ virtual void forceRepaint();
+ virtual void setRootCompositingLayer(WebCore::GraphicsLayer*);
+ virtual void scheduleLayerFlush();
+ virtual void setLayerFlushSchedulingEnabled(bool layerFlushingEnabled);
+
+private:
+ // LayerTreeHost.
+ virtual const LayerTreeContext& layerTreeContext();
+ virtual void setShouldNotifyAfterNextScheduledLayerFlush(bool);
+
+ virtual void setNonCompositedContentsNeedDisplay(const WebCore::IntRect&);
+ virtual void scrollNonCompositedContents(const WebCore::IntRect& scrollRect, const WebCore::IntSize& scrollOffset);
+
+ virtual void didInstallPageOverlay();
+ virtual void didUninstallPageOverlay();
+ virtual void setPageOverlayNeedsDisplay(const WebCore::IntRect&);
+
+ virtual bool flushPendingLayerChanges();
+
+ // GraphicsLayerClient
+ virtual void notifyAnimationStarted(const WebCore::GraphicsLayer*, double time);
+ virtual void notifySyncRequired(const WebCore::GraphicsLayer*);
+ virtual void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::IntRect& clipRect);
+ virtual bool showDebugBorders(const WebCore::GraphicsLayer*) const;
+ virtual bool showRepaintCounter(const WebCore::GraphicsLayer*) const;
+ virtual float deviceScaleFactor() const;
+ virtual void didCommitChangesForLayer(const WebCore::GraphicsLayer*) const { }
+
+ void createPageOverlayLayer();
+ void destroyPageOverlayLayer();
+ void compositeLayersToContext();
+ void flushAndRenderLayers();
+ void cancelPendingLayerFlush();
+
+ void layerFlushTimerFired();
+ static gboolean layerFlushTimerFiredCallback(LayerTreeHostGtk*);
+
+ WebCore::GLContext* glContext();
+
+ LayerTreeContext m_layerTreeContext;
+ bool m_isValid;
+ bool m_notifyAfterScheduledLayerFlush;
+ OwnPtr<WebCore::GraphicsLayer> m_rootLayer;
+ OwnPtr<WebCore::GraphicsLayer> m_nonCompositedContentLayer;
+ OwnPtr<WebCore::GraphicsLayer> m_pageOverlayLayer;
+ OwnPtr<WebCore::TextureMapper> m_textureMapper;
+ OwnPtr<WebCore::GLContext> m_context;
+ bool m_layerFlushSchedulingEnabled;
+ unsigned m_layerFlushTimerCallbackId;
+};
+
+} // namespace WebKit
+
+#endif // LayerTreeHostGtk_h
Property changes on: trunk/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.h
___________________________________________________________________
Added: svn:eol-style
Modified: trunk/Source/WebKit2/WebProcess/WebPage/gtk/WebPageGtk.cpp (120261 => 120262)
--- trunk/Source/WebKit2/WebProcess/WebPage/gtk/WebPageGtk.cpp 2012-06-14 00:04:59 UTC (rev 120261)
+++ trunk/Source/WebKit2/WebProcess/WebPage/gtk/WebPageGtk.cpp 2012-06-14 00:13:48 UTC (rev 120262)
@@ -54,6 +54,8 @@
m_accessibilityObject = webPageAccessibilityObjectNew(this);
GOwnPtr<gchar> plugID(atk_plug_get_id(ATK_PLUG(m_accessibilityObject)));
send(Messages::WebPageProxy::BindAccessibilityTree(String(plugID.get())));
+
+ m_nativeWindowHandle = 0;
}
void WebPage::updateAccessibilityTree()
@@ -150,4 +152,12 @@
return 0;
}
+#if USE(TEXTURE_MAPPER_GL)
+void WebPage::widgetMapped(int64_t nativeWindowHandle)
+{
+ m_nativeWindowHandle = nativeWindowHandle;
+}
+
+#endif
+
} // namespace WebKit
