Changeset 287967 in webkit

Timestamp:

Jan 12, 2022, 6:17:09 PM (5 years ago)

Author:

Fujii Hironori

Message:

[WinCairo] Tiling scroll support
​https://bugs.webkit.org/show_bug.cgi?id=233676

Reviewed by Don Olmstead.

Source/WebCore:

Added a new class TextureMapperSparseBackingStore that supports
partially tiling the layer and removing tiles outside of the
coverage rect.

• Headers.cmake:
• platform/TextureMapper.cmake:
• platform/graphics/texmap/TextureMapperSparseBackingStore.cpp: Added.

(WebCore::TextureMapperSparseBackingStore::TextureMapperSparseBackingStore):
(WebCore::TextureMapperSparseBackingStore::setSize):
(WebCore::TextureMapperSparseBackingStore::removeUncoveredTiles):
(WebCore::TextureMapperSparseBackingStore::adjustedTransformForRect):
(WebCore::TextureMapperSparseBackingStore::paintToTextureMapper):
(WebCore::TextureMapperSparseBackingStore::drawBorder):
(WebCore::TextureMapperSparseBackingStore::drawRepaintCounter):
(WebCore::TextureMapperSparseBackingStore::tileDimension const):
(WebCore::TextureMapperSparseBackingStore::updateContents):

• platform/graphics/texmap/TextureMapperSparseBackingStore.h: Added.

Source/WebKit:

Added a new class WCTiledBacking that implements TiledBacking.

Copied computeVisibleAndCoverageRect,
transformByApplyingAnchorPoint and layerTransform from
GraphicsLayerAC.

• GPUProcess/graphics/wc/WCScene.cpp:

(WebKit::WCScene::update):

• WebProcess/WebPage/wc/DrawingAreaWC.cpp:

(WebKit::DrawingAreaWC::DrawingAreaWC):
(WebKit::DrawingAreaWC::updatePreferences):
(WebKit::DrawingAreaWC::shouldUseTiledBackingForFrameView const):
(WebKit::DrawingAreaWC::setNeedsDisplayInRect):
(WebKit::DrawingAreaWC::scroll):
(WebKit::flushLayerImageBuffers):
(WebKit::DrawingAreaWC::sendUpdateAC):
(WebKit::DrawingAreaWC::RootLayerClient::RootLayerClient): Deleted.
(WebKit::DrawingAreaWC::RootLayerClient::paintContents): Deleted.
(WebKit::DrawingAreaWC::RootLayerClient::deviceScaleFactor const): Deleted.

• WebProcess/WebPage/wc/DrawingAreaWC.h:
• WebProcess/WebPage/wc/GraphicsLayerWC.cpp:

(WebKit::GraphicsLayerWC::GraphicsLayerWC):
(WebKit::GraphicsLayerWC::setNeedsDisplay):
(WebKit::GraphicsLayerWC::setNeedsDisplayInRect):
(WebKit::GraphicsLayerWC::setBackgroundColor):
(WebKit::GraphicsLayerWC::setDrawsContent):
(WebKit::GraphicsLayerWC::noteLayerPropertyChanged):
(WebKit::GraphicsLayerWC::flushCompositingState):
(WebKit::GraphicsLayerWC::flushCompositingStateForThisLayerOnly):
(WebKit::GraphicsLayerWC::tiledBacking const):
(WebKit::GraphicsLayerWC::createImageBuffer):
(WebKit::accumulatesTransform):
(WebKit::GraphicsLayerWC::transformByApplyingAnchorPoint const):
(WebKit::GraphicsLayerWC::layerTransform const):
(WebKit::GraphicsLayerWC::computeVisibleAndCoverageRect const):
(WebKit::GraphicsLayerWC::recursiveCommitChanges):

• WebProcess/WebPage/wc/GraphicsLayerWC.h:
• WebProcess/WebPage/wc/WCUpateInfo.h:

(WebKit::WCLayerUpateInfo::encode const):
(WebKit::WCLayerUpateInfo::decode):

Location:

trunk/Source

Files:

• WebCore/ChangeLog (modified) (1 diff)
• WebCore/Headers.cmake (modified) (1 diff)
• WebCore/platform/TextureMapper.cmake (modified) (1 diff)
• WebCore/platform/graphics/texmap/TextureMapperSparseBackingStore.cpp (added)
• WebCore/platform/graphics/texmap/TextureMapperSparseBackingStore.h (added)
• WebKit/ChangeLog (modified) (1 diff)
• WebKit/GPUProcess/graphics/wc/WCScene.cpp (modified) (4 diffs)
• WebKit/WebProcess/WebPage/wc/DrawingAreaWC.cpp (modified) (9 diffs)
• WebKit/WebProcess/WebPage/wc/DrawingAreaWC.h (modified) (2 diffs)
• WebKit/WebProcess/WebPage/wc/GraphicsLayerWC.cpp (modified) (11 diffs)
• WebKit/WebProcess/WebPage/wc/GraphicsLayerWC.h (modified) (3 diffs)
• WebKit/WebProcess/WebPage/wc/WCUpateInfo.h (modified) (7 diffs)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2022-01-12  Fujii Hironori  <Hironori.Fujii@sony.com>
+
+        [WinCairo] Tiling scroll support
+        https://bugs.webkit.org/show_bug.cgi?id=233676
+
+        Reviewed by Don Olmstead.
+
+        Added a new class TextureMapperSparseBackingStore that supports
+        partially tiling the layer and removing tiles outside of the
+        coverage rect.
+
+        * Headers.cmake:
+        * platform/TextureMapper.cmake:
+        * platform/graphics/texmap/TextureMapperSparseBackingStore.cpp: Added.
+        (WebCore::TextureMapperSparseBackingStore::TextureMapperSparseBackingStore):
+        (WebCore::TextureMapperSparseBackingStore::setSize):
+        (WebCore::TextureMapperSparseBackingStore::removeUncoveredTiles):
+        (WebCore::TextureMapperSparseBackingStore::adjustedTransformForRect):
+        (WebCore::TextureMapperSparseBackingStore::paintToTextureMapper):
+        (WebCore::TextureMapperSparseBackingStore::drawBorder):
+        (WebCore::TextureMapperSparseBackingStore::drawRepaintCounter):
+        (WebCore::TextureMapperSparseBackingStore::tileDimension const):
+        (WebCore::TextureMapperSparseBackingStore::updateContents):
+        * platform/graphics/texmap/TextureMapperSparseBackingStore.h: Added.
+
 2022-01-12  Megan Gardner  <megan_gardner@apple.com>
 

trunk/Source/WebCore/Headers.cmake

@@ -1646 +1646 @@
     platform/graphics/transforms/TransformOperation.h
     platform/graphics/transforms/TransformOperations.h
+    platform/graphics/transforms/TransformState.h
     platform/graphics/transforms/TransformationMatrix.h
     platform/graphics/transforms/TranslateTransformOperation.h

trunk/Source/WebCore/platform/TextureMapper.cmake

@@ -130 +130 @@
     )
 endif ()
+
+if (USE_GRAPHICS_LAYER_WC)
+    list(APPEND WebCore_SOURCES
+        platform/graphics/texmap/TextureMapperSparseBackingStore.cpp
+    )
+    list(APPEND WebCore_PRIVATE_FRAMEWORK_HEADERS
+        platform/graphics/texmap/TextureMapperSparseBackingStore.h
+    )
+endif ()

trunk/Source/WebKit/ChangeLog

@@ +1 @@
+2022-01-12  Fujii Hironori  <Hironori.Fujii@sony.com>
+
+        [WinCairo] Tiling scroll support
+        https://bugs.webkit.org/show_bug.cgi?id=233676
+
+        Reviewed by Don Olmstead.
+
+        Added a new class WCTiledBacking that implements TiledBacking.
+
+        Copied computeVisibleAndCoverageRect,
+        transformByApplyingAnchorPoint and layerTransform from
+        GraphicsLayerAC.
+
+        * GPUProcess/graphics/wc/WCScene.cpp:
+        (WebKit::WCScene::update):
+        * WebProcess/WebPage/wc/DrawingAreaWC.cpp:
+        (WebKit::DrawingAreaWC::DrawingAreaWC):
+        (WebKit::DrawingAreaWC::updatePreferences):
+        (WebKit::DrawingAreaWC::shouldUseTiledBackingForFrameView const):
+        (WebKit::DrawingAreaWC::setNeedsDisplayInRect):
+        (WebKit::DrawingAreaWC::scroll):
+        (WebKit::flushLayerImageBuffers):
+        (WebKit::DrawingAreaWC::sendUpdateAC):
+        (WebKit::DrawingAreaWC::RootLayerClient::RootLayerClient): Deleted.
+        (WebKit::DrawingAreaWC::RootLayerClient::paintContents): Deleted.
+        (WebKit::DrawingAreaWC::RootLayerClient::deviceScaleFactor const): Deleted.
+        * WebProcess/WebPage/wc/DrawingAreaWC.h:
+        * WebProcess/WebPage/wc/GraphicsLayerWC.cpp:
+        (WebKit::GraphicsLayerWC::GraphicsLayerWC):
+        (WebKit::GraphicsLayerWC::setNeedsDisplay):
+        (WebKit::GraphicsLayerWC::setNeedsDisplayInRect):
+        (WebKit::GraphicsLayerWC::setBackgroundColor):
+        (WebKit::GraphicsLayerWC::setDrawsContent):
+        (WebKit::GraphicsLayerWC::noteLayerPropertyChanged):
+        (WebKit::GraphicsLayerWC::flushCompositingState):
+        (WebKit::GraphicsLayerWC::flushCompositingStateForThisLayerOnly):
+        (WebKit::GraphicsLayerWC::tiledBacking const):
+        (WebKit::GraphicsLayerWC::createImageBuffer):
+        (WebKit::accumulatesTransform):
+        (WebKit::GraphicsLayerWC::transformByApplyingAnchorPoint const):
+        (WebKit::GraphicsLayerWC::layerTransform const):
+        (WebKit::GraphicsLayerWC::computeVisibleAndCoverageRect const):
+        (WebKit::GraphicsLayerWC::recursiveCommitChanges):
+        * WebProcess/WebPage/wc/GraphicsLayerWC.h:
+        * WebProcess/WebPage/wc/WCUpateInfo.h:
+        (WebKit::WCLayerUpateInfo::encode const):
+        (WebKit::WCLayerUpateInfo::decode):
+
 2022-01-12  Ryan Haddad  <ryanhaddad@apple.com>
 

trunk/Source/WebKit/GPUProcess/graphics/wc/WCScene.cpp

@@ -37 +37 @@
 #include <WebCore/TextureMapperLayer.h>
 #include <WebCore/TextureMapperPlatformLayer.h>
-#include <WebCore/TextureMapperTiledBackingStore.h>
+#include <WebCore/TextureMapperSparseBackingStore.h>
 
 namespace WebKit {
@@ -53 +53 @@
 
     WebCore::TextureMapperLayer texmapLayer;
-    RefPtr<WebCore::TextureMapperTiledBackingStore> backingStore;
+    std::optional<WebCore::TextureMapperSparseBackingStore> backingStore;
     std::unique_ptr<WebCore::TextureMapperLayer> backdropLayer;
 };
@@ -123 +123 @@
         if (layerUpdate.changes & WCLayerChange::MasksToBounds)
             layer->texmapLayer.setMasksToBounds(layerUpdate.masksToBounds);
-        if (layerUpdate.changes & WCLayerChange::BackingStore) {
-            auto bitmap = layerUpdate.backingStore.bitmap();
-            if (bitmap) {
-                layer->backingStore = WebCore::TextureMapperTiledBackingStore::create();
-                auto image = bitmap->createImage();
-                layer->backingStore->updateContents(*m_textureMapper, image.get(), bitmap->size(), { { }, bitmap->size() });
-                layer->texmapLayer.setBackingStore(layer->backingStore.get());
+        if (layerUpdate.changes & WCLayerChange::Background) {
+            if (layerUpdate.hasBackingStore) {
+                if (!layer->backingStore) {
+                    const int tileSize = 512;
+                    layer->backingStore.emplace<WebCore::TextureMapperSparseBackingStore>(tileSize);
+                    auto& backingStore = *layer->backingStore;
+                    layer->texmapLayer.setBackgroundColor({ });
+                    layer->texmapLayer.setBackingStore(&backingStore);
+                }
+                auto& backingStore = *layer->backingStore;
+                backingStore.setSize(WebCore::IntSize(layer->texmapLayer.size()));
+                backingStore.removeUncoveredTiles(layerUpdate.coverageRect);
+                auto bitmap = layerUpdate.backingStore.bitmap();
+                if (bitmap) {
+                    auto image = bitmap->createImage();
+                    backingStore.updateContents(*m_textureMapper, *image, layerUpdate.dirtyRect);
+                }
             } else {
+                layer->texmapLayer.setBackgroundColor(layerUpdate.backgroundColor);
                 layer->texmapLayer.setBackingStore(nullptr);
-                layer->backingStore = nullptr;
+                layer->backingStore = std::nullopt;
             }
         }
@@ -141 +152 @@
         if (layerUpdate.changes & WCLayerChange::RepaintCount)
             layer->texmapLayer.setRepaintCounter(layerUpdate.showRepaintCounter, layerUpdate.repaintCount);
-        if (layerUpdate.changes & WCLayerChange::BackgroundColor)
-            layer->texmapLayer.setBackgroundColor(layerUpdate.backgroundColor);
         if (layerUpdate.changes & WCLayerChange::Opacity)
             layer->texmapLayer.setOpacity(layerUpdate.opacity);

trunk/Source/WebKit/WebProcess/WebPage/wc/DrawingAreaWC.cpp

@@ -32 +32 @@
 #include "RemoteWCLayerTreeHostProxy.h"
 #include "UpdateInfo.h"
+#include "WebFrame.h"
 #include "WebPageCreationParameters.h"
 #include "WebProcess.h"
@@ -43 +44 @@
 DrawingAreaWC::DrawingAreaWC(WebPage& webPage, const WebPageCreationParameters& parameters)
     : DrawingArea(DrawingAreaType::WC, parameters.drawingAreaIdentifier, webPage)
-    , m_rootLayerClient(webPage)
     , m_remoteWCLayerTreeHostProxy(makeUnique<RemoteWCLayerTreeHostProxy>(webPage, *this))
     , m_layerFactory(*this)
@@ -51 +51 @@
 {
     m_rootLayer->setName(MAKE_STATIC_STRING_IMPL("drawing area root"));
-    m_rootLayer->setDrawsContent(true);
-    m_rootLayer->setContentsOpaque(true);
     m_rootLayer->setSize(m_webPage.size());
-    m_rootLayer->setNeedsDisplay();
 }
 
@@ -94 +91 @@
 }
 
+void DrawingAreaWC::updatePreferences(const WebPreferencesStore&)
+{
+    Settings& settings = m_webPage.corePage()->settings();
+    settings.setAcceleratedCompositingForFixedPositionEnabled(settings.acceleratedCompositingEnabled());
+}
+
+bool DrawingAreaWC::shouldUseTiledBackingForFrameView(const WebCore::FrameView& frameView) const
+{
+    return frameView.frame().isMainFrame();
+}
+
 void DrawingAreaWC::setLayerTreeStateIsFrozen(bool isFrozen)
 {
@@ -123 +131 @@
 {
     if (isCompositingMode())
-        m_rootLayer->setNeedsDisplayInRect(rect);
-    else
-        m_dirtyRegion.unite(rect);
+        return;
+    m_dirtyRegion.unite(rect);
     triggerRenderingUpdate();
 }
@@ -132 +139 @@
 {
     if (isCompositingMode())
-        m_rootLayer->setNeedsDisplayInRect(scrollRect);
-    else {
-        if (scrollRect != m_scrollRect) {
-            // Just repaint the entire current scroll rect, we'll scroll the new rect instead.
-            setNeedsDisplayInRect(m_scrollRect);
-            m_scrollRect = { };
-            m_scrollOffset = { };
-        }
-        // Get the part of the dirty region that is in the scroll rect.
-        Region dirtyRegionInScrollRect = intersect(scrollRect, m_dirtyRegion);
-        if (!dirtyRegionInScrollRect.isEmpty()) {
-            // There are parts of the dirty region that are inside the scroll rect.
-            // We need to subtract them from the region, move them and re-add them.
-            m_dirtyRegion.subtract(scrollRect);
-            // Move the dirty parts.
-            Region movedDirtyRegionInScrollRect = intersect(translate(dirtyRegionInScrollRect, scrollDelta), scrollRect);
-            // And add them back.
-            m_dirtyRegion.unite(movedDirtyRegionInScrollRect);
-        }
-        // Compute the scroll repaint region.
-        Region scrollRepaintRegion = subtract(scrollRect, translate(scrollRect, scrollDelta));
-        m_dirtyRegion.unite(scrollRepaintRegion);
-        m_scrollRect = scrollRect;
-        m_scrollOffset += scrollDelta;
-        triggerRenderingUpdate();
-    }
+        return;
+
+    if (scrollRect != m_scrollRect) {
+        // Just repaint the entire current scroll rect, we'll scroll the new rect instead.
+        setNeedsDisplayInRect(m_scrollRect);
+        m_scrollRect = { };
+        m_scrollOffset = { };
+    }
+    // Get the part of the dirty region that is in the scroll rect.
+    Region dirtyRegionInScrollRect = intersect(scrollRect, m_dirtyRegion);
+    if (!dirtyRegionInScrollRect.isEmpty()) {
+        // There are parts of the dirty region that are inside the scroll rect.
+        // We need to subtract them from the region, move them and re-add them.
+        m_dirtyRegion.subtract(scrollRect);
+        // Move the dirty parts.
+        Region movedDirtyRegionInScrollRect = intersect(translate(dirtyRegionInScrollRect, scrollDelta), scrollRect);
+        // And add them back.
+        m_dirtyRegion.unite(movedDirtyRegionInScrollRect);
+    }
+    // Compute the scroll repaint region.
+    Region scrollRepaintRegion = subtract(scrollRect, translate(scrollRect, scrollDelta));
+    m_dirtyRegion.unite(scrollRepaintRegion);
+    m_scrollRect = scrollRect;
+    m_scrollOffset += scrollDelta;
+    triggerRenderingUpdate();
 }
 
@@ -174 +180 @@
 {
     for (auto& layerInfo : info.changedLayers) {
-        if (layerInfo.changes & WCLayerChange::BackingStore) {
+        if (layerInfo.changes & WCLayerChange::Background) {
             if (auto image = layerInfo.backingStore.imageBuffer()) {
                 if (auto flusher = image->createFlusher())
@@ -221 +227 @@
 
     // Because our view-relative overlay root layer is not attached to the FrameView's GraphicsLayer tree, we need to flush it manually.
-    if (m_viewOverlayRootLayer)
-        m_viewOverlayRootLayer->flushCompositingState({ });
+    if (m_viewOverlayRootLayer) {
+        FloatRect visibleRect({ }, m_webPage.size());
+        m_viewOverlayRootLayer->flushCompositingState(visibleRect);
+    }
 
     m_updateInfo.rootLayer = m_rootLayer->primaryLayerID();
@@ -342 +350 @@
 }
 
-DrawingAreaWC::RootLayerClient::RootLayerClient(WebPage& webPage)
-    : m_webPage(webPage)
-{
-}
-
-void DrawingAreaWC::RootLayerClient::paintContents(const GraphicsLayer*, GraphicsContext& context, const FloatRect& rectToPaint, GraphicsLayerPaintBehavior)
-{
-    context.save();
-    context.clip(rectToPaint);
-    m_webPage.corePage()->mainFrame().view()->paint(context, enclosingIntRect(rectToPaint));
-    context.restore();
-}
-
-float DrawingAreaWC::RootLayerClient::deviceScaleFactor() const
-{
-    return m_webPage.corePage()->deviceScaleFactor();
-}
-
 } // namespace WebKit

trunk/Source/WebKit/WebProcess/WebPage/wc/DrawingAreaWC.h

@@ -58 +58 @@
     void setRootCompositingLayer(WebCore::GraphicsLayer*) override;
     void attachViewOverlayGraphicsLayer(WebCore::GraphicsLayer*) override;
+    void updatePreferences(const WebPreferencesStore&) override;
+    bool shouldUseTiledBackingForFrameView(const WebCore::FrameView&) const override;
     // GraphicsLayerWC::Observer
     void graphicsLayerAdded(GraphicsLayerWC&) override;
@@ -72 +74 @@
     void updateRootLayers();
 
-    class RootLayerClient : public WebCore::GraphicsLayerClient {
-    public:
-        RootLayerClient(WebPage&);
-    private:
-        void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, const WebCore::FloatRect& rectToPaint, WebCore::GraphicsLayerPaintBehavior) override;
-        float deviceScaleFactor() const override;
-        WebPage& m_webPage;
-    };
-
-    RootLayerClient m_rootLayerClient;
+    WebCore::GraphicsLayerClient m_rootLayerClient;
     std::unique_ptr<RemoteWCLayerTreeHostProxy> m_remoteWCLayerTreeHostProxy;
     WCLayerFactory m_layerFactory;

trunk/Source/WebKit/WebProcess/WebPage/wc/GraphicsLayerWC.cpp

@@ -1 +1 @@
 /*
+ * Copyright (C) 2010-2021 Apple Inc. All rights reserved.
  * Copyright (C) 2021 Sony Interactive Entertainment Inc.
  *
@@ -28 +29 @@
 
 #include "WCPlatformLayerGCGL.h"
+#include <WebCore/TransformState.h>
 
 namespace WebKit {
 using namespace WebCore;
+
+class WCTiledBacking final : public TiledBacking {
+    WTF_MAKE_FAST_ALLOCATED;
+public:
+    WCTiledBacking(GraphicsLayerWC& owner)
+        : m_owner(owner) { }
+
+    bool paintAndFlush(WCLayerUpateInfo& update)
+    {
+        update.dirtyRect = enclosingIntRect(m_dirtyRect);
+        update.coverageRect = m_coverageRect;
+        m_dirtyRect = { };
+        auto& imageRect = update.dirtyRect;
+        if (imageRect.isEmpty())
+            return false;
+        auto image = m_owner.createImageBuffer(imageRect.size());
+        auto& context = image->context();
+        context.translate(-imageRect.x(), -imageRect.y());
+        m_owner.paintGraphicsLayerContents(context, update.dirtyRect);
+        image->flushDrawingContextAsync();
+        update.backingStore.setImageBuffer(WTFMove(image));
+        return true;
+    }
+
+    void setDirtyRect(const WebCore::FloatRect& rect)
+    {
+        m_dirtyRect.unite(rect);
+    }
+
+    bool hasDirtyRect()
+    {
+        return !m_dirtyRect.isEmpty();
+    }
+
+    TiledBacking* tiledBacking() const { return const_cast<WCTiledBacking*>(this); };
+
+    IntRect adjustCoverageRect(IntRect coverage)
+    {
+        int x = coverage.x() / tileSize().width() * tileSize().width();
+        int y = coverage.y() / tileSize().height() * tileSize().height();
+        int maxX = (coverage.maxX() + tileSize().width() - 1) / tileSize().width() * tileSize().width();
+        int maxY = (coverage.maxY() + tileSize().height() - 1) / tileSize().height() * tileSize().height();
+        IntRect newCoverage { x, y, maxX - x, maxY - y };
+        newCoverage.intersect(bounds());
+        return newCoverage;
+    }
+
+    // TiledBacking override
+    void setVisibleRect(const FloatRect&) final { }
+    FloatRect visibleRect() const final { return { }; };
+    void setLayoutViewportRect(std::optional<FloatRect>) final { }
+    void setCoverageRect(const FloatRect& rect) final
+    {
+        auto newCoverage = adjustCoverageRect(enclosingIntRect(rect));
+        WebCore::Region region(newCoverage);
+        region.subtract(m_coverageRect);
+        setDirtyRect(region.bounds());
+        m_coverageRect = newCoverage;
+        m_dirtyRect.intersect(m_coverageRect);
+    }
+    FloatRect coverageRect() const final { return { }; };
+    bool tilesWouldChangeForCoverageRect(const FloatRect&) const final { return false; }
+    void setTiledScrollingIndicatorPosition(const FloatPoint&) final { }
+    void setTopContentInset(float) final { }
+    void setVelocity(const VelocityData&) final { }
+    void setTileSizeUpdateDelayDisabledForTesting(bool) final { };
+    void setScrollability(Scrollability) final { }
+    void prepopulateRect(const FloatRect&) final { }
+    void setIsInWindow(bool) final { }
+    bool isInWindow() const final { return m_isInWindow; }
+    void setTileCoverage(TileCoverage) final { }
+    TileCoverage tileCoverage() const final { return { }; };
+    FloatRect adjustTileCoverageRect(const FloatRect& coverageRect, const FloatRect& previousVisibleRect, const FloatRect& currentVisibleRect, bool sizeChanged) final { return { }; };
+    FloatRect adjustTileCoverageRectForScrolling(const FloatRect& coverageRect, const FloatSize& newSize, const FloatRect& previousVisibleRect, const FloatRect& currentVisibleRect, float contentsScale) final { return { }; };
+    void willStartLiveResize() final { };
+    void didEndLiveResize() final { };
+    IntSize tileSize() const final { return { 512, 512 }; };
+    void revalidateTiles() final { }
+    void forceRepaint() final { }
+    IntRect tileGridExtent() const final { return { }; }
+    void setScrollingPerformanceTestingEnabled(bool flag) final { }
+    bool scrollingPerformanceTestingEnabled() const final { return false; };
+    double retainedTileBackingStoreMemory() const final { return 0; }
+    IntRect tileCoverageRect() const final { return { }; }
+    void setScrollingModeIndication(ScrollingModeIndication) final { }
+    void setHasMargins(bool marginTop, bool marginBottom, bool marginLeft, bool marginRight) final { }
+    bool hasMargins() const final { return false; };
+    bool hasHorizontalMargins() const final { return false; };
+    bool hasVerticalMargins() const final { return false; };
+    void setMarginSize(int) final { }
+    int topMarginHeight() const final { return 0; };
+    int bottomMarginHeight() const final { return 0; };
+    int leftMarginWidth() const final { return 0; };
+    int rightMarginWidth() const final { return 0; };
+    void setZoomedOutContentsScale(float) final { }
+    float zoomedOutContentsScale() const final { return 1; }
+    IntRect bounds() const final { return { { }, IntSize(m_owner.size()) }; };
+    IntRect boundsWithoutMargin() const final { return bounds(); };
+
+private:
+    bool m_isInWindow { false };
+    WebCore::IntRect m_coverageRect;
+    WebCore::FloatRect m_dirtyRect;
+    GraphicsLayerWC& m_owner;
+};
+
 
 GraphicsLayerWC::GraphicsLayerWC(Type layerType, GraphicsLayerClient& client, Observer& observer)
@@ -36 +144 @@
     , m_observer(&observer)
 {
+    m_tiledBacking = makeUnique<WCTiledBacking>(*this);
+    if (layerType == Type::Normal)
+        client.tiledBackingUsageChanged(this, true);
     m_observer->graphicsLayerAdded(*this);
 }
@@ -60 +171 @@
 void GraphicsLayerWC::setNeedsDisplay()
 {
+    setNeedsDisplayInRect({ { }, m_size }, ClipToLayer);
+}
+
+void GraphicsLayerWC::setNeedsDisplayInRect(const WebCore::FloatRect& rect, ShouldClipToLayer shouldClip)
+{
     if (!drawsContent())
         return;
-    noteLayerPropertyChanged(WCLayerChange::BackingStore);
-    addRepaintRect({ { }, m_size });
-}
-
-void GraphicsLayerWC::setNeedsDisplayInRect(const WebCore::FloatRect& rect, ShouldClipToLayer)
-{
-    if (!drawsContent())
-        return;
-    noteLayerPropertyChanged(WCLayerChange::BackingStore);
+
+    m_tiledBacking->setDirtyRect(rect);
+    noteLayerPropertyChanged(WCLayerChange::Background);
     addRepaintRect(rect);
 }
@@ -222 +332 @@
         return;
     GraphicsLayer::setBackgroundColor(value);
-    noteLayerPropertyChanged(WCLayerChange::BackgroundColor);
+    noteLayerPropertyChanged(WCLayerChange::Background);
 }
 
@@ -254 +364 @@
         return;
     GraphicsLayer::setDrawsContent(value);
-    noteLayerPropertyChanged(WCLayerChange::BackingStore);
+    noteLayerPropertyChanged(WCLayerChange::Background);
     updateDebugIndicators();
 }
@@ -375 +485 @@
 }
 
-void GraphicsLayerWC::noteLayerPropertyChanged(OptionSet<WCLayerChange> flags)
+void GraphicsLayerWC::noteLayerPropertyChanged(OptionSet<WCLayerChange> flags, ScheduleFlushOrNot scheduleFlush)
 {
     if (beingDestroyed())
@@ -381 +491 @@
     bool needsFlush = !m_uncommittedChanges;
     m_uncommittedChanges.add(flags);
-    if (needsFlush)
+    if (needsFlush && scheduleFlush == ScheduleFlush)
         client().notifyFlushRequired(this);
 }
 
-void GraphicsLayerWC::flushCompositingState(const FloatRect& rect)
-{
-    if (auto* mask = maskLayer())
-        mask->flushCompositingStateForThisLayerOnly();
-    if (auto* replica = replicaLayer())
-        replica->flushCompositingStateForThisLayerOnly();
-    flushCompositingStateForThisLayerOnly();
-    for (auto& child : children())
-        child->flushCompositingState(rect);
+void GraphicsLayerWC::flushCompositingState(const FloatRect& passedVisibleRect)
+{
+    // passedVisibleRect doesn't contain the scrollbar area. Inflate it.
+    FloatRect visibleRect = passedVisibleRect;
+    visibleRect.inflate(20.f);
+    TransformState state(TransformState::UnapplyInverseTransformDirection, FloatQuad(visibleRect));
+    state.setSecondaryQuad(FloatQuad { visibleRect });
+    recursiveCommitChanges(state);
 }
 
@@ -438 +547 @@
     if (update.changes & WCLayerChange::MasksToBounds)
         update.masksToBounds = masksToBounds();
-    if (update.changes & WCLayerChange::BackingStore) {
-        if (drawsContent() && contentsAreVisible() && !size().isEmpty()) {
-            auto image = m_observer->createImageBuffer(size());
-            FloatRect clipRect = { { }, size() };
-            paintGraphicsLayerContents(image->context(), clipRect);
-            image->flushDrawingContextAsync();
-            update.backingStore.setImageBuffer(WTFMove(image));
-
-            incrementRepaintCount();
-            update.changes.add(WCLayerChange::RepaintCount);
-        }
+    if (update.changes & WCLayerChange::Background) {
+        update.backgroundColor = backgroundColor();
+        if (drawsContent() && contentsAreVisible()) {
+            update.hasBackingStore = true;
+            if (m_tiledBacking->paintAndFlush(update)) {
+                incrementRepaintCount();
+                update.changes.add(WCLayerChange::RepaintCount);
+            }
+        } else
+            update.hasBackingStore = false;
     }
     if (update.changes & WCLayerChange::SolidColor)
@@ -461 +569 @@
         update.repaintCount = repaintCount();
     }
-    if (update.changes & WCLayerChange::BackgroundColor)
-        update.backgroundColor = backgroundColor();
     if (update.changes & WCLayerChange::Opacity)
         update.opacity = opacity();
@@ -483 +589 @@
 }
 
+TiledBacking* GraphicsLayerWC::tiledBacking() const
+{
+    return m_tiledBacking->tiledBacking();
+}
+
+RefPtr<WebCore::ImageBuffer> GraphicsLayerWC::createImageBuffer(WebCore::FloatSize size)
+{
+    return m_observer->createImageBuffer(size);
+}
+
+static inline bool accumulatesTransform(const GraphicsLayerWC& layer)
+{
+    return !layer.masksToBounds() && (layer.preserves3D() || (layer.parent() && layer.parent()->preserves3D()));
+}
+
+TransformationMatrix GraphicsLayerWC::transformByApplyingAnchorPoint(const TransformationMatrix& matrix) const
+{
+    if (matrix.isIdentity())
+        return matrix;
+
+    TransformationMatrix result;
+    FloatPoint3D absoluteAnchorPoint(anchorPoint());
+    absoluteAnchorPoint.scale(size().width(), size().height(), 1);
+    result.translate3d(absoluteAnchorPoint.x(), absoluteAnchorPoint.y(), absoluteAnchorPoint.z());
+    result.multiply(matrix);
+    result.translate3d(-absoluteAnchorPoint.x(), -absoluteAnchorPoint.y(), -absoluteAnchorPoint.z());
+    return result;
+}
+
+TransformationMatrix GraphicsLayerWC::layerTransform(const FloatPoint& position, const TransformationMatrix* customTransform) const
+{
+    TransformationMatrix transform;
+    transform.translate(position.x(), position.y());
+
+    TransformationMatrix currentTransform;
+    if (customTransform)
+        currentTransform = *customTransform;
+    else if (m_transform)
+        currentTransform = *m_transform;
+
+    transform.multiply(transformByApplyingAnchorPoint(currentTransform));
+
+    if (GraphicsLayer* parentLayer = parent()) {
+        if (parentLayer->hasNonIdentityChildrenTransform()) {
+            FloatPoint boundsOrigin = parentLayer->boundsOrigin();
+
+            FloatPoint3D parentAnchorPoint(parentLayer->anchorPoint());
+            parentAnchorPoint.scale(parentLayer->size().width(), parentLayer->size().height(), 1);
+            parentAnchorPoint += boundsOrigin;
+
+            transform.translateRight3d(-parentAnchorPoint.x(), -parentAnchorPoint.y(), -parentAnchorPoint.z());
+            transform = parentLayer->childrenTransform() * transform;
+            transform.translateRight3d(parentAnchorPoint.x(), parentAnchorPoint.y(), parentAnchorPoint.z());
+        }
+    }
+
+    return transform;
+}
+
+GraphicsLayerWC::VisibleAndCoverageRects GraphicsLayerWC::computeVisibleAndCoverageRect(TransformState& state, bool preserves3D) const
+{
+    FloatPoint position = approximatePosition();
+    client().customPositionForVisibleRectComputation(this, position);
+
+    TransformationMatrix layerTransform;
+    TransformationMatrix currentTransform;
+    if (client().getCurrentTransform(this, currentTransform))
+        layerTransform = this->layerTransform(position, &currentTransform);
+    else
+        layerTransform = this->layerTransform(position);
+
+    bool applyWasClamped;
+    TransformState::TransformAccumulation accumulation = preserves3D ? TransformState::AccumulateTransform : TransformState::FlattenTransform;
+    state.applyTransform(layerTransform, accumulation, &applyWasClamped);
+
+    bool mapWasClamped;
+    FloatRect clipRectForChildren = state.mappedQuad(&mapWasClamped).boundingBox();
+    FloatPoint boundsOrigin = m_boundsOrigin;
+    clipRectForChildren.move(boundsOrigin.x(), boundsOrigin.y());
+    
+    FloatRect clipRectForSelf(boundsOrigin, m_size);
+    if (!applyWasClamped && !mapWasClamped)
+        clipRectForSelf.intersect(clipRectForChildren);
+
+    if (masksToBounds()) {
+        ASSERT(accumulation == TransformState::FlattenTransform);
+        // Flatten, and replace the quad in the TransformState with one that is clipped to this layer's bounds.
+        state.flatten();
+        state.setQuad(clipRectForSelf);
+        if (state.isMappingSecondaryQuad())
+            state.setSecondaryQuad(FloatQuad { clipRectForSelf });
+    }
+
+    FloatRect coverageRect = clipRectForSelf;
+    auto quad = state.mappedSecondaryQuad(&mapWasClamped);
+    if (quad && !mapWasClamped && !applyWasClamped)
+        coverageRect = (*quad).boundingBox();
+
+    return { clipRectForSelf, coverageRect, currentTransform };
+}
+
+void GraphicsLayerWC::recursiveCommitChanges(const TransformState& state)
+{
+    TransformState localState = state;
+
+    bool accumulateTransform = accumulatesTransform(*this);
+    VisibleAndCoverageRects rects = computeVisibleAndCoverageRect(localState, accumulateTransform);
+    m_tiledBacking->setCoverageRect(rects.coverageRect);
+    if (m_tiledBacking->hasDirtyRect())
+        noteLayerPropertyChanged(WCLayerChange::Background, DontScheduleFlush);
+
+    flushCompositingStateForThisLayerOnly();
+    if (auto* mask = maskLayer())
+        static_cast<GraphicsLayerWC*>(mask)->recursiveCommitChanges(localState);
+    if (auto* replica = replicaLayer())
+        static_cast<GraphicsLayerWC*>(replica)->recursiveCommitChanges(localState);
+    for (auto& child : children())
+        static_cast<GraphicsLayerWC*>(child.ptr())->recursiveCommitChanges(localState);
+}
+
 } // namespace WebKit

trunk/Source/WebKit/WebProcess/WebPage/wc/GraphicsLayerWC.h

@@ -30 +30 @@
 #include <wtf/DoublyLinkedList.h>
 
+namespace WebCore {
+class TransformState;
+}
+
 namespace WebKit {
+class WCTiledBacking;
 
 class GraphicsLayerWC final : public WebCore::GraphicsLayer, public DoublyLinkedListNode<GraphicsLayerWC> {
@@ -89 +94 @@
     void flushCompositingState(const WebCore::FloatRect& clipRect) override;
     void flushCompositingStateForThisLayerOnly() override;
+    WebCore::TiledBacking* tiledBacking() const override;
 
+protected:
+    friend WCTiledBacking;
+
+    RefPtr<WebCore::ImageBuffer> createImageBuffer(WebCore::FloatSize);
+    
 private:
-    void noteLayerPropertyChanged(OptionSet<WCLayerChange>);
+    struct VisibleAndCoverageRects {
+        WTF_MAKE_STRUCT_FAST_ALLOCATED;
+        WebCore::FloatRect visibleRect;
+        WebCore::FloatRect coverageRect;
+        WebCore::TransformationMatrix animatingTransform;
+    };
+
+    enum ScheduleFlushOrNot { ScheduleFlush, DontScheduleFlush };
+    void noteLayerPropertyChanged(OptionSet<WCLayerChange>, ScheduleFlushOrNot = ScheduleFlush);
+    WebCore::TransformationMatrix transformByApplyingAnchorPoint(const WebCore::TransformationMatrix&) const;
+    WebCore::TransformationMatrix layerTransform(const WebCore::FloatPoint&, const WebCore::TransformationMatrix* = nullptr) const;
+    VisibleAndCoverageRects computeVisibleAndCoverageRect(WebCore::TransformState&, bool preserves3D) const;
+    void recursiveCommitChanges(const WebCore::TransformState&);
 
     static GraphicsLayer::PlatformLayerID generateLayerID();
@@ -101 +124 @@
     WebCore::GraphicsLayer::PlatformLayerID m_layerID { generateLayerID() };
     Observer* m_observer;
+    std::unique_ptr<WCTiledBacking> m_tiledBacking;
     PlatformLayer* m_platformLayer { nullptr };
     WebCore::Color m_solidColor;

trunk/Source/WebKit/WebProcess/WebPage/wc/WCUpateInfo.h

@@ -51 +51 @@
     ContentsClippingRect    = 1 << 12,
     Opacity                 = 1 << 13,
-    BackingStore            = 1 << 14,
+    Background              = 1 << 14,
     Transform               = 1 << 15,
     ChildrenTransform       = 1 << 16,
@@ -57 +57 @@
     BackdropFilters         = 1 << 18,
     PlatformLayer           = 1 << 19,
-    BackgroundColor         = 1 << 20,
 };
 
@@ -77 +76 @@
     bool preserves3D;
     bool hasPlatformLayer;
+    bool hasBackingStore;
     WebCore::Color solidColor;
     WebCore::Color backgroundColor;
@@ -85 +85 @@
     WebCore::FloatRect contentsRect;
     WCBackingStore backingStore;
+    WebCore::IntRect dirtyRect;
+    WebCore::IntRect coverageRect;
     WebCore::TransformationMatrix transform;
     WebCore::TransformationMatrix childrenTransform;
@@ -124 +126 @@
         if (changes & WCLayerChange::ContentsClippingRect)
             encoder << contentsClippingRect;
-        if (changes & WCLayerChange::BackgroundColor)
-            encoder << backgroundColor;
         if (changes & WCLayerChange::Opacity)
             encoder << opacity;
-        if (changes & WCLayerChange::BackingStore)
-            encoder << backingStore;
+        if (changes & WCLayerChange::Background)
+            encoder << backgroundColor << hasBackingStore << backingStore << dirtyRect << coverageRect;
         if (changes & WCLayerChange::Transform)
             encoder << transform;
@@ -213 +213 @@
                 return false;
         }
-        if (result.changes & WCLayerChange::BackgroundColor) {
-            if (!decoder.decode(result.backgroundColor))
-                return false;
-        }
         if (result.changes & WCLayerChange::Opacity) {
             if (!decoder.decode(result.opacity))
                 return false;
         }
-        if (result.changes & WCLayerChange::BackingStore) {
+        if (result.changes & WCLayerChange::Background) {
+            if (!decoder.decode(result.backgroundColor))
+                return false;
+            if (!decoder.decode(result.hasBackingStore))
+                return false;
             if (!decoder.decode(result.backingStore))
+                return false;
+            if (!decoder.decode(result.dirtyRect))
+                return false;
+            if (!decoder.decode(result.coverageRect))
                 return false;
         }
@@ -304 +308 @@
         WebKit::WCLayerChange::ContentsClippingRect,
         WebKit::WCLayerChange::Opacity,
-        WebKit::WCLayerChange::BackingStore,
+        WebKit::WCLayerChange::Background,
         WebKit::WCLayerChange::Transform,
         WebKit::WCLayerChange::ChildrenTransform,
         WebKit::WCLayerChange::Filters,
         WebKit::WCLayerChange::BackdropFilters,
-        WebKit::WCLayerChange::PlatformLayer,
-        WebKit::WCLayerChange::BackgroundColor
+        WebKit::WCLayerChange::PlatformLayer
     >;
 };