Imported WebKit commit 7e538425aa020340619e927792f3d895061fb54b (http://svn.webkit.org/repository/webkit/trunk@116286)

1 files changed, 141 insertions, 27 deletions

diff --git a/Source/WebKit2/WebProcess/WebPage/qt/LayerTreeHostQt.cpp b/Source/WebKit2/WebProcess/WebPage/qt/LayerTreeHostQt.cpp
index 213743003..964366e8d 100644
--- a/Source/WebKit2/WebProcess/WebPage/qt/LayerTreeHostQt.cpp
+++ b/Source/WebKit2/WebProcess/WebPage/qt/LayerTreeHostQt.cpp
@@ -32,11 +32,17 @@
 #include "GraphicsContext.h"
 #include "LayerTreeHostProxyMessages.h"
 #include "MessageID.h"
+#include "SurfaceUpdateInfo.h"
+#include "WebCoreArgumentCoders.h"
 #include "WebGraphicsLayer.h"
 #include "WebPage.h"
 #include <WebCore/Frame.h>
 #include <WebCore/FrameView.h>
 #include <WebCore/Page.h>
+#include <WebCore/RenderLayer.h>
+#include <WebCore/RenderLayerBacking.h>
+#include <WebCore/RenderLayerCompositor.h>
+#include <WebCore/RenderView.h>
 #include <WebCore/Settings.h>
 
 using namespace WebCore;
@@ -63,11 +69,10 @@ LayerTreeHostQt::LayerTreeHostQt(WebPage* webPage)
     : LayerTreeHost(webPage)
     , m_notifyAfterScheduledLayerFlush(false)
     , m_isValid(true)
-#if USE(TILED_BACKING_STORE)
     , m_waitingForUIProcess(false)
     , m_isSuspended(false)
     , m_contentsScale(1)
-#endif
+    , m_shouldSendScrollPositionUpdate(true)
     , m_shouldSyncFrame(false)
     , m_shouldSyncRootLayer(true)
     , m_layerFlushTimer(this, &LayerTreeHostQt::layerFlushTimerFired)
@@ -85,9 +90,7 @@ LayerTreeHostQt::LayerTreeHostQt(WebPage* webPage)
     m_layerTreeContext.webLayerID = toWebGraphicsLayer(webRootLayer)->id();
 
     m_nonCompositedContentLayer = GraphicsLayer::create(this);
-#if USE(TILED_BACKING_STORE)
     toWebGraphicsLayer(m_rootLayer.get())->setWebGraphicsLayerClient(this);
-#endif
 #ifndef NDEBUG
     m_nonCompositedContentLayer->setName("LayerTreeHostQt non-composited content");
 #endif
@@ -176,6 +179,9 @@ void LayerTreeHostQt::forceRepaint()
 
 void LayerTreeHostQt::sizeDidChange(const WebCore::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
@@ -216,6 +222,13 @@ void LayerTreeHostQt::setPageOverlayNeedsDisplay(const WebCore::IntRect& rect)
     scheduleLayerFlush();
 }
 
+void LayerTreeHostQt::setPageOverlayOpacity(float value)
+{
+    ASSERT(m_pageOverlayLayer);
+    m_pageOverlayLayer->setOpacity(value);
+    scheduleLayerFlush();
+}
+
 bool LayerTreeHostQt::flushPendingLayerChanges()
 {
     bool didSync = m_webPage->corePage()->mainFrame()->view()->syncCompositingStateIncludingSubframes();
@@ -227,12 +240,30 @@ bool LayerTreeHostQt::flushPendingLayerChanges()
     return didSync;
 }
 
-void LayerTreeHostQt::didSyncCompositingStateForLayer(const WebLayerInfo& info)
+void LayerTreeHostQt::syncLayerState(WebLayerID id, const WebLayerInfo& info)
+{
+    if (m_shouldSendScrollPositionUpdate) {
+        m_webPage->send(Messages::LayerTreeHostProxy::DidChangeScrollPosition(m_visibleContentsRect.location()));
+        m_shouldSendScrollPositionUpdate = false;
+    }
+    m_shouldSyncFrame = true;
+    m_webPage->send(Messages::LayerTreeHostProxy::SetCompositingLayerState(id, info));
+}
+
+void LayerTreeHostQt::syncLayerChildren(WebLayerID id, const Vector<WebLayerID>& children)
 {
     m_shouldSyncFrame = true;
-    m_webPage->send(Messages::LayerTreeHostProxy::SyncCompositingLayerState(info));
+    m_webPage->send(Messages::LayerTreeHostProxy::SetCompositingLayerChildren(id, children));
 }
 
+#if ENABLE(CSS_FILTERS)
+void LayerTreeHostQt::syncLayerFilters(WebLayerID id, const FilterOperations& filters)
+{
+    m_shouldSyncFrame = true;
+    m_webPage->send(Messages::LayerTreeHostProxy::SetCompositingLayerFilters(id, filters));
+}
+#endif
+
 void LayerTreeHostQt::attachLayer(WebGraphicsLayer* layer)
 {
     ASSERT(!m_registeredLayers.contains(layer));
@@ -249,12 +280,58 @@ void LayerTreeHostQt::detachLayer(WebGraphicsLayer* layer)
     m_webPage->send(Messages::LayerTreeHostProxy::DeleteCompositingLayer(layer->id()));
 }
 
+static void updateOffsetFromViewportForSelf(RenderLayer* renderLayer)
+{
+    // These conditions must match the conditions in RenderLayerCompositor::requiresCompositingForPosition.
+    RenderLayerBacking* backing = renderLayer->backing();
+    if (!backing)
+        return;
+
+    RenderStyle* style = renderLayer->renderer()->style();
+    if (!style)
+        return;
+
+    if (!renderLayer->renderer()->isPositioned() || renderLayer->renderer()->style()->position() != FixedPosition)
+        return;
+
+    if (!renderLayer->renderer()->container()->isRenderView())
+        return;
+
+    if (!renderLayer->isStackingContext())
+        return;
+
+    WebGraphicsLayer* graphicsLayer = toWebGraphicsLayer(backing->graphicsLayer());
+    graphicsLayer->setFixedToViewport(true);
+}
+
+static void updateOffsetFromViewportForLayer(RenderLayer* renderLayer)
+{
+    updateOffsetFromViewportForSelf(renderLayer);
+
+    if (renderLayer->firstChild())
+        updateOffsetFromViewportForLayer(renderLayer->firstChild());
+    if (renderLayer->nextSibling())
+        updateOffsetFromViewportForLayer(renderLayer->nextSibling());
+}
+
+void LayerTreeHostQt::syncFixedLayers()
+{
+    if (!m_webPage->corePage()->settings() || !m_webPage->corePage()->settings()->acceleratedCompositingForFixedPositionEnabled())
+        return;
+
+    if (!m_webPage->mainFrame()->view()->hasFixedObjects())
+        return;
+
+    RenderLayer* rootRenderLayer = m_webPage->mainFrame()->contentRenderer()->compositor()->rootRenderLayer();
+    ASSERT(rootRenderLayer);
+    if (rootRenderLayer->firstChild())
+        updateOffsetFromViewportForLayer(rootRenderLayer->firstChild());
+}
+
 void LayerTreeHostQt::performScheduledLayerFlush()
 {
-#if USE(TILED_BACKING_STORE)
     if (m_isSuspended || m_waitingForUIProcess)
         return;
-#endif
 
     m_webPage->layoutIfNeeded();
 
@@ -326,7 +403,7 @@ int64_t LayerTreeHostQt::adoptImageBackingStore(Image* image)
         return key;
     }
 
-    RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(image->size(), image->currentFrameHasAlpha() ? ShareableBitmap::SupportsAlpha : 0);
+    RefPtr<ShareableBitmap> bitmap = ShareableBitmap::createShareable(image->size(), (image->currentFrameHasAlpha() ? ShareableBitmap::SupportsAlpha : 0));
     {
         OwnPtr<WebCore::GraphicsContext> graphicsContext = bitmap->createGraphicsContext();
         graphicsContext->drawImage(image, ColorSpaceDeviceRGB, IntPoint::zero());
@@ -395,18 +472,21 @@ bool LayerTreeHost::supportsAcceleratedCompositing()
     return true;
 }
 
-void LayerTreeHostQt::createTile(WebLayerID layerID, int tileID, const UpdateInfo& updateInfo)
+void LayerTreeHostQt::createTile(WebLayerID layerID, int tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& targetRect)
 {
-    m_webPage->send(Messages::LayerTreeHostProxy::CreateTileForLayer(layerID, tileID, updateInfo));
+    m_shouldSyncFrame = true;
+    m_webPage->send(Messages::LayerTreeHostProxy::CreateTileForLayer(layerID, tileID, targetRect, updateInfo));
 }
 
-void LayerTreeHostQt::updateTile(WebLayerID layerID, int tileID, const UpdateInfo& updateInfo)
+void LayerTreeHostQt::updateTile(WebLayerID layerID, int tileID, const SurfaceUpdateInfo& updateInfo, const WebCore::IntRect& targetRect)
 {
-    m_webPage->send(Messages::LayerTreeHostProxy::UpdateTileForLayer(layerID, tileID, updateInfo));
+    m_shouldSyncFrame = true;
+    m_webPage->send(Messages::LayerTreeHostProxy::UpdateTileForLayer(layerID, tileID, targetRect, updateInfo));
 }
 
 void LayerTreeHostQt::removeTile(WebLayerID layerID, int tileID)
 {
+    m_shouldSyncFrame = true;
     m_webPage->send(Messages::LayerTreeHostProxy::RemoveTileForLayer(layerID, tileID));
 }
 
@@ -415,32 +495,40 @@ WebCore::IntRect LayerTreeHostQt::visibleContentsRect() const
     return m_visibleContentsRect;
 }
 
-void LayerTreeHostQt::setVisibleContentsRectForScaling(const IntRect& rect, float scale)
+void LayerTreeHostQt::setVisibleContentsRect(const IntRect& rect, float scale, const FloatPoint& trajectoryVector)
 {
-    m_visibleContentsRect = rect;
-    m_contentsScale = scale;
+    bool contentsRectDidChange = rect != m_visibleContentsRect;
+    bool contentsScaleDidChange = scale != m_contentsScale;
 
-    HashSet<WebCore::WebGraphicsLayer*>::iterator end = m_registeredLayers.end();
-    for (HashSet<WebCore::WebGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
-        (*it)->setContentsScale(scale);
-        (*it)->adjustVisibleRect();
-    }
-    scheduleLayerFlush();
-}
+    if (trajectoryVector != FloatPoint::zero())
+        toWebGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
 
-void LayerTreeHostQt::setVisibleContentsRectForPanning(const IntRect& rect, const FloatPoint& trajectoryVector)
-{
-    m_visibleContentsRect = rect;
+    if (contentsRectDidChange || contentsScaleDidChange) {
+        m_visibleContentsRect = rect;
+        m_contentsScale = scale;
 
-    toWebGraphicsLayer(m_nonCompositedContentLayer.get())->setVisibleContentRectTrajectoryVector(trajectoryVector);
+        HashSet<WebCore::WebGraphicsLayer*>::iterator end = m_registeredLayers.end();
+        for (HashSet<WebCore::WebGraphicsLayer*>::iterator it = m_registeredLayers.begin(); it != end; ++it) {
+            if (contentsScaleDidChange)
+                (*it)->setContentsScale(scale);
+            if (contentsRectDidChange)
+                (*it)->adjustVisibleRect();
+        }
+    }
 
     scheduleLayerFlush();
+    if (m_webPage->useFixedLayout())
+        m_webPage->setFixedVisibleContentRect(rect);
+    if (contentsRectDidChange)
+        m_shouldSendScrollPositionUpdate = true;
 }
 
 void LayerTreeHostQt::renderNextFrame()
 {
     m_waitingForUIProcess = false;
     scheduleLayerFlush();
+    for (int i = 0; i < m_updateAtlases.size(); ++i)
+        m_updateAtlases[i].didSwapBuffers();
 }
 
 bool LayerTreeHostQt::layerTreeTileUpdatesAllowed() const
@@ -455,6 +543,32 @@ void LayerTreeHostQt::purgeBackingStores()
         (*it)->purgeBackingStores();
 
     ASSERT(!m_directlyCompositedImageRefCounts.size());
+    m_updateAtlases.clear();
+}
+
+UpdateAtlas& LayerTreeHostQt::getAtlas(ShareableBitmap::Flags flags)
+{
+    for (int i = 0; i < m_updateAtlases.size(); ++i) {
+        if (m_updateAtlases[i].flags() == flags)
+            return m_updateAtlases[i];
+    }
+    static const int ScratchBufferDimension = 2000;
+    m_updateAtlases.append(UpdateAtlas(ScratchBufferDimension, flags));
+    return m_updateAtlases.last();
+}
+
+PassOwnPtr<WebCore::GraphicsContext> LayerTreeHostQt::beginContentUpdate(const WebCore::IntSize& size, ShareableBitmap::Flags flags, ShareableSurface::Handle& handle, WebCore::IntPoint& offset)
+{
+    UpdateAtlas& atlas = getAtlas(flags);
+    if (!atlas.surface()->createHandle(handle))
+        return PassOwnPtr<WebCore::GraphicsContext>();
+
+    // This will return null if there is no available buffer.
+    OwnPtr<WebCore::GraphicsContext> graphicsContext = atlas.beginPaintingOnAvailableBuffer(size, offset);
+    if (!graphicsContext)
+        return PassOwnPtr<WebCore::GraphicsContext>();
+
+    return graphicsContext.release();
 }
 
 } // namespace WebKit