Changeset 270557 in webkit

Timestamp:

Dec 8, 2020, 2:57:27 PM (5 years ago)

Author:

Simon Fraser

Message:

Make ScrollingPerformanceLoggingEnabled an internal debug preference
​https://bugs.webkit.org/show_bug.cgi?id=219647

Reviewed by Sam Weinig.

Source/WebCore:

ScrollingPerformanceLoggingEnabled is used by a Safari performance test, so it needs to be
easily toggleable from a script. That's easier if it's an Internal Debug preference.

Testing also sets ForceUpdateScrollbarsOnMainThreadForPerformanceTesting but we can just use
the ScrollingPerformanceLoggingEnabled flag, but it makes more sense to rename
ScrollingPerformanceLoggingEnabled to ScrollingPerformanceTestingEnabled when we do that.

Also fix how we propagate ScrollingPerformanceTestingEnabled to the scrolling tree;
do so via ScrollingStateFrameScrollingNode as we do for the other tree-wide settings,
removing code in TiledCoreAnimationDrawingArea::updatePreferences() that did this.

• page/FrameView.cpp:

(WebCore::FrameView::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):
(WebCore::FrameView::setScrollingPerformanceTestingEnabled):
(WebCore::FrameView::setScrollingPerformanceLoggingEnabled): Deleted.

• page/FrameView.h:
• page/SettingsBase.cpp:

(WebCore::SettingsBase::scrollingPerformanceTestingEnabledChanged):
(WebCore::SettingsBase::scrollingPerformanceLoggingEnabledChanged): Deleted.

• page/SettingsBase.h:
• page/scrolling/AsyncScrollingCoordinator.cpp:

(WebCore::AsyncScrollingCoordinator::setFrameScrollingNodeState):
(WebCore::AsyncScrollingCoordinator::asyncFrameOrOverflowScrollingEnabled const): Deleted.
(WebCore::AsyncScrollingCoordinator::wheelEventGesturesBecomeNonBlocking const): Deleted.

• page/scrolling/AsyncScrollingCoordinator.h:
• page/scrolling/ScrollingStateFrameScrollingNode.cpp:

(WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
(WebCore::ScrollingStateFrameScrollingNode::applicableProperties const):
(WebCore::ScrollingStateFrameScrollingNode::setScrollingPerformanceTestingEnabled):

• page/scrolling/ScrollingStateFrameScrollingNode.h:
• page/scrolling/ScrollingStateNode.h:
• page/scrolling/ScrollingTree.cpp:

(WebCore::ScrollingTree::commitTreeState):
(WebCore::ScrollingTree::setScrollingPerformanceLoggingEnabled): Deleted.
(WebCore::ScrollingTree::scrollingPerformanceLoggingEnabled): Deleted.

• page/scrolling/ScrollingTree.h:

(WebCore::ScrollingTree::scrollingPerformanceTestingEnabled const):
(WebCore::ScrollingTree::setScrollingPerformanceTestingEnabled):

• page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:

(WebCore::ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren):
(WebCore::ScrollingTreeFrameScrollingNodeMac::currentScrollPositionChanged):

• platform/graphics/TiledBacking.h:
• platform/graphics/ca/TileController.h:
• platform/graphics/ca/TileGrid.cpp:

(WebCore::TileGrid::platformCALayerPaintContents):

• rendering/RenderLayer.cpp:

(WebCore::RenderLayer::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):

• rendering/RenderLayerBacking.cpp:

(WebCore::RenderLayerBacking::RenderLayerBacking):

• rendering/RenderListBox.cpp:

(WebCore::RenderListBox::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):

Source/WebKit:

ScrollingPerformanceLoggingEnabled is used by a Safari performance test, so it needs to be
easily toggleable from a script. That's easier if it's an Internal Debug preference.

Testing also sets ForceUpdateScrollbarsOnMainThreadForPerformanceTesting but we can just use
the ScrollingPerformanceLoggingEnabled flag, but it makes more sense to rename
ScrollingPerformanceLoggingEnabled to ScrollingPerformanceTestingEnabled when we do that.

Also fix how we propagate ScrollingPerformanceTestingEnabled to the scrolling tree;
do so via ScrollingStateFrameScrollingNode as we do for the other tree-wide settings,
removing code in TiledCoreAnimationDrawingArea::updatePreferences() that did this.

• Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:

(ArgumentCoder<ScrollingStateFrameScrollingNode>::encode):
(ArgumentCoder<ScrollingStateFrameScrollingNode>::decode):

• UIProcess/API/C/WKPreferences.cpp:

(WKPreferencesSetScrollingPerformanceLoggingEnabled):
(WKPreferencesGetScrollingPerformanceLoggingEnabled):

• WebProcess/Plugins/PDF/PDFPlugin.mm:

(WebKit::PDFPlugin::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):

• WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

(WebKit::TiledCoreAnimationDrawingArea::updatePreferences):

Source/WTF:

Rename ScrollingPerformanceLoggingEnabled to ScrollingPerformanceTestingEnabled and make
it an Internal Debug preference.

Remove ForceUpdateScrollbarsOnMainThreadForPerformanceTesting.

• Scripts/Preferences/WebPreferences.yaml:
• Scripts/Preferences/WebPreferencesInternal.yaml:

Location:

trunk/Source

Files:

• WTF/ChangeLog (modified) (1 diff)
• WTF/Scripts/Preferences/WebPreferences.yaml (modified) (2 diffs)
• WTF/Scripts/Preferences/WebPreferencesInternal.yaml (modified) (1 diff)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/page/FrameView.cpp (modified) (3 diffs)
• WebCore/page/FrameView.h (modified) (1 diff)
• WebCore/page/PerformanceLoggingClient.h (modified) (1 diff)
• WebCore/page/SettingsBase.cpp (modified) (1 diff)
• WebCore/page/SettingsBase.h (modified) (1 diff)
• WebCore/page/scrolling/AsyncScrollingCoordinator.cpp (modified) (3 diffs)
• WebCore/page/scrolling/AsyncScrollingCoordinator.h (modified) (1 diff)
• WebCore/page/scrolling/ScrollingStateFrameScrollingNode.cpp (modified) (3 diffs)
• WebCore/page/scrolling/ScrollingStateFrameScrollingNode.h (modified) (2 diffs)
• WebCore/page/scrolling/ScrollingStateNode.h (modified) (1 diff)
• WebCore/page/scrolling/ScrollingTree.cpp (modified) (3 diffs)
• WebCore/page/scrolling/ScrollingTree.h (modified) (3 diffs)
• WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm (modified) (2 diffs)
• WebCore/platform/graphics/TiledBacking.h (modified) (1 diff)
• WebCore/platform/graphics/ca/TileController.h (modified) (3 diffs)
• WebCore/platform/graphics/ca/TileGrid.cpp (modified) (1 diff)
• WebCore/rendering/RenderLayer.cpp (modified) (1 diff)
• WebCore/rendering/RenderLayerBacking.cpp (modified) (1 diff)
• WebCore/rendering/RenderListBox.cpp (modified) (1 diff)
• WebKit/ChangeLog (modified) (1 diff)
• WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp (modified) (3 diffs)
• WebKit/UIProcess/API/C/WKPreferences.cpp (modified) (1 diff)
• WebKit/UIProcess/WebPageProxy.cpp (modified) (1 diff)
• WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm (modified) (1 diff)
• WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm (modified) (1 diff)

trunk/Source/WTF/ChangeLog ¶

@@ +1 @@
+2020-12-08  Simon Fraser  <simon.fraser@apple.com>
+
+        Make ScrollingPerformanceLoggingEnabled an internal debug preference
+        https://bugs.webkit.org/show_bug.cgi?id=219647
+
+        Reviewed by Sam Weinig.
+
+        Rename ScrollingPerformanceLoggingEnabled to ScrollingPerformanceTestingEnabled and make
+        it an Internal Debug preference.
+
+        Remove ForceUpdateScrollbarsOnMainThreadForPerformanceTesting.
+
+        * Scripts/Preferences/WebPreferences.yaml:
+        * Scripts/Preferences/WebPreferencesInternal.yaml:
+
 2020-12-08  Chris Dumez  <cdumez@apple.com>
 

trunk/Source/WTF/Scripts/Preferences/WebPreferences.yaml ¶

@@ -803 +803 @@
       default: false
 
-ForceUpdateScrollbarsOnMainThreadForPerformanceTesting:
-  type: bool
-  defaultValue:
-    WebKitLegacy:
-      default: false
-    WebKit:
-      default: false
-    WebCore:
-      default: false
-
 ForceWebGLUsesLowPower:
   type: bool
@@ -1847 +1837 @@
       default: true
 
-# FIXME: Is this implemented for WebKitLegacy? If not, this should be excluded from WebKitLegacy entirely (though we should still set the default value to false when initializing settings).
-ScrollingPerformanceLoggingEnabled:
-  type: bool
-  webcoreOnChange: scrollingPerformanceLoggingEnabledChanged
-  defaultValue:
-    WebKitLegacy:
-      default: false
-    WebKit:
-      default: false
-    WebCore:
-      default: false
-
 # FIXME: This is handled via WebView SPI rather than WebPreferences for WebKitLegacy. We should change the SPI to lookup the WebPreferences value instead.
 SelectTrailingWhitespaceEnabled:

trunk/Source/WTF/Scripts/Preferences/WebPreferencesInternal.yaml ¶

@@ -611 +611 @@
       default: true
 
+ScrollingPerformanceTestingEnabled:
+  type: bool
+  humanReadableName: "Scroll Performance Testing Enabled"
+  humanReadableDescription: "Enable behaviors used by scrolling performance tests"
+  webcoreOnChange: scrollingPerformanceTestingEnabledChanged
+  exposed: [ WebKit ]
+  defaultValue:
+    WebKitLegacy:
+      default: false
+    WebKit:
+      default: false
+    WebCore:
+      default: false
+
 SecureContextChecksEnabled:
   type: bool

trunk/Source/WebCore/ChangeLog ¶

@@ +1 @@
+2020-12-08  Simon Fraser  <simon.fraser@apple.com>
+
+        Make ScrollingPerformanceLoggingEnabled an internal debug preference
+        https://bugs.webkit.org/show_bug.cgi?id=219647
+
+        Reviewed by Sam Weinig.
+
+        ScrollingPerformanceLoggingEnabled is used by a Safari performance test, so it needs to be
+        easily toggleable from a script. That's easier if it's an Internal Debug preference.
+
+        Testing also sets ForceUpdateScrollbarsOnMainThreadForPerformanceTesting but we can just use
+        the ScrollingPerformanceLoggingEnabled flag, but it makes more sense to rename
+        ScrollingPerformanceLoggingEnabled to ScrollingPerformanceTestingEnabled when we do that.
+
+        Also fix how we propagate ScrollingPerformanceTestingEnabled to the scrolling tree;
+        do so via ScrollingStateFrameScrollingNode as we do for the other tree-wide settings,
+        removing code in TiledCoreAnimationDrawingArea::updatePreferences() that did this.
+
+        * page/FrameView.cpp:
+        (WebCore::FrameView::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):
+        (WebCore::FrameView::setScrollingPerformanceTestingEnabled):
+        (WebCore::FrameView::setScrollingPerformanceLoggingEnabled): Deleted.
+        * page/FrameView.h:
+        * page/SettingsBase.cpp:
+        (WebCore::SettingsBase::scrollingPerformanceTestingEnabledChanged):
+        (WebCore::SettingsBase::scrollingPerformanceLoggingEnabledChanged): Deleted.
+        * page/SettingsBase.h:
+        * page/scrolling/AsyncScrollingCoordinator.cpp:
+        (WebCore::AsyncScrollingCoordinator::setFrameScrollingNodeState):
+        (WebCore::AsyncScrollingCoordinator::asyncFrameOrOverflowScrollingEnabled const): Deleted.
+        (WebCore::AsyncScrollingCoordinator::wheelEventGesturesBecomeNonBlocking const): Deleted.
+        * page/scrolling/AsyncScrollingCoordinator.h:
+        * page/scrolling/ScrollingStateFrameScrollingNode.cpp:
+        (WebCore::ScrollingStateFrameScrollingNode::ScrollingStateFrameScrollingNode):
+        (WebCore::ScrollingStateFrameScrollingNode::applicableProperties const):
+        (WebCore::ScrollingStateFrameScrollingNode::setScrollingPerformanceTestingEnabled):
+        * page/scrolling/ScrollingStateFrameScrollingNode.h:
+        * page/scrolling/ScrollingStateNode.h:
+        * page/scrolling/ScrollingTree.cpp:
+        (WebCore::ScrollingTree::commitTreeState):
+        (WebCore::ScrollingTree::setScrollingPerformanceLoggingEnabled): Deleted.
+        (WebCore::ScrollingTree::scrollingPerformanceLoggingEnabled): Deleted.
+        * page/scrolling/ScrollingTree.h:
+        (WebCore::ScrollingTree::scrollingPerformanceTestingEnabled const):
+        (WebCore::ScrollingTree::setScrollingPerformanceTestingEnabled):
+        * page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm:
+        (WebCore::ScrollingTreeFrameScrollingNodeMac::commitStateBeforeChildren):
+        (WebCore::ScrollingTreeFrameScrollingNodeMac::currentScrollPositionChanged):
+        * platform/graphics/TiledBacking.h:
+        * platform/graphics/ca/TileController.h:
+        * platform/graphics/ca/TileGrid.cpp:
+        (WebCore::TileGrid::platformCALayerPaintContents):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::RenderLayerBacking):
+        * rendering/RenderListBox.cpp:
+        (WebCore::RenderListBox::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):
+
 2020-12-08  Wenson Hsieh  <wenson_hsieh@apple.com>
 

trunk/Source/WebCore/page/FrameView.cpp ¶

@@ -73 +73 @@
 #include "Page.h"
 #include "PageOverlayController.h"
+#include "PerformanceLoggingClient.h"
 #include "ProgressTracker.h"
 #include "Quirks.h"
@@ -3747 +3748 @@
 {
     Page* page = frame().page();
-    return page && page->settings().forceUpdateScrollbarsOnMainThreadForPerformanceTesting();
+    return page && page->settings().scrollingPerformanceTestingEnabled();
 }
 
@@ -5213 +5214 @@
 #endif // PLATFORM(IOS_FAMILY)
 
-void FrameView::setScrollingPerformanceLoggingEnabled(bool flag)
-{
+void FrameView::setScrollingPerformanceTestingEnabled(bool scrollingPerformanceTestingEnabled)
+{
+    if (scrollingPerformanceTestingEnabled) {
+        auto* page = frame().page();
+        if (page && page->performanceLoggingClient())
+            page->performanceLoggingClient()->logScrollingEvent(PerformanceLoggingClient::ScrollingEvent::LoggingEnabled, MonotonicTime::now(), 0);
+    }
+
     if (TiledBacking* tiledBacking = this->tiledBacking())
-        tiledBacking->setScrollingPerformanceLoggingEnabled(flag);
+        tiledBacking->setScrollingPerformanceTestingEnabled(scrollingPerformanceTestingEnabled);
 }
 

trunk/Source/WebCore/page/FrameView.h ¶

@@ -568 +568 @@
     bool handleWheelEventForScrolling(const PlatformWheelEvent&, Optional<WheelScrollGestureState>) final;
 
-    WEBCORE_EXPORT void setScrollingPerformanceLoggingEnabled(bool);
+    WEBCORE_EXPORT void setScrollingPerformanceTestingEnabled(bool);
 
     // Page and FrameView both store a Pagination value. Page::pagination() is set only by API,

trunk/Source/WebCore/page/PerformanceLoggingClient.h ¶

@@ -38 +38 @@
 public:
     enum class ScrollingEvent {
+        LoggingEnabled,
         ExposedTilelessArea,
         FilledTile,

trunk/Source/WebCore/page/SettingsBase.cpp ¶

@@ -340 +340 @@
 }
 
-void SettingsBase::scrollingPerformanceLoggingEnabledChanged()
+void SettingsBase::scrollingPerformanceTestingEnabledChanged()
 {
     if (m_page && m_page->mainFrame().view())
-        m_page->mainFrame().view()->setScrollingPerformanceLoggingEnabled(m_page->settings().scrollingPerformanceLoggingEnabled());
+        m_page->mainFrame().view()->setScrollingPerformanceTestingEnabled(m_page->settings().scrollingPerformanceTestingEnabled());
 }
 

trunk/Source/WebCore/page/SettingsBase.h ¶

@@ -126 +126 @@
     void storageBlockingPolicyChanged();
     void backgroundShouldExtendBeyondPageChanged();
-    void scrollingPerformanceLoggingEnabledChanged();
+    void scrollingPerformanceTestingEnabledChanged();
     void hiddenPageDOMTimerThrottlingStateChanged();
     void hiddenPageCSSAnimationSuspensionEnabledChanged();

trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.cpp ¶

@@ -646 +646 @@
         return;
 
+    auto& settings = m_page->mainFrame().settings();
     auto& frameScrollingNode = downcast<ScrollingStateFrameScrollingNode>(*stateNode);
 
@@ -653 +654 @@
     frameScrollingNode.setTopContentInset(frameView.topContentInset());
     frameScrollingNode.setLayoutViewport(frameView.layoutViewportRect());
-    frameScrollingNode.setAsyncFrameOrOverflowScrollingEnabled(asyncFrameOrOverflowScrollingEnabled());
-    frameScrollingNode.setWheelEventGesturesBecomeNonBlocking(wheelEventGesturesBecomeNonBlocking());
+    frameScrollingNode.setAsyncFrameOrOverflowScrollingEnabled(settings.asyncFrameScrollingEnabled() || settings.asyncOverflowScrollingEnabled());
+    frameScrollingNode.setScrollingPerformanceTestingEnabled(settings.scrollingPerformanceTestingEnabled());
+    frameScrollingNode.setWheelEventGesturesBecomeNonBlocking(settings.wheelEventGesturesBecomeNonBlocking());
 
     frameScrollingNode.setMinLayoutViewportOrigin(frameView.minStableLayoutViewportOrigin());
@@ -832 +834 @@
 }
 
-bool AsyncScrollingCoordinator::asyncFrameOrOverflowScrollingEnabled() const
-{
-    auto& settings = m_page->mainFrame().settings();
-    return settings.asyncFrameScrollingEnabled() || settings.asyncOverflowScrollingEnabled();
-}
-
-bool AsyncScrollingCoordinator::wheelEventGesturesBecomeNonBlocking() const
-{
-    auto& settings = m_page->mainFrame().settings();
-    return settings.wheelEventGesturesBecomeNonBlocking();
-}
-
 ScrollingNodeID AsyncScrollingCoordinator::scrollableContainerNodeID(const RenderObject& renderer) const
 {

trunk/Source/WebCore/page/scrolling/AsyncScrollingCoordinator.h ¶

@@ -95 +95 @@
 
     bool hasVisibleSlowRepaintViewportConstrainedObjects(const FrameView&) const override { return false; }
-    
-    bool asyncFrameOrOverflowScrollingEnabled() const;
-    bool wheelEventGesturesBecomeNonBlocking() const;
 
     WEBCORE_EXPORT ScrollingNodeID scrollableContainerNodeID(const RenderObject&) const override;

trunk/Source/WebCore/page/scrolling/ScrollingStateFrameScrollingNode.cpp ¶

@@ -61 +61 @@
     , m_asyncFrameOrOverflowScrollingEnabled(stateNode.asyncFrameOrOverflowScrollingEnabled())
     , m_wheelEventGesturesBecomeNonBlocking(stateNode.wheelEventGesturesBecomeNonBlocking())
+    , m_scrollingPerformanceTestingEnabled(stateNode.scrollingPerformanceTestingEnabled())
 {
     if (hasChangedProperty(Property::RootContentsLayer))
@@ -107 +108 @@
         Property::AsyncFrameOrOverflowScrollingEnabled,
         Property::WheelEventGesturesBecomeNonBlocking,
+        Property::ScrollingPerformanceTestingEnabled,
         Property::LayoutViewport,
         Property::MinLayoutViewportOrigin,
@@ -297 +299 @@
     m_wheelEventGesturesBecomeNonBlocking = enabled;
     setPropertyChanged(Property::WheelEventGesturesBecomeNonBlocking);
+}
+
+void ScrollingStateFrameScrollingNode::setScrollingPerformanceTestingEnabled(bool enabled)
+{
+    if (enabled == m_scrollingPerformanceTestingEnabled)
+        return;
+    
+    m_scrollingPerformanceTestingEnabled = enabled;
+    setPropertyChanged(Property::ScrollingPerformanceTestingEnabled);
 }
 

trunk/Source/WebCore/page/scrolling/ScrollingStateFrameScrollingNode.h ¶

@@ -112 +112 @@
     void setAsyncFrameOrOverflowScrollingEnabled(bool);
 
+    bool scrollingPerformanceTestingEnabled() const { return m_scrollingPerformanceTestingEnabled; }
+    WEBCORE_EXPORT void setScrollingPerformanceTestingEnabled(bool);
+
     bool wheelEventGesturesBecomeNonBlocking() const { return m_wheelEventGesturesBecomeNonBlocking; }
     WEBCORE_EXPORT void setWheelEventGesturesBecomeNonBlocking(bool);
@@ -146 +149 @@
     bool m_asyncFrameOrOverflowScrollingEnabled { false };
     bool m_wheelEventGesturesBecomeNonBlocking { false };
+    bool m_scrollingPerformanceTestingEnabled { false };
 };
 

trunk/Source/WebCore/page/scrolling/ScrollingStateNode.h ¶

@@ -260 +260 @@
         AsyncFrameOrOverflowScrollingEnabled        = 1LLU << 36,
         WheelEventGesturesBecomeNonBlocking         = 1LLU << 37,
-        LayoutViewport                              = 1LLU << 38,
-        MinLayoutViewportOrigin                     = 1LLU << 39,
-        MaxLayoutViewportOrigin                     = 1LLU << 40,
-        OverrideVisualViewportSize                  = 1LLU << 41,
+        ScrollingPerformanceTestingEnabled          = 1LLU << 38,
+        LayoutViewport                              = 1LLU << 39,
+        MinLayoutViewportOrigin                     = 1LLU << 40,
+        MaxLayoutViewportOrigin                     = 1LLU << 41,
+        OverrideVisualViewportSize                  = 1LLU << 42,
         // ScrollingStatePositionedNode
-        RelatedOverflowScrollingNodes               = 1LLU << 42,
-        LayoutConstraintData                        = 1LLU << 43,
+        RelatedOverflowScrollingNodes               = 1LLU << 43,
+        LayoutConstraintData                        = 1LLU << 44,
         // ScrollingStateFixedNode, ScrollingStateStickyNode
-        ViewportConstraints                         = 1LLU << 44,
+        ViewportConstraints                         = 1LLU << 45,
         // ScrollingStateOverflowScrollProxyNode
-        OverflowScrollingNode                       = 1LLU << 45,
+        OverflowScrollingNode                       = 1LLU << 46,
     };
     

trunk/Source/WebCore/page/scrolling/ScrollingTree.cpp ¶

@@ -273 +273 @@
             || rootNode->hasChangedProperty(ScrollingStateNode::Property::AsyncFrameOrOverflowScrollingEnabled)
             || rootNode->hasChangedProperty(ScrollingStateNode::Property::WheelEventGesturesBecomeNonBlocking)
+            || rootNode->hasChangedProperty(ScrollingStateNode::Property::ScrollingPerformanceTestingEnabled)
             || rootNode->hasChangedProperty(ScrollingStateNode::Property::IsMonitoringWheelEvents))) {
         LockHolder lock(m_treeStateMutex);
@@ -287 +288 @@
         if (rootStateNodeChanged || rootNode->hasChangedProperty(ScrollingStateNode::Property::WheelEventGesturesBecomeNonBlocking))
             m_wheelEventGesturesBecomeNonBlocking = scrollingStateTree->rootStateNode()->wheelEventGesturesBecomeNonBlocking();
+
+        if (rootStateNodeChanged || rootNode->hasChangedProperty(ScrollingStateNode::Property::ScrollingPerformanceTestingEnabled))
+            m_scrollingPerformanceTestingEnabled = scrollingStateTree->rootStateNode()->scrollingPerformanceTestingEnabled();
 
         if (rootStateNodeChanged || rootNode->hasChangedProperty(ScrollingStateNode::Property::IsMonitoringWheelEvents))
@@ -697 +701 @@
 }
 
-void ScrollingTree::setScrollingPerformanceLoggingEnabled(bool flag)
-{
-    m_scrollingPerformanceLoggingEnabled = flag;
-}
-
-bool ScrollingTree::scrollingPerformanceLoggingEnabled()
-{
-    return m_scrollingPerformanceLoggingEnabled;
-}
-
 String ScrollingTree::scrollingTreeAsText(ScrollingStateTreeAsTextBehavior behavior)
 {

trunk/Source/WebCore/page/scrolling/ScrollingTree.h ¶

@@ -96 +96 @@
     void setWheelEventGesturesBecomeNonBlocking(bool value) { m_wheelEventGesturesBecomeNonBlocking = value; }
 
+    bool scrollingPerformanceTestingEnabled() const { return m_scrollingPerformanceTestingEnabled; }
+    void setScrollingPerformanceTestingEnabled(bool value) { m_scrollingPerformanceTestingEnabled = value; }
+
     WEBCORE_EXPORT OptionSet<WheelEventProcessingSteps> determineWheelEventProcessing(const PlatformWheelEvent&);
     WEBCORE_EXPORT virtual WheelEventHandlingResult handleWheelEvent(const PlatformWheelEvent&, OptionSet<WheelEventProcessingSteps> = { });
@@ -178 +181 @@
 
     WEBCORE_EXPORT bool willWheelEventStartSwipeGesture(const PlatformWheelEvent&);
-
-    WEBCORE_EXPORT void setScrollingPerformanceLoggingEnabled(bool flag);
-    bool scrollingPerformanceLoggingEnabled();
 
     ScrollingTreeFrameScrollingNode* rootNode() const { return m_rootNode.get(); }
@@ -329 +329 @@
     bool m_isHandlingProgrammaticScroll { false };
     bool m_isMonitoringWheelEvents { false };
-    bool m_scrollingPerformanceLoggingEnabled { false };
+    bool m_scrollingPerformanceTestingEnabled { false };
     bool m_asyncFrameOrOverflowScrollingEnabled { false };
     bool m_wheelEventGesturesBecomeNonBlocking { false };

trunk/Source/WebCore/page/scrolling/mac/ScrollingTreeFrameScrollingNodeMac.mm ¶

@@ -91 +91 @@
         logScrollingMode = true;
 
-    if (logScrollingMode && isRootNode() && scrollingTree().scrollingPerformanceLoggingEnabled())
+    if (logScrollingMode && isRootNode() && scrollingTree().scrollingPerformanceTestingEnabled())
         scrollingTree().reportSynchronousScrollingReasonsChanged(MonotonicTime::now(), synchronousScrollingReasons());
 
@@ -156 +156 @@
     ScrollingTreeFrameScrollingNode::currentScrollPositionChanged(scrollType, hasSynchronousScrollingReasons() ? ScrollingLayerPositionAction::Set : action);
 
-    if (scrollingTree().scrollingPerformanceLoggingEnabled()) {
+    if (scrollingTree().scrollingPerformanceTestingEnabled()) {
         unsigned unfilledArea = exposedUnfilledArea();
         if (unfilledArea || m_lastScrollHadUnfilledPixels)

trunk/Source/WebCore/platform/graphics/TiledBacking.h ¶

@@ -107 +107 @@
     virtual void forceRepaint() = 0;
 
-    virtual void setScrollingPerformanceLoggingEnabled(bool) = 0;
-    virtual bool scrollingPerformanceLoggingEnabled() const = 0;
+    virtual void setScrollingPerformanceTestingEnabled(bool) = 0;
+    virtual bool scrollingPerformanceTestingEnabled() const = 0;
     
     virtual double retainedTileBackingStoreMemory() const = 0;

trunk/Source/WebCore/platform/graphics/ca/TileController.h ¶

@@ -126 +126 @@
     FloatRect adjustTileCoverageRectForScrolling(const FloatRect& coverageRect, const FloatSize& newSize, const FloatRect& previousVisibleRect, const FloatRect& currentVisibleRect, float contentsScale) final;
 
-    bool scrollingPerformanceLoggingEnabled() const final { return m_scrollingPerformanceLoggingEnabled; }
+    bool scrollingPerformanceTestingEnabled() const final { return m_scrollingPerformanceTestingEnabled; }
 
     IntSize computeTileSize();
@@ -170 +170 @@
     void forceRepaint() final;
     IntRect tileGridExtent() const final;
-    void setScrollingPerformanceLoggingEnabled(bool flag) final { m_scrollingPerformanceLoggingEnabled = flag; }
+    void setScrollingPerformanceTestingEnabled(bool flag) final { m_scrollingPerformanceTestingEnabled = flag; }
     double retainedTileBackingStoreMemory() const final;
     IntRect tileCoverageRect() const final;
@@ -237 +237 @@
     
     bool m_isInWindow { false };
-    bool m_scrollingPerformanceLoggingEnabled { false };
+    bool m_scrollingPerformanceTestingEnabled { false };
     bool m_acceleratesDrawing { false };
     bool m_wantsDeepColorBackingStore { false };

trunk/Source/WebCore/platform/graphics/ca/TileGrid.cpp ¶

@@ -738 +738 @@
         PlatformCALayer::drawRepaintIndicator(context, platformCALayer, repaintCount, m_controller.tileDebugBorderColor());
 
-    if (m_controller.scrollingPerformanceLoggingEnabled()) {
+    if (m_controller.scrollingPerformanceTestingEnabled()) {
         FloatRect visiblePart(platformCALayer->position().x(), platformCALayer->position().y(), platformCALayer->bounds().size().width(), platformCALayer->bounds().size().height());
         visiblePart.intersect(m_controller.visibleRect());

trunk/Source/WebCore/rendering/RenderLayer.cpp ¶

@@ -1924 +1924 @@
 bool RenderLayer::forceUpdateScrollbarsOnMainThreadForPerformanceTesting() const
 {
-    return renderer().settings().forceUpdateScrollbarsOnMainThreadForPerformanceTesting();
+    return renderer().settings().scrollingPerformanceTestingEnabled();
 }
 

trunk/Source/WebCore/rendering/RenderLayerBacking.cpp ¶

@@ -228 +228 @@
 
         if (m_isFrameLayerWithTiledBacking) {
-            tiledBacking->setScrollingPerformanceLoggingEnabled(renderer().settings().scrollingPerformanceLoggingEnabled());
+            tiledBacking->setScrollingPerformanceTestingEnabled(renderer().settings().scrollingPerformanceTestingEnabled());
             adjustTiledBackingCoverage();
         }

trunk/Source/WebCore/rendering/RenderListBox.cpp ¶

@@ -874 +874 @@
 bool RenderListBox::forceUpdateScrollbarsOnMainThreadForPerformanceTesting() const
 {
-    return settings().forceUpdateScrollbarsOnMainThreadForPerformanceTesting();
+    return settings().scrollingPerformanceTestingEnabled();
 }
 

trunk/Source/WebKit/ChangeLog ¶

@@ +1 @@
+2020-12-08  Simon Fraser  <simon.fraser@apple.com>
+
+        Make ScrollingPerformanceLoggingEnabled an internal debug preference
+        https://bugs.webkit.org/show_bug.cgi?id=219647
+
+        Reviewed by Sam Weinig.
+
+        ScrollingPerformanceLoggingEnabled is used by a Safari performance test, so it needs to be
+        easily toggleable from a script. That's easier if it's an Internal Debug preference.
+
+        Testing also sets ForceUpdateScrollbarsOnMainThreadForPerformanceTesting but we can just use
+        the ScrollingPerformanceLoggingEnabled flag, but it makes more sense to rename
+        ScrollingPerformanceLoggingEnabled to ScrollingPerformanceTestingEnabled when we do that.
+
+        Also fix how we propagate ScrollingPerformanceTestingEnabled to the scrolling tree;
+        do so via ScrollingStateFrameScrollingNode as we do for the other tree-wide settings,
+        removing code in TiledCoreAnimationDrawingArea::updatePreferences() that did this.
+
+        * Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp:
+        (ArgumentCoder<ScrollingStateFrameScrollingNode>::encode):
+        (ArgumentCoder<ScrollingStateFrameScrollingNode>::decode):
+        * UIProcess/API/C/WKPreferences.cpp:
+        (WKPreferencesSetScrollingPerformanceLoggingEnabled):
+        (WKPreferencesGetScrollingPerformanceLoggingEnabled):
+        * WebProcess/Plugins/PDF/PDFPlugin.mm:
+        (WebKit::PDFPlugin::forceUpdateScrollbarsOnMainThreadForPerformanceTesting const):
+        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
+        (WebKit::TiledCoreAnimationDrawingArea::updatePreferences):
+
 2020-12-08  Per Arne Vollan  <pvollan@apple.com>
 

trunk/Source/WebKit/Shared/RemoteLayerTree/RemoteScrollingCoordinatorTransaction.cpp ¶

@@ -144 +144 @@
         WebCore::ScrollingStateNode::Property::AsyncFrameOrOverflowScrollingEnabled,
         WebCore::ScrollingStateNode::Property::WheelEventGesturesBecomeNonBlocking,
+        WebCore::ScrollingStateNode::Property::ScrollingPerformanceTestingEnabled,
         WebCore::ScrollingStateNode::Property::LayoutViewport,
         WebCore::ScrollingStateNode::Property::MinLayoutViewportOrigin,
@@ -244 +245 @@
     // AsyncFrameOrOverflowScrollingEnabled is not relevant for UI-side compositing.
     SCROLLING_NODE_ENCODE(ScrollingStateNode::Property::WheelEventGesturesBecomeNonBlocking, wheelEventGesturesBecomeNonBlocking)
+    SCROLLING_NODE_ENCODE(ScrollingStateNode::Property::ScrollingPerformanceTestingEnabled, scrollingPerformanceTestingEnabled)
     SCROLLING_NODE_ENCODE(ScrollingStateNode::Property::LayoutViewport, layoutViewport)
     SCROLLING_NODE_ENCODE(ScrollingStateNode::Property::MinLayoutViewportOrigin, minLayoutViewportOrigin)
@@ -362 +364 @@
     // AsyncFrameOrOverflowScrollingEnabled is not encoded.
     SCROLLING_NODE_DECODE(ScrollingStateNode::Property::WheelEventGesturesBecomeNonBlocking, bool, setWheelEventGesturesBecomeNonBlocking)
+    SCROLLING_NODE_DECODE(ScrollingStateNode::Property::ScrollingPerformanceTestingEnabled, bool, setScrollingPerformanceTestingEnabled)
     SCROLLING_NODE_DECODE(ScrollingStateNode::Property::LayoutViewport, FloatRect, setLayoutViewport)
     SCROLLING_NODE_DECODE(ScrollingStateNode::Property::MinLayoutViewportOrigin, FloatPoint, setMinLayoutViewportOrigin)

trunk/Source/WebKit/UIProcess/API/C/WKPreferences.cpp ¶

@@ -1059 +1059 @@
 void WKPreferencesSetScrollingPerformanceLoggingEnabled(WKPreferencesRef preferencesRef, bool enabled)
 {
-    toImpl(preferencesRef)->setScrollingPerformanceLoggingEnabled(enabled);
+    toImpl(preferencesRef)->setScrollingPerformanceTestingEnabled(enabled);
 }
 
 bool WKPreferencesGetScrollingPerformanceLoggingEnabled(WKPreferencesRef preferencesRef)
 {
-    return toImpl(preferencesRef)->scrollingPerformanceLoggingEnabled();
+    return toImpl(preferencesRef)->scrollingPerformanceTestingEnabled();
 }
 

trunk/Source/WebKit/UIProcess/WebPageProxy.cpp ¶

@@ -7264 +7264 @@
 
     switch (event) {
+    case PerformanceLoggingClient::ScrollingEvent::LoggingEnabled:
+        WTFLogAlways("SCROLLING: ScrollingPerformanceTestingEnabled\n");
+        break;
     case PerformanceLoggingClient::ScrollingEvent::ExposedTilelessArea:
         WTFLogAlways("SCROLLING: Exposed tileless area. Time: %f Unfilled Pixels: %llu\n", timestamp.secondsSinceEpoch().value(), (unsigned long long)data);

trunk/Source/WebKit/WebProcess/Plugins/PDF/PDFPlugin.mm ¶

@@ -1458 +1458 @@
     if (auto* coreFrame = m_frame ? m_frame->coreFrame() : nullptr) {
         if (auto* page = coreFrame->page())
-            return page->settings().forceUpdateScrollbarsOnMainThreadForPerformanceTesting();
+            return page->settings().scrollingPerformanceTestingEnabled();
     }
 

trunk/Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm ¶

@@ -220 +220 @@
     Settings& settings = m_webPage.corePage()->settings();
 
-#if ENABLE(ASYNC_SCROLLING)
-    if (AsyncScrollingCoordinator* scrollingCoordinator = downcast<AsyncScrollingCoordinator>(m_webPage.corePage()->scrollingCoordinator())) {
-        bool scrollingPerformanceLoggingEnabled = store.getBoolValueForKey(WebPreferencesKey::scrollingPerformanceLoggingEnabledKey());
-        
-        RefPtr<ScrollingTree> scrollingTree = scrollingCoordinator->scrollingTree();
-        ScrollingThread::dispatch([scrollingTree, scrollingPerformanceLoggingEnabled] {
-            scrollingTree->setScrollingPerformanceLoggingEnabled(scrollingPerformanceLoggingEnabled);
-        });
-    }
-#endif
-
     // Fixed position elements need to be composited and create stacking contexts
     // in order to be scrolled by the ScrollingCoordinator.