Title: [198271] releases/WebKitGTK/webkit-2.12/Source
Revision
198271
Author
[email protected]
Date
2016-03-16 08:13:20 -0700 (Wed, 16 Mar 2016)

Log Message

Merge r198266 - Unreviewed, rolling out r196803.
https://bugs.webkit.org/show_bug.cgi?id=155534

Introduced several rendering issues in popular websites
(Requested by KaL on #webkit).

Reverted changeset:

"[GTK] Limit the number of tiles according to the visible
area"
https://bugs.webkit.org/show_bug.cgi?id=126122
http://trac.webkit.org/changeset/196803

Modified Paths

Diff

Modified: releases/WebKitGTK/webkit-2.12/Source/WebCore/ChangeLog (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebCore/ChangeLog	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebCore/ChangeLog	2016-03-16 15:13:20 UTC (rev 198271)
@@ -1,3 +1,18 @@
+2016-03-16  Commit Queue  <[email protected]>
+
+        Unreviewed, rolling out r196803.
+        https://bugs.webkit.org/show_bug.cgi?id=155534
+
+        Introduced several rendering issues in popular websites
+        (Requested by KaL on #webkit).
+
+        Reverted changeset:
+
+        "[GTK] Limit the number of tiles according to the visible
+        area"
+        https://bugs.webkit.org/show_bug.cgi?id=126122
+        http://trac.webkit.org/changeset/196803
+
 2016-03-15  Carlos Garcia Campos  <[email protected]>
 
         REGRESSION (r197724): [GTK] Web Inspector: Images being blocked by CSP 2.0

Modified: releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp	2016-03-16 15:13:20 UTC (rev 198271)
@@ -48,8 +48,6 @@
     , m_contentsLayer(0)
     , m_animationStartTime(0)
     , m_isScrollable(false)
-    , m_isNonCompositingLayer(false)
-    , m_isVisibleRectDirty(true)
 {
 }
 
@@ -169,7 +167,6 @@
         return;
     GraphicsLayer::setPosition(value);
     notifyChange(PositionChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setAnchorPoint(const FloatPoint3D& value)
@@ -178,7 +175,6 @@
         return;
     GraphicsLayer::setAnchorPoint(value);
     notifyChange(AnchorPointChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setSize(const FloatSize& value)
@@ -190,7 +186,6 @@
     if (maskLayer())
         maskLayer()->setSize(value);
     notifyChange(SizeChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setTransform(const TransformationMatrix& value)
@@ -200,7 +195,6 @@
 
     GraphicsLayer::setTransform(value);
     notifyChange(TransformChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setChildrenTransform(const TransformationMatrix& value)
@@ -209,7 +203,6 @@
         return;
     GraphicsLayer::setChildrenTransform(value);
     notifyChange(ChildrenTransformChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setPreserves3D(bool value)
@@ -218,7 +211,6 @@
         return;
     GraphicsLayer::setPreserves3D(value);
     notifyChange(Preserves3DChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setMasksToBounds(bool value)
@@ -227,7 +219,6 @@
         return;
     GraphicsLayer::setMasksToBounds(value);
     notifyChange(MasksToBoundsChange);
-    markVisibleRectAsDirty();
 }
 
 void GraphicsLayerTextureMapper::setDrawsContent(bool value)
@@ -310,7 +301,6 @@
             m_compositedImage = TextureMapperTiledBackingStore::create();
         m_compositedImage->setContentsToImage(image);
         m_compositedImage->updateContentsScale(pageScaleFactor() * deviceScaleFactor());
-        m_compositedImage->updateContentsSize(image->size());
     } else {
         m_compositedNativeImagePtr = nullptr;
         m_compositedImage = nullptr;
@@ -379,8 +369,6 @@
     prepareBackingStoreIfNeeded();
     commitLayerChanges();
     m_layer.syncAnimations();
-    if (!m_isNonCompositingLayer)
-        computeTransformedVisibleRect();
 }
 
 void GraphicsLayerTextureMapper::prepareBackingStoreIfNeeded()
@@ -524,22 +512,22 @@
         child->flushCompositingState(rect, viewportIsStable);
 }
 
-void GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers(const FloatRect& visibleContentRect)
+void GraphicsLayerTextureMapper::updateBackingStoreIncludingSubLayers()
 {
     if (!m_layer.textureMapper())
         return;
 
-    updateBackingStoreIfNeeded(visibleContentRect);
+    updateBackingStoreIfNeeded();
 
     if (maskLayer())
-        downcast<GraphicsLayerTextureMapper>(*maskLayer()).updateBackingStoreIfNeeded(visibleContentRect);
+        downcast<GraphicsLayerTextureMapper>(*maskLayer()).updateBackingStoreIfNeeded();
     if (replicaLayer())
-        downcast<GraphicsLayerTextureMapper>(*replicaLayer()).updateBackingStoreIfNeeded(visibleContentRect);
+        downcast<GraphicsLayerTextureMapper>(*replicaLayer()).updateBackingStoreIfNeeded();
     for (auto* child : children())
-        downcast<GraphicsLayerTextureMapper>(*child).updateBackingStoreIncludingSubLayers(visibleContentRect);
+        downcast<GraphicsLayerTextureMapper>(*child).updateBackingStoreIncludingSubLayers();
 }
 
-void GraphicsLayerTextureMapper::updateBackingStoreIfNeeded(const FloatRect& visibleContentRect)
+void GraphicsLayerTextureMapper::updateBackingStoreIfNeeded()
 {
     TextureMapper* textureMapper = m_layer.textureMapper();
     if (!textureMapper)
@@ -559,10 +547,9 @@
 
     TextureMapperTiledBackingStore* backingStore = static_cast<TextureMapperTiledBackingStore*>(m_backingStore.get());
     backingStore->updateContentsScale(pageScaleFactor() * deviceScaleFactor());
-    backingStore->updateContentsSize(m_size);
 
     dirtyRect.scale(pageScaleFactor() * deviceScaleFactor());
-    backingStore->updateContents(*textureMapper, this, transformedVisibleRect(visibleContentRect), dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
+    backingStore->updateContents(*textureMapper, this, m_size, dirtyRect, BitmapTexture::UpdateCanModifyOriginalImageData);
 
     m_needsDisplay = false;
     m_needsDisplayRect = IntRect();
@@ -639,81 +626,5 @@
     notifyChange(RepaintCountChange);
 }
 
-void GraphicsLayerTextureMapper::markVisibleRectAsDirty()
-{
-    m_isVisibleRectDirty = true;
-
-    if (maskLayer())
-        downcast<GraphicsLayerTextureMapper>(*maskLayer()).markVisibleRectAsDirty();
-    if (replicaLayer())
-        downcast<GraphicsLayerTextureMapper>(*replicaLayer()).markVisibleRectAsDirty();
-    for (auto* child : children())
-        downcast<GraphicsLayerTextureMapper>(*child).markVisibleRectAsDirty();
 }
-
-bool GraphicsLayerTextureMapper::selfOrAncestorHasActiveTransformAnimation() const
-{
-    if (m_animations.hasActiveAnimationsOfType(AnimatedPropertyTransform))
-        return true;
-
-    if (!parent())
-        return false;
-
-    return downcast<GraphicsLayerTextureMapper>(*parent()).selfOrAncestorHasActiveTransformAnimation();
-}
-
-void GraphicsLayerTextureMapper::computeTransformedVisibleRect()
-{
-    if (!m_isVisibleRectDirty && !selfOrAncestorHasActiveTransformAnimation())
-        return;
-
-    m_isVisibleRectDirty = false;
-    TransformationMatrix currentTransform = transform();
-    if (selfOrAncestorHasActiveTransformAnimation())
-        client().getCurrentTransform(this, currentTransform);
-    m_layerTransform.setLocalTransform(currentTransform);
-
-    m_layerTransform.setAnchorPoint(m_anchorPoint);
-    m_layerTransform.setPosition(m_position);
-    m_layerTransform.setSize(m_size);
-
-    m_layerTransform.setFlattening(!preserves3D());
-    m_layerTransform.setChildrenTransform(childrenTransform());
-    m_layerTransform.combineTransforms(parent() ? downcast<GraphicsLayerTextureMapper>(*parent()).m_layerTransform.combinedForChildren() : TransformationMatrix());
-
-    m_cachedInverseTransform = m_layerTransform.combined().inverse().valueOr(TransformationMatrix());
-}
-
-static void clampToContentsRectIfRectIsInfinite(FloatRect& rect, const FloatSize& contentsSize)
-{
-    if (rect.width() >= LayoutUnit::nearlyMax() || rect.width() <= LayoutUnit::nearlyMin()) {
-        rect.setX(0);
-        rect.setWidth(contentsSize.width());
-    }
-
-    if (rect.height() >= LayoutUnit::nearlyMax() || rect.height() <= LayoutUnit::nearlyMin()) {
-        rect.setY(0);
-        rect.setHeight(contentsSize.height());
-    }
-}
-
-FloatRect GraphicsLayerTextureMapper::transformedVisibleRect(const FloatRect& visibleContentRect)
-{
-    if (m_isNonCompositingLayer)
-        return FloatRect(FloatPoint::zero(), m_size);
-
-    // Non-invertible layers are not visible.
-    if (!m_layerTransform.combined().isInvertible())
-        return IntRect();
-
-    // Return a projection of the visible rect (surface coordinates) onto the layer's plane (layer coordinates).
-    // The resulting quad might be squewed and the visible rect is the bounding box of this quad,
-    // so it might spread further than the real visible area (and then even more amplified by the cover rect multiplier).
-    ASSERT(m_cachedInverseTransform == m_layerTransform.combined().inverse().valueOr(TransformationMatrix()));
-    FloatRect rect = m_cachedInverseTransform.clampedBoundsOfProjectedQuad(FloatQuad(visibleContentRect));
-    clampToContentsRectIfRectIsInfinite(rect, size());
-    return rect;
-}
-
-}
 #endif

Modified: releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h	2016-03-16 15:13:20 UTC (rev 198271)
@@ -86,7 +86,7 @@
     virtual void flushCompositingState(const FloatRect&, bool) override;
     virtual void flushCompositingStateForThisLayerOnly(bool) override;
 
-    void updateBackingStoreIncludingSubLayers(const FloatRect&);
+    void updateBackingStoreIncludingSubLayers();
 
     TextureMapperLayer& layer() { return m_layer; }
 
@@ -102,7 +102,6 @@
     void setRepaintCount(int);
 
     void setAnimations(const TextureMapperAnimations&);
-    void setAsNonCompositingLayer() { m_isNonCompositingLayer = true; }
 
 private:
     // GraphicsLayer
@@ -114,15 +113,10 @@
 
     void commitLayerChanges();
     void updateDebugBorderAndRepaintCount();
-    void updateBackingStoreIfNeeded(const FloatRect&);
+    void updateBackingStoreIfNeeded();
     void prepareBackingStoreIfNeeded();
     bool shouldHaveBackingStore() const;
 
-    bool selfOrAncestorHasActiveTransformAnimation() const;
-    void computeTransformedVisibleRect();
-    void markVisibleRectAsDirty();
-    FloatRect transformedVisibleRect(const FloatRect&);
-
     // This set of flags help us defer which properties of the layer have been
     // modified by the compositor, so we can know what to look for in the next flush.
     enum ChangeMask {
@@ -188,11 +182,6 @@
 
     IntSize m_committedScrollOffset;
     bool m_isScrollable;
-
-    bool m_isNonCompositingLayer;
-    bool m_isVisibleRectDirty;
-    GraphicsLayerTransform m_layerTransform;
-    TransformationMatrix m_cachedInverseTransform;
 };
 
 } // namespace WebCore

Modified: releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.cpp	2016-03-16 15:13:20 UTC (rev 198271)
@@ -35,7 +35,7 @@
     if (!m_image)
         return;
 
-    updateContents(textureMapper, m_image.get(), m_image->rect(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);
+    updateContents(textureMapper, m_image.get(), m_image->size(), enclosingIntRect(m_image->rect()), BitmapTexture::UpdateCannotModifyOriginalImageData);
 
     if (m_image->imageObserver())
         m_image->imageObserver()->didDraw(m_image.get());
@@ -44,23 +44,15 @@
 
 TransformationMatrix TextureMapperTiledBackingStore::adjustedTransformForRect(const FloatRect& targetRect)
 {
-    FloatRect scaledContentsRect(FloatPoint::zero(), m_contentsSize);
-    scaledContentsRect.scale(m_contentsScale);
-    return TransformationMatrix::rectToRect(scaledContentsRect, targetRect);
+    return TransformationMatrix::rectToRect(rect(), targetRect);
 }
 
 void TextureMapperTiledBackingStore::paintToTextureMapper(TextureMapper& textureMapper, const FloatRect& targetRect, const TransformationMatrix& transform, float opacity)
 {
-    FloatRect scaledTargetRect(targetRect);
-    if (m_image)
-        scaledTargetRect.scale(m_contentsScale);
-
     updateContentsFromImageIfNeeded(textureMapper);
-    TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(scaledTargetRect);
-    FloatRect scaledContentsRect(FloatPoint::zero(), m_contentsSize);
-    scaledContentsRect.scale(m_contentsScale);
+    TransformationMatrix adjustedTransform = transform * adjustedTransformForRect(targetRect);
     for (auto& tile : m_tiles)
-        tile.paint(textureMapper, adjustedTransform, opacity, calculateExposedTileEdges(scaledContentsRect, tile.rect()));
+        tile.paint(textureMapper, adjustedTransform, opacity, calculateExposedTileEdges(rect(), tile.rect()));
 }
 
 void TextureMapperTiledBackingStore::drawBorder(TextureMapper& textureMapper, const Color& borderColor, float borderWidth, const FloatRect& targetRect, const TransformationMatrix& transform)
@@ -86,50 +78,29 @@
     m_contentsScale = scale;
 }
 
-void TextureMapperTiledBackingStore::updateContentsSize(const FloatSize& size)
+void TextureMapperTiledBackingStore::createOrDestroyTilesIfNeeded(const FloatSize& size, const IntSize& tileSize, bool hasAlpha)
 {
-    if (m_contentsSize == size)
+    if (size == m_size && !m_isScaleDirty)
         return;
 
-    m_isSizeDirty = true;
-    m_contentsSize = size;
-}
-
-void TextureMapperTiledBackingStore::createOrDestroyTilesIfNeeded(const FloatRect& visibleRect, const IntSize& tileSize, bool hasAlpha)
-{
-    if (visibleRect == m_visibleRect && !m_isScaleDirty && !m_isSizeDirty)
-        return;
-
-    m_visibleRect = visibleRect;
+    m_size = size;
     m_isScaleDirty = false;
-    m_isSizeDirty = false;
 
-    FloatRect scaledContentsRect(FloatRect(FloatPoint::zero(), m_contentsSize));
-    FloatRect scaledVisibleRect(m_visibleRect);
+    FloatSize scaledSize(m_size);
+    if (!m_image)
+        scaledSize.scale(m_contentsScale);
 
-    static const float coverRectMultiplier = 1.2;
-    FloatPoint delta(scaledVisibleRect.center());
-    delta.scale(1 - coverRectMultiplier, 1 - coverRectMultiplier);
-
-    scaledVisibleRect.scale(coverRectMultiplier);
-    scaledVisibleRect.moveBy(delta);
-    if (!m_image) {
-        scaledContentsRect.scale(m_contentsScale);
-        scaledVisibleRect.scale(m_contentsScale);
-    }
-
     Vector<FloatRect> tileRectsToAdd;
     Vector<int> tileIndicesToRemove;
     static const size_t TileEraseThreshold = 6;
 
     // This method recycles tiles. We check which tiles we need to add, which to remove, and use as many
     // removable tiles as replacement for new tiles when possible.
-    for (float y = 0; y < scaledContentsRect.height(); y += tileSize.height()) {
-        for (float x = 0; x < scaledContentsRect.width(); x += tileSize.width()) {
+    for (float y = 0; y < scaledSize.height(); y += tileSize.height()) {
+        for (float x = 0; x < scaledSize.width(); x += tileSize.width()) {
             FloatRect tileRect(x, y, tileSize.width(), tileSize.height());
-            tileRect.intersect(scaledContentsRect);
-            if (tileRect.intersects(scaledVisibleRect))
-                tileRectsToAdd.append(tileRect);
+            tileRect.intersect(rect());
+            tileRectsToAdd.append(tileRect);
         }
     }
 
@@ -179,16 +150,16 @@
     }
 }
 
-void TextureMapperTiledBackingStore::updateContents(TextureMapper& textureMapper, Image* image, const FloatRect& visibleRect, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
+void TextureMapperTiledBackingStore::updateContents(TextureMapper& textureMapper, Image* image, const FloatSize& totalSize, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
 {
-    createOrDestroyTilesIfNeeded(visibleRect, textureMapper.maxTextureSize(), !image->currentFrameKnownToBeOpaque());
+    createOrDestroyTilesIfNeeded(totalSize, textureMapper.maxTextureSize(), !image->currentFrameKnownToBeOpaque());
     for (auto& tile : m_tiles)
         tile.updateContents(textureMapper, image, dirtyRect, updateContentsFlag);
 }
 
-void TextureMapperTiledBackingStore::updateContents(TextureMapper& textureMapper, GraphicsLayer* sourceLayer, const FloatRect& visibleRect, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
+void TextureMapperTiledBackingStore::updateContents(TextureMapper& textureMapper, GraphicsLayer* sourceLayer, const FloatSize& totalSize, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag updateContentsFlag)
 {
-    createOrDestroyTilesIfNeeded(visibleRect, textureMapper.maxTextureSize(), true);
+    createOrDestroyTilesIfNeeded(totalSize, textureMapper.maxTextureSize(), true);
     for (auto& tile : m_tiles)
         tile.updateContents(textureMapper, sourceLayer, dirtyRect, updateContentsFlag, m_contentsScale);
 }

Modified: releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebCore/platform/graphics/texmap/TextureMapperTiledBackingStore.h	2016-03-16 15:13:20 UTC (rev 198271)
@@ -43,28 +43,29 @@
     virtual void drawRepaintCounter(TextureMapper&, int repaintCount, const Color&, const FloatRect&, const TransformationMatrix&) override;
 
     void updateContentsScale(float);
-    void updateContentsSize(const FloatSize&);
+    void updateContents(TextureMapper&, Image*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);
+    void updateContents(TextureMapper&, GraphicsLayer*, const FloatSize&, const IntRect&, BitmapTexture::UpdateContentsFlag);
 
-    void updateContents(TextureMapper&, Image*, const FloatRect& visibleRect, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag);
-    void updateContents(TextureMapper&, GraphicsLayer*, const FloatRect& visibleRect, const IntRect& dirtyRect, BitmapTexture::UpdateContentsFlag);
-
     void setContentsToImage(Image* image) { m_image = image; }
 
 private:
     TextureMapperTiledBackingStore() { }
 
-    void createOrDestroyTilesIfNeeded(const FloatRect& visibleRect, const IntSize& tileSize, bool hasAlpha);
+    void createOrDestroyTilesIfNeeded(const FloatSize& backingStoreSize, const IntSize& tileSize, bool hasAlpha);
     void updateContentsFromImageIfNeeded(TextureMapper&);
     TransformationMatrix adjustedTransformForRect(const FloatRect&);
+    inline FloatRect rect() const
+    {
+        FloatRect rect(FloatPoint::zero(), m_size);
+        rect.scale(m_contentsScale);
+        return rect;
+    }
 
     Vector<TextureMapperTile> m_tiles;
-    FloatSize m_contentsSize;
-    FloatRect m_visibleRect;
-    FloatRect m_scaledvisibleRect;
+    FloatSize m_size;
     RefPtr<Image> m_image;
     float m_contentsScale { 1 };
     bool m_isScaleDirty { false };
-    bool m_isSizeDirty { false };
 };
 
 } // namespace WebCore

Modified: releases/WebKitGTK/webkit-2.12/Source/WebKit2/ChangeLog (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebKit2/ChangeLog	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebKit2/ChangeLog	2016-03-16 15:13:20 UTC (rev 198271)
@@ -1,3 +1,18 @@
+2016-03-16  Commit Queue  <[email protected]>
+
+        Unreviewed, rolling out r196803.
+        https://bugs.webkit.org/show_bug.cgi?id=155534
+
+        Introduced several rendering issues in popular websites
+        (Requested by KaL on #webkit).
+
+        Reverted changeset:
+
+        "[GTK] Limit the number of tiles according to the visible
+        area"
+        https://bugs.webkit.org/show_bug.cgi?id=126122
+        http://trac.webkit.org/changeset/196803
+
 2016-03-14  Carlos Garcia Campos  <[email protected]>
 
         [GTK] Reimplement webkit_web_context_clear_cache functionality.

Modified: releases/WebKitGTK/webkit-2.12/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp (198270 => 198271)


--- releases/WebKitGTK/webkit-2.12/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp	2016-03-16 13:59:43 UTC (rev 198270)
+++ releases/WebKitGTK/webkit-2.12/Source/WebKit2/WebProcess/WebPage/gtk/LayerTreeHostGtk.cpp	2016-03-16 15:13:20 UTC (rev 198271)
@@ -172,7 +172,6 @@
 
     // The non-composited contents are a child of the root layer.
     m_nonCompositedContentLayer = GraphicsLayer::create(graphicsLayerFactory(), *this);
-    downcast<GraphicsLayerTextureMapper>(*m_nonCompositedContentLayer).setAsNonCompositingLayer();
     m_nonCompositedContentLayer->setDrawsContent(true);
     m_nonCompositedContentLayer->setContentsOpaque(m_webPage->drawsBackground());
     m_nonCompositedContentLayer->setSize(m_webPage->size());
@@ -323,8 +322,7 @@
     if (m_viewOverlayRootLayer)
         m_viewOverlayRootLayer->flushCompositingState(FloatRect(FloatPoint(), m_rootLayer->size()), viewportIsStable);
 
-    FloatRect visibleRect(m_webPage->mainFrame()->view()->scrollPosition(), m_webPage->size());
-    downcast<GraphicsLayerTextureMapper>(*m_rootLayer).updateBackingStoreIncludingSubLayers(visibleRect);
+    downcast<GraphicsLayerTextureMapper>(*m_rootLayer).updateBackingStoreIncludingSubLayers();
     return true;
 }
 
_______________________________________________
webkit-changes mailing list
[email protected]
https://lists.webkit.org/mailman/listinfo/webkit-changes

Reply via email to