Changeset 215469 in webkit

Timestamp:

Apr 18, 2017 10:31:20 AM (7 years ago)

Author:

Antti Koivisto

Message:

Enable optimized layer flushes on iOS
​https://bugs.webkit.org/show_bug.cgi?id=170938
<rdar://problem/31677395>

Reviewed by Simon Fraser.

Source/WebCore:

Test: compositing/ios/overflow-scroll-touch-tiles.html

• platform/graphics/GraphicsLayer.h:

(WebCore::GraphicsLayer::setApproximatePosition):

Make virtual.

(WebCore::GraphicsLayer::flushCompositingState):

• platform/graphics/ca/GraphicsLayerCA.cpp:

(WebCore::GraphicsLayerCA::syncPosition):

Rename PositionChanged enum value to more descriptive NeedsComputeVisibleAndCoverageRect.

(WebCore::GraphicsLayerCA::setApproximatePosition):
(WebCore::GraphicsLayerCA::syncBoundsOrigin):

Like syncPosition make these invalidate the geometry without scheduling a flush. This is needed
so when flush happens we don't just optimize it away. Tile coverage depends on position and bounds.

(WebCore::GraphicsLayerCA::flushCompositingState):

Remove FlushScope argument.
Disable optimization on WK1 due to some UIKit interactions.

• platform/graphics/ca/GraphicsLayerCA.h:
• platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:

(WebCore::GraphicsLayerTextureMapper::flushCompositingState):

• platform/graphics/texmap/GraphicsLayerTextureMapper.h:

LayoutTests:

Add test verifying that tiles get created for touch overflow scrolling.

• compositing/ios/overflow-scroll-touch-tiles-expected.txt: Added.
• compositing/ios/overflow-scroll-touch-tiles.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/compositing/ios/overflow-scroll-touch-tiles-expected.txt (added)
• LayoutTests/compositing/ios/overflow-scroll-touch-tiles.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/platform/graphics/GraphicsLayer.h (modified) (2 diffs)
• Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp (modified) (4 diffs)
• Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h (modified) (3 diffs)
• Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp (modified) (1 diff)
• Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h (modified) (1 diff)
• Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp (modified) (1 diff)
• Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h (modified) (1 diff)
• Source/WebCore/rendering/RenderLayerCompositor.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2017-04-18  Antti Koivisto  <antti@apple.com>
+
+        Enable optimized layer flushes on iOS
+        https://bugs.webkit.org/show_bug.cgi?id=170938
+        <rdar://problem/31677395>
+
+        Reviewed by Simon Fraser.
+
+        Add test verifying that tiles get created for touch overflow scrolling.
+
+        * compositing/ios/overflow-scroll-touch-tiles-expected.txt: Added.
+        * compositing/ios/overflow-scroll-touch-tiles.html: Added.
+
 2017-04-18  Ryan Haddad  <ryanhaddad@apple.com>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-04-18  Antti Koivisto  <antti@apple.com>
+
+        Enable optimized layer flushes on iOS
+        https://bugs.webkit.org/show_bug.cgi?id=170938
+        <rdar://problem/31677395>
+
+        Reviewed by Simon Fraser.
+
+        Test: compositing/ios/overflow-scroll-touch-tiles.html
+
+        * platform/graphics/GraphicsLayer.h:
+        (WebCore::GraphicsLayer::setApproximatePosition):
+
+            Make virtual.
+
+        (WebCore::GraphicsLayer::flushCompositingState):
+        * platform/graphics/ca/GraphicsLayerCA.cpp:
+        (WebCore::GraphicsLayerCA::syncPosition):
+
+            Rename PositionChanged enum value to more descriptive NeedsComputeVisibleAndCoverageRect.
+
+        (WebCore::GraphicsLayerCA::setApproximatePosition):
+        (WebCore::GraphicsLayerCA::syncBoundsOrigin):
+
+            Like syncPosition make these invalidate the geometry without scheduling a flush. This is needed
+            so when flush happens we don't just optimize it away. Tile coverage depends on position and bounds.
+
+        (WebCore::GraphicsLayerCA::flushCompositingState):
+
+            Remove FlushScope argument.
+            Disable optimization on WK1 due to some UIKit interactions.
+
+        * platform/graphics/ca/GraphicsLayerCA.h:
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.cpp:
+        (WebCore::GraphicsLayerTextureMapper::flushCompositingState):
+        * platform/graphics/texmap/GraphicsLayerTextureMapper.h:
+
 2017-04-18  Tim Horton  <timothy_horton@apple.com>
 

trunk/Source/WebCore/platform/graphics/GraphicsLayer.h

@@ -315 +315 @@
     // approximatePosition, if set, overrides position() and is used during coverage rect computation.
     FloatPoint approximatePosition() const { return m_approximatePosition ? m_approximatePosition.value() : m_position; }
-    void setApproximatePosition(std::optional<FloatPoint> p) { m_approximatePosition = p; }
+    virtual void setApproximatePosition(const FloatPoint& p) { m_approximatePosition = p; }
 
     // For platforms that move underlying platform layers on a different thread for scrolling; just update the GraphicsLayer state.
@@ -526 +526 @@
     // with updates drawn into the window. These methods flush internal batched state on this layer
     // and descendant layers, and this layer only.
-    enum class FlushScope { Uncommitted, All };
-    virtual void flushCompositingState(const FloatRect& /* clipRect */, FlushScope = FlushScope::All) { }
+    virtual void flushCompositingState(const FloatRect& /* clipRect */) { }
     virtual void flushCompositingStateForThisLayerOnly() { }
 

trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp

@@ -589 +589 @@
     GraphicsLayer::syncPosition(point);
     // Ensure future flushes will recompute the coverage rect and update tiling.
-    noteLayerPropertyChanged(PositionChanged, DontScheduleFlush);
+    noteLayerPropertyChanged(NeedsComputeVisibleAndCoverageRect, DontScheduleFlush);
+}
+
+void GraphicsLayerCA::setApproximatePosition(const FloatPoint& point)
+{
+    if (point == m_approximatePosition)
+        return;
+
+    GraphicsLayer::setApproximatePosition(point);
+    // Ensure future flushes will recompute the coverage rect and update tiling.
+    noteLayerPropertyChanged(NeedsComputeVisibleAndCoverageRect, DontScheduleFlush);
 }
 
@@ -617 +627 @@
     GraphicsLayer::setBoundsOrigin(origin);
     noteLayerPropertyChanged(GeometryChanged);
+}
+
+void GraphicsLayerCA::syncBoundsOrigin(const FloatPoint& origin)
+{
+    if (origin == m_boundsOrigin)
+        return;
+
+    GraphicsLayer::syncBoundsOrigin(origin);
+    noteLayerPropertyChanged(NeedsComputeVisibleAndCoverageRect, DontScheduleFlush);
 }
 
@@ -1175 +1194 @@
 }
 
-void GraphicsLayerCA::flushCompositingState(const FloatRect& visibleRect, FlushScope flushScope)
+void GraphicsLayerCA::flushCompositingState(const FloatRect& visibleRect)
 {
     TransformState state(TransformState::UnapplyInverseTransformDirection, FloatQuad(visibleRect));
@@ -1182 +1201 @@
 
     CommitState commitState;
-    commitState.ancestorHadChanges = visibleRect != m_previousCommittedVisibleRect || flushScope == FlushScope::All;
+    commitState.ancestorHadChanges = visibleRect != m_previousCommittedVisibleRect;
     m_previousCommittedVisibleRect = visibleRect;
+
+#if PLATFORM(IOS)
+    // In WK1, UIKit may be changing layer bounds behind our back in overflow-scroll layers, so disable the optimization.
+    // See the similar test in computeVisibleAndCoverageRect().
+    if (m_layer->isPlatformCALayerCocoa())
+        commitState.ancestorHadChanges = true;
+#endif
 
     recursiveCommitChanges(commitState, state);

trunk/Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h

@@ -77 +77 @@
     WEBCORE_EXPORT void setPosition(const FloatPoint&) override;
     WEBCORE_EXPORT void syncPosition(const FloatPoint&) override;
+    WEBCORE_EXPORT void setApproximatePosition(const FloatPoint&) override;
     WEBCORE_EXPORT void setAnchorPoint(const FloatPoint3D&) override;
     WEBCORE_EXPORT void setSize(const FloatSize&) override;
     WEBCORE_EXPORT void setBoundsOrigin(const FloatPoint&) override;
+    WEBCORE_EXPORT void syncBoundsOrigin(const FloatPoint&) override;
 
     WEBCORE_EXPORT void setTransform(const TransformationMatrix&) override;
@@ -160 +162 @@
     void recursiveCommitChanges(const CommitState&, const TransformState&, float pageScaleFactor = 1, const FloatPoint& positionRelativeToBase = FloatPoint(), bool affectedByPageScale = false);
 
-    WEBCORE_EXPORT void flushCompositingState(const FloatRect&, FlushScope) override;
+    WEBCORE_EXPORT void flushCompositingState(const FloatRect&) override;
     WEBCORE_EXPORT void flushCompositingStateForThisLayerOnly() override;
 
@@ -497 +499 @@
         WindRuleChanged                         = 1LLU << 37,
         UserInteractionEnabledChanged           = 1LLU << 38,
-        PositionChanged                         = 1LLU << 39,
+        NeedsComputeVisibleAndCoverageRect      = 1LLU << 39,
     };
     typedef uint64_t LayerChangeFlags;

trunk/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.cpp

@@ -498 +498 @@
 }
 
-void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect& rect, FlushScope)
+void GraphicsLayerTextureMapper::flushCompositingState(const FloatRect& rect)
 {
     if (!m_layer.textureMapper())

trunk/Source/WebCore/platform/graphics/texmap/GraphicsLayerTextureMapper.h

@@ -84 +84 @@
     void setShowRepaintCounter(bool) override;
 
-    void flushCompositingState(const FloatRect&, FlushScope) override;
+    void flushCompositingState(const FloatRect&) override;
     void flushCompositingStateForThisLayerOnly() override;
 

trunk/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.cpp

@@ -573 +573 @@
 }
 
-void CoordinatedGraphicsLayer::flushCompositingState(const FloatRect& rect, FlushScope)
+void CoordinatedGraphicsLayer::flushCompositingState(const FloatRect& rect)
 {
     if (CoordinatedGraphicsLayer* mask = downcast<CoordinatedGraphicsLayer>(maskLayer()))

trunk/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedGraphicsLayer.h

@@ -101 +101 @@
     void setContentsNeedsDisplay() override;
     void deviceOrPageScaleFactorChanged() override;
-    void flushCompositingState(const FloatRect&, FlushScope) override;
+    void flushCompositingState(const FloatRect&) override;
     void flushCompositingStateForThisLayerOnly() override;
     bool setFilters(const FilterOperations&) override;

trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

@@ -453 +453 @@
 
         LOG_WITH_STREAM(Compositing,  stream << "\nRenderLayerCompositor " << this << " flushPendingLayerChanges(" << isFlushRoot << ") " << visibleRect);
-        rootLayer->flushCompositingState(visibleRect, GraphicsLayer::FlushScope::Uncommitted);
+        rootLayer->flushCompositingState(visibleRect);
         LOG_WITH_STREAM(Compositing,  stream << "RenderLayerCompositor " << this << " flush complete\n");
 #endif