Unreviewed, rolling out r253299.
authortsavell@apple.com <tsavell@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Dec 2019 00:47:10 +0000 (00:47 +0000)
committertsavell@apple.com <tsavell@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Dec 2019 00:47:10 +0000 (00:47 +0000)
Casued 30+ imported/ test failures on Mac wk2

Reverted changeset:

"Throttling requestAnimationFrame should be controlled by
RenderingUpdateScheduler"
https://bugs.webkit.org/show_bug.cgi?id=204713
https://trac.webkit.org/changeset/253299

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@253308 268f45cc-cd09-0410-ab3c-d52691b4dbfc

33 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/animation/request-animation-frame-throttling-lowPowerMode-expected.txt
LayoutTests/fast/animation/request-animation-frame-throttling-lowPowerMode.html
LayoutTests/fast/animation/request-animation-frame-throttling-outside-viewport-expected.txt [deleted file]
LayoutTests/fast/animation/request-animation-frame-throttling-outside-viewport.html [deleted file]
LayoutTests/fast/animation/resources/frame-with-animation-2.html [deleted file]
Source/WebCore/ChangeLog
Source/WebCore/Headers.cmake
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/animation/DocumentTimeline.cpp
Source/WebCore/animation/DocumentTimeline.h
Source/WebCore/dom/Document.cpp
Source/WebCore/dom/ScriptedAnimationController.cpp
Source/WebCore/dom/ScriptedAnimationController.h
Source/WebCore/page/FrameView.cpp
Source/WebCore/page/Page.cpp
Source/WebCore/page/Page.h
Source/WebCore/page/RenderingUpdateScheduler.cpp
Source/WebCore/page/RenderingUpdateScheduler.h
Source/WebCore/platform/graphics/AnimationFrameRate.h [deleted file]
Source/WebCore/platform/graphics/DisplayRefreshMonitor.h
Source/WebCore/platform/graphics/DisplayRefreshMonitorManager.cpp
Source/WebCore/platform/graphics/DisplayRefreshMonitorManager.h
Source/WebCore/platform/graphics/GraphicsLayerUpdater.cpp
Source/WebCore/platform/graphics/ios/DisplayRefreshMonitorIOS.mm
Source/WebKit/ChangeLog
Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.h
Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.messages.in
Source/WebKit/UIProcess/RemoteLayerTree/RemoteLayerTreeDrawingAreaProxy.mm
Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDisplayRefreshMonitor.h
Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDisplayRefreshMonitor.mm
Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h
Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm

index ab10390..50c3473 100644 (file)
@@ -1,3 +1,16 @@
+2019-12-09  Truitt Savell  <tsavell@apple.com>
+
+        Unreviewed, rolling out r253299.
+
+        Casued 30+ imported/ test failures on Mac wk2
+
+        Reverted changeset:
+
+        "Throttling requestAnimationFrame should be controlled by
+        RenderingUpdateScheduler"
+        https://bugs.webkit.org/show_bug.cgi?id=204713
+        https://trac.webkit.org/changeset/253299
+
 2019-12-09  Wenson Hsieh  <wenson_hsieh@apple.com>
 
         Finish encoding/decoding support for DisplayList::SetState
index 353c21e..9833ffb 100644 (file)
@@ -3,7 +3,23 @@ Test that requestAnimationFrame gets throttled in low power mode.
 On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
 
 
-PASS farmesPerSecond < 35 is true
+PASS internals.isRequestAnimationFrameThrottled() is false
+PASS internals.requestAnimationFrameInterval is Infinity
+rAFHandle = requestAnimationFrame(doWork);
+PASS internals.isRequestAnimationFrameThrottled() is false
+PASS internals.requestAnimationFrameInterval is 0.015
+internals.setLowPowerModeEnabled(true);
+PASS internals.isRequestAnimationFrameThrottled() is true
+PASS internals.requestAnimationFrameInterval is 0.030
+cancelAnimationFrame(rAFHandle);
+PASS internals.isRequestAnimationFrameThrottled() is true
+PASS internals.requestAnimationFrameInterval is 0.030
+rAFHandle = requestAnimationFrame(doWork);
+PASS internals.isRequestAnimationFrameThrottled() is true
+PASS internals.requestAnimationFrameInterval is 0.030
+internals.setLowPowerModeEnabled(false);
+PASS internals.isRequestAnimationFrameThrottled() is false
+PASS internals.requestAnimationFrameInterval is 0.015
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 7ad4b8f..dbae09f 100644 (file)
@@ -1,32 +1,36 @@
 <!DOCTYPE html>
 <html>
 <body>
-    <script src="../../resources/js-test-pre.js"></script>
-    <script>
-        description("Test that requestAnimationFrame gets throttled in low power mode.");
+<script src="../../resources/js-test-pre.js"></script>
+<script>
+description("Test that requestAnimationFrame gets throttled in low power mode.");
 
-        window.jsTestIsAsync = true;
+let rAFHandle;
+let i = 0;
+function doWork()
+{
+    i++;
+    rAFHandle = requestAnimationFrame(doWork);
+}
 
-        if (window.internals)
-            internals.setLowPowerModeEnabled(true);
-
-        var start = null;
-        var farmesPerSecond = 0;
-        function doWork(timestamp) {
-            if (!start)
-                start = timestamp;
-            if (timestamp - start < 1000) {
-                ++farmesPerSecond;
-                window.requestAnimationFrame(doWork);
-            }
-            else {
-                // The LowPowerMode throttling interval = 30_ms. The frame rate ~= 33.3 fps.
-                shouldBeTrue("farmesPerSecond < 35");
-                finishJSTest();
-            }
-        }
-        window.requestAnimationFrame(doWork);
-    </script>
-    <script src="../../resources/js-test-post.js"></script>
+shouldBeFalse("internals.isRequestAnimationFrameThrottled()");
+shouldBe("internals.requestAnimationFrameInterval", "Infinity");
+evalAndLog("rAFHandle = requestAnimationFrame(doWork);");
+shouldBeFalse("internals.isRequestAnimationFrameThrottled()");
+shouldBe("internals.requestAnimationFrameInterval", "0.015");
+evalAndLog("internals.setLowPowerModeEnabled(true);");
+shouldBeTrue("internals.isRequestAnimationFrameThrottled()");
+shouldBe("internals.requestAnimationFrameInterval", "0.030");
+evalAndLog("cancelAnimationFrame(rAFHandle);");
+shouldBeTrue("internals.isRequestAnimationFrameThrottled()");
+shouldBe("internals.requestAnimationFrameInterval", "0.030");
+evalAndLog("rAFHandle = requestAnimationFrame(doWork);");
+shouldBeTrue("internals.isRequestAnimationFrameThrottled()");
+shouldBe("internals.requestAnimationFrameInterval", "0.030");
+evalAndLog("internals.setLowPowerModeEnabled(false);");
+shouldBeFalse("internals.isRequestAnimationFrameThrottled()");
+shouldBe("internals.requestAnimationFrameInterval", "0.015");
+</script>
+<script src="../../resources/js-test-post.js"></script>
 </body>
 </html>
diff --git a/LayoutTests/fast/animation/request-animation-frame-throttling-outside-viewport-expected.txt b/LayoutTests/fast/animation/request-animation-frame-throttling-outside-viewport-expected.txt
deleted file mode 100644 (file)
index 4183863..0000000
+++ /dev/null
@@ -1,11 +0,0 @@
-Test that requestAnimationFrame gets the right throttling in an iframe when when it's outside the viewport.
-
-On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
-
-
-PASS farmesPerSecond > 0 is true
-PASS ifarmeFarmesPerSecond == 0 is true
-PASS successfullyParsed is true
-
-TEST COMPLETE
-
diff --git a/LayoutTests/fast/animation/request-animation-frame-throttling-outside-viewport.html b/LayoutTests/fast/animation/request-animation-frame-throttling-outside-viewport.html
deleted file mode 100644 (file)
index 7f55cd8..0000000
+++ /dev/null
@@ -1,45 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-    <div style="height: 1000px;"></div>
-    <script src="../../resources/js-test-pre.js"></script>
-    <script>
-        description("Test that requestAnimationFrame gets the right throttling in an iframe when when it's outside the viewport.");
-        jsTestIsAsync = true;
-
-        var farmesPerSecond = 0;
-        var ifarmeFarmesPerSecond = 0;
-
-        window.onmessage = function(e){
-            if (e.data == 'subFrameRAFMessage') {
-                ++ifarmeFarmesPerSecond;
-            }
-        };
-
-        const frame = document.createElement("iframe");
-        frame.src = "resources/frame-with-animation-2.html";
-        frame.onload = function() {
-            var start = null;
-            function doWork(timestamp) {
-                if (!start)
-                    start = timestamp;
-                if (timestamp - start < 1000) {
-                    ++farmesPerSecond;
-                    window.requestAnimationFrame(doWork);
-                }
-                else {
-                    shouldBeTrue("farmesPerSecond > 0");
-
-                    // The OutsideViewport throttling = 10_s. subFrameRAFMessage
-                    // should not ever be received during the first second.
-                    shouldBeTrue("ifarmeFarmesPerSecond == 0");
-                    finishJSTest();
-                }
-            }
-            window.requestAnimationFrame(doWork);
-        }
-        document.body.appendChild(frame);
-    </script>
-    <script src="../../resources/js-test-post.js"></script>
-</body>
-</html>
diff --git a/LayoutTests/fast/animation/resources/frame-with-animation-2.html b/LayoutTests/fast/animation/resources/frame-with-animation-2.html
deleted file mode 100644 (file)
index 883fc0e..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-<script>
-       function doWork(timestamp) {
-               window.top.postMessage('subFrameRAFMessage', '*');
-               window.requestAnimationFrame(doWork);
-       }
-       window.requestAnimationFrame(doWork);
-</script>
index 6ad8b44..7448554 100644 (file)
@@ -1,3 +1,16 @@
+2019-12-09  Truitt Savell  <tsavell@apple.com>
+
+        Unreviewed, rolling out r253299.
+
+        Casued 30+ imported/ test failures on Mac wk2
+
+        Reverted changeset:
+
+        "Throttling requestAnimationFrame should be controlled by
+        RenderingUpdateScheduler"
+        https://bugs.webkit.org/show_bug.cgi?id=204713
+        https://trac.webkit.org/changeset/253299
+
 2019-12-09  Wenson Hsieh  <wenson_hsieh@apple.com>
 
         Finish encoding/decoding support for DisplayList::SetState
index 5138b8c..ee89ee3 100644 (file)
@@ -1011,7 +1011,6 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
     platform/gamepad/PlatformGamepad.h
 
     platform/graphics/ANGLEWebKitBridge.h
-    platform/graphics/AnimationFrameRate.h
     platform/graphics/AudioTrackPrivate.h
     platform/graphics/BitmapImage.h
     platform/graphics/Color.h
index f566b71..1082fb0 100644 (file)
                72144333223EC8B000F12FF7 /* SVGProperty.h in Headers */ = {isa = PBXBuildFile; fileRef = 55EE5363223B2A2400FBA944 /* SVGProperty.h */; settings = {ATTRIBUTES = (Private, ); }; };
                72144334223EC91600F12FF7 /* SVGPropertyOwner.h in Headers */ = {isa = PBXBuildFile; fileRef = 55EE5360223B2A2100FBA944 /* SVGPropertyOwner.h */; settings = {ATTRIBUTES = (Private, ); }; };
                72283F0E230B268C00F5D828 /* ImagePaintingOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 72C18A3F230B04B7006847C7 /* ImagePaintingOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               722A815D238FDAF000C00583 /* AnimationFrameRate.h in Headers */ = {isa = PBXBuildFile; fileRef = 722A815C238FD50500C00583 /* AnimationFrameRate.h */; settings = {ATTRIBUTES = (Private, ); }; };
                724ED3321A3A8B2300F5F13C /* JSEXTBlendMinMax.h in Headers */ = {isa = PBXBuildFile; fileRef = 724ED3301A3A8B2300F5F13C /* JSEXTBlendMinMax.h */; };
                724EE5501DC80D7F00A91FFB /* ActivityState.h in Headers */ = {isa = PBXBuildFile; fileRef = 724EE54E1DC7F25B00A91FFB /* ActivityState.h */; settings = {ATTRIBUTES = (Private, ); }; };
                724EE5511DC80D8400A91FFB /* ActivityStateChangeObserver.h in Headers */ = {isa = PBXBuildFile; fileRef = 724EE54F1DC7F25B00A91FFB /* ActivityStateChangeObserver.h */; settings = {ATTRIBUTES = (Private, ); }; };
                71FF851822A3F81F005D5959 /* NavigatorMaxTouchPoints.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = NavigatorMaxTouchPoints.idl; sourceTree = "<group>"; };
                721443452240C8BA00F12FF7 /* SVGAnimatedValueProperty.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGAnimatedValueProperty.h; sourceTree = "<group>"; };
                721443462240CAD200F12FF7 /* SVGValueProperty.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGValueProperty.h; sourceTree = "<group>"; };
-               722A815C238FD50500C00583 /* AnimationFrameRate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AnimationFrameRate.h; sourceTree = "<group>"; };
                724ED3291A3A7E5400F5F13C /* EXTBlendMinMax.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EXTBlendMinMax.cpp; sourceTree = "<group>"; };
                724ED32A1A3A7E5400F5F13C /* EXTBlendMinMax.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EXTBlendMinMax.h; sourceTree = "<group>"; };
                724ED32B1A3A7E5400F5F13C /* EXTBlendMinMax.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = EXTBlendMinMax.idl; sourceTree = "<group>"; };
                                1199FA59208E3C7F002358CC /* DisplayBox.h */,
                                E4FB4B35239BEB10003C336A /* DisplayInlineContent.cpp */,
                                E451C6332394058E00993190 /* DisplayInlineContent.h */,
-                               112FB350239C23C40087054A /* DisplayInlineRect.h */,
                                6FB47E612277425A00C7BCB0 /* DisplayLineBox.h */,
                                6F77868523491AC6004D9636 /* DisplayPainter.cpp */,
                                6F77868723491AD7004D9636 /* DisplayPainter.h */,
                                6FD9CD52227E21C800E53957 /* DisplayRect.h */,
+                               112FB350239C23C40087054A /* DisplayInlineRect.h */,
                                6FCE1A1822618AB3004F0343 /* DisplayRun.h */,
                        );
                        path = displaytree;
                                49E911B20EF86D27009D0CAF /* transforms */,
                                490707E41219C04300D90E51 /* ANGLEWebKitBridge.cpp */,
                                490707E51219C04300D90E51 /* ANGLEWebKitBridge.h */,
-                               722A815C238FD50500C00583 /* AnimationFrameRate.h */,
                                BEF29EE91715DD0900C4B4C9 /* AudioTrackPrivate.h */,
                                A89943270B42338700D7C802 /* BitmapImage.cpp */,
                                A89943260B42338700D7C802 /* BitmapImage.h */,
                                71EFCEDC202B38A900D7C411 /* AnimationEffect.h in Headers */,
                                71E2C42621C935280024F8C8 /* AnimationEffectPhase.h in Headers */,
                                319848011A1D817B00A13318 /* AnimationEvent.h in Headers */,
-                               722A815D238FDAF000C00583 /* AnimationFrameRate.h in Headers */,
                                49E912AD0EFAC906009D0CAF /* AnimationList.h in Headers */,
                                714C7C661FDAD2A100F2BEE1 /* AnimationPlaybackEvent.h in Headers */,
                                714C7C671FDAD2A900F2BEE1 /* AnimationPlaybackEventInit.h in Headers */,
                                7EDAAFC919A2CCDC0034DFD1 /* DiskCacheMonitorCocoa.h in Headers */,
                                1199FA5B208E3C7F002358CC /* DisplayBox.h in Headers */,
                                E451C6342394058F00993190 /* DisplayInlineContent.h in Headers */,
-                               112FB352239C23C40087054A /* DisplayInlineRect.h in Headers */,
-                               6FB47E632277425A00C7BCB0 /* DisplayLineBox.h in Headers */,
                                0FE5FBD31C3DD51E0007A2CA /* DisplayList.h in Headers */,
                                0FE5FBD51C3DD51E0007A2CA /* DisplayListItems.h in Headers */,
                                0FE5FBD71C3DD51E0007A2CA /* DisplayListRecorder.h in Headers */,
                                115CFA7E208B8E10001E6991 /* InlineFormattingState.h in Headers */,
                                6FE7CFA22177EEF2005B1573 /* InlineItem.h in Headers */,
                                BCE789161120D6080060ECE5 /* InlineIterator.h in Headers */,
+                               6FB47E632277425A00C7BCB0 /* DisplayLineBox.h in Headers */,
                                6FE198172178397C00446F08 /* InlineLineBreaker.h in Headers */,
                                6F0CD695229ED32700C5994E /* InlineLineBuilder.h in Headers */,
                                6F360E5023999421001512A7 /* InlineSoftLineBreakItem.h in Headers */,
                                BC5EB6680E81CB7100B25965 /* RenderStyleConstants.h in Headers */,
                                436708C112D9CA4B00044234 /* RenderSVGBlock.h in Headers */,
                                436708C312D9CA4B00044234 /* RenderSVGContainer.h in Headers */,
+                               112FB352239C23C40087054A /* DisplayInlineRect.h in Headers */,
                                2B365C841525119E0091D27B /* RenderSVGEllipse.h in Headers */,
                                43C092BC12D9E4EE00A989C3 /* RenderSVGForeignObject.h in Headers */,
                                436708C512D9CA4B00044234 /* RenderSVGGradientStop.h in Headers */,
index 16999a7..4fe9980 100644 (file)
@@ -44,6 +44,9 @@
 #include "RenderLayerBacking.h"
 #include <JavaScriptCore/VM.h>
 
+static const Seconds defaultAnimationInterval { 15_ms };
+static const Seconds throttledAnimationInterval { 30_ms };
+
 namespace WebCore {
 
 Ref<DocumentTimeline> DocumentTimeline::create(Document& document)
@@ -190,11 +193,16 @@ Vector<RefPtr<WebAnimation>> DocumentTimeline::getAnimations() const
     return animations;
 }
 
+void DocumentTimeline::updateThrottlingState()
+{
+    scheduleAnimationResolution();
+}
+
 Seconds DocumentTimeline::animationInterval() const
 {
     if (!m_document || !m_document->page())
         return Seconds::infinity();
-    return m_document->page()->preferredRenderingUpdateInterval();
+    return m_document->page()->isLowPowerModeEnabled() ? throttledAnimationInterval : defaultAnimationInterval;
 }
 
 void DocumentTimeline::suspendAnimations()
index fcc3b03..2c35d24 100644 (file)
@@ -73,6 +73,7 @@ public:
     
     void updateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp);
 
+    void updateThrottlingState();
     WEBCORE_EXPORT Seconds animationInterval() const;
     WEBCORE_EXPORT void suspendAnimations();
     WEBCORE_EXPORT void resumeAnimations();
index e5288d3..53fb379 100644 (file)
@@ -6495,8 +6495,11 @@ int Document::requestAnimationFrame(Ref<RequestAnimationFrameCallback>&& callbac
         if (!page() || page()->scriptedAnimationsSuspended())
             m_scriptedAnimationController->suspend();
 
+        if (page() && page()->isLowPowerModeEnabled())
+            m_scriptedAnimationController->addThrottlingReason(ScriptedAnimationController::ThrottlingReason::LowPowerMode);
+
         if (!topOrigin().canAccess(securityOrigin()) && !hasHadUserInteraction())
-            m_scriptedAnimationController->addThrottlingReason(ThrottlingReason::NonInteractedCrossOriginFrame);
+            m_scriptedAnimationController->addThrottlingReason(ScriptedAnimationController::ThrottlingReason::NonInteractedCrossOriginFrame);
     }
 
     return m_scriptedAnimationController->registerCallback(WTFMove(callback));
@@ -6735,7 +6738,7 @@ void Document::updateLastHandledUserGestureTimestamp(MonotonicTime time)
 
     if (static_cast<bool>(time) && m_scriptedAnimationController) {
         // It's OK to always remove NonInteractedCrossOriginFrame even if this frame isn't cross-origin.
-        m_scriptedAnimationController->removeThrottlingReason(ThrottlingReason::NonInteractedCrossOriginFrame);
+        m_scriptedAnimationController->removeThrottlingReason(ScriptedAnimationController::ThrottlingReason::NonInteractedCrossOriginFrame);
     }
 
     // DOM Timer alignment may depend on the user having interacted with the document.
index c47a24b..014d4cd 100644 (file)
@@ -1,6 +1,5 @@
 /*
  * Copyright (C) 2011 Google Inc. All Rights Reserved.
- * Copyright (C) 2019 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 #include "config.h"
 #include "ScriptedAnimationController.h"
 
+#include "Chrome.h"
+#include "ChromeClient.h"
+#include "CustomHeaderFields.h"
+#include "DOMWindow.h"
+#include "Document.h"
+#include "DocumentLoader.h"
+#include "Frame.h"
+#include "FrameView.h"
 #include "InspectorInstrumentation.h"
+#include "Logging.h"
 #include "Page.h"
 #include "RequestAnimationFrameCallback.h"
 #include "Settings.h"
+#include <algorithm>
+#include <wtf/Ref.h>
 #include <wtf/SystemTracing.h>
+#include <wtf/text/StringBuilder.h>
+
+// Allow a little more than 60fps to make sure we can at least hit that frame rate.
+static const Seconds fullSpeedAnimationInterval { 15_ms };
+// Allow a little more than 30fps to make sure we can at least hit that frame rate.
+static const Seconds halfSpeedThrottlingAnimationInterval { 30_ms };
+static const Seconds aggressiveThrottlingAnimationInterval { 10_s };
+
+#define RELEASE_LOG_IF_ALLOWED(fmt, ...) RELEASE_LOG_IF(page() && page()->isAlwaysOnLoggingAllowed(), PerformanceLogging, "%p - ScriptedAnimationController::" fmt, this, ##__VA_ARGS__)
 
 namespace WebCore {
 
 ScriptedAnimationController::ScriptedAnimationController(Document& document)
     : m_document(makeWeakPtr(document))
+    , m_animationTimer(*this, &ScriptedAnimationController::animationTimerFired)
 {
 }
 
@@ -47,18 +67,6 @@ bool ScriptedAnimationController::requestAnimationFrameEnabled() const
     return m_document && m_document->settings().requestAnimationFrameEnabled();
 }
 
-Page* ScriptedAnimationController::page() const
-{
-    return m_document ? m_document->page() : nullptr;
-}
-
-Seconds ScriptedAnimationController::interval() const
-{
-    if (auto* page = this->page())
-        return std::max(preferredFrameInterval(m_throttlingReasons), page->preferredRenderingUpdateInterval());
-    return preferredFrameInterval(m_throttlingReasons);
-}
-
 void ScriptedAnimationController::suspend()
 {
     ++m_suspendCount;
@@ -75,42 +83,110 @@ void ScriptedAnimationController::resume()
         scheduleAnimation();
 }
 
-bool ScriptedAnimationController::isThrottled() const
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR) && !RELEASE_LOG_DISABLED
+
+static const char* throttlingReasonToString(ScriptedAnimationController::ThrottlingReason reason)
+{
+    switch (reason) {
+    case ScriptedAnimationController::ThrottlingReason::VisuallyIdle:
+        return "VisuallyIdle";
+    case ScriptedAnimationController::ThrottlingReason::OutsideViewport:
+        return "OutsideViewport";
+    case ScriptedAnimationController::ThrottlingReason::LowPowerMode:
+        return "LowPowerMode";
+    case ScriptedAnimationController::ThrottlingReason::NonInteractedCrossOriginFrame:
+        return "NonInteractiveCrossOriginFrame";
+    }
+}
+
+static String throttlingReasonsToString(OptionSet<ScriptedAnimationController::ThrottlingReason> reasons)
+{
+    if (reasons.isEmpty())
+        return "[Unthrottled]"_s;
+
+    StringBuilder builder;
+    for (auto reason : reasons) {
+        if (!builder.isEmpty())
+            builder.append('|');
+        builder.append(throttlingReasonToString(reason));
+    }
+    return builder.toString();
+}
+
+#endif
+
+void ScriptedAnimationController::addThrottlingReason(ThrottlingReason reason)
+{
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
+    if (m_throttlingReasons.contains(reason))
+        return;
+
+    m_throttlingReasons.add(reason);
+
+    RELEASE_LOG_IF_ALLOWED("addThrottlingReason(%s) -> %s", throttlingReasonToString(reason), throttlingReasonsToString(m_throttlingReasons).utf8().data());
+
+    if (m_animationTimer.isActive()) {
+        m_animationTimer.stop();
+        scheduleAnimation();
+    }
+#else
+    UNUSED_PARAM(reason);
+#endif
+}
+
+void ScriptedAnimationController::removeThrottlingReason(ThrottlingReason reason)
 {
-    auto* page = this->page();
-    if (!m_throttlingReasons.isEmpty() || (page && page->isRenderingUpdateThrottled())) {
-        ASSERT(interval() > FullSpeedAnimationInterval);
-        return true;
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
+    if (!m_throttlingReasons.contains(reason))
+        return;
+
+    m_throttlingReasons.remove(reason);
+
+    RELEASE_LOG_IF_ALLOWED("removeThrottlingReason(%s) -> %s", throttlingReasonToString(reason), throttlingReasonsToString(m_throttlingReasons).utf8().data());
+
+    if (m_animationTimer.isActive()) {
+        m_animationTimer.stop();
+        scheduleAnimation();
     }
+#else
+    UNUSED_PARAM(reason);
+#endif
+}
+
+bool ScriptedAnimationController::isThrottled() const
+{
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
+    return !m_throttlingReasons.isEmpty();
+#else
     return false;
+#endif
 }
 
 ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(Ref<RequestAnimationFrameCallback>&& callback)
 {
-    CallbackId callbackId = ++m_nextCallbackId;
+    ScriptedAnimationController::CallbackId id = ++m_nextCallbackId;
     callback->m_firedOrCancelled = false;
-    callback->m_id = callbackId;
+    callback->m_id = id;
     m_callbacks.append(WTFMove(callback));
 
     if (m_document)
-        InspectorInstrumentation::didRequestAnimationFrame(*m_document, callbackId);
+        InspectorInstrumentation::didRequestAnimationFrame(*m_document, id);
 
     if (!m_suspendCount)
         scheduleAnimation();
-    return callbackId;
+    return id;
 }
 
-void ScriptedAnimationController::cancelCallback(CallbackId callbackId)
+void ScriptedAnimationController::cancelCallback(CallbackId id)
 {
-    bool cancelled = m_callbacks.removeFirstMatching([&](auto& callback) {
-        if (callback->m_id != callbackId)
-            return false;
-        callback->m_firedOrCancelled = true;
-        return true;
-    });
-
-    if (cancelled && m_document)
-        InspectorInstrumentation::didCancelAnimationFrame(*m_document, callbackId);
+    for (size_t i = 0; i < m_callbacks.size(); ++i) {
+        if (m_callbacks[i]->m_id == id) {
+            m_callbacks[i]->m_firedOrCancelled = true;
+            InspectorInstrumentation::didCancelAnimationFrame(*m_document, id);
+            m_callbacks.remove(i);
+            return;
+        }
+    }
 }
 
 void ScriptedAnimationController::serviceRequestAnimationFrameCallbacks(DOMHighResTimeStamp timestamp)
@@ -118,13 +194,6 @@ void ScriptedAnimationController::serviceRequestAnimationFrameCallbacks(DOMHighR
     if (!m_callbacks.size() || m_suspendCount || !requestAnimationFrameEnabled())
         return;
 
-    bool isThrottlingRelativeToPage = page() && page()->preferredRenderingUpdateInterval() < preferredFrameInterval(m_throttlingReasons);
-    bool canSkipFrame = Seconds(timestamp - m_lastAnimationFrameTimestamp) < preferredFrameInterval(m_throttlingReasons);
-    if (isThrottlingRelativeToPage && canSkipFrame) {
-        scheduleAnimation();
-        return;
-    }
-    
     TraceScope tracingScope(RAFCallbackStart, RAFCallbackEnd);
 
     // We round this to the nearest microsecond so that we can return a time that matches what is returned by document.timeline.currentTime.
@@ -154,19 +223,72 @@ void ScriptedAnimationController::serviceRequestAnimationFrameCallbacks(DOMHighR
         return callback->m_firedOrCancelled;
     });
 
-    m_lastAnimationFrameTimestamp = timestamp;
-
     if (m_callbacks.size())
         scheduleAnimation();
 }
 
+Seconds ScriptedAnimationController::interval() const
+{
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
+    if (m_throttlingReasons.contains(ThrottlingReason::VisuallyIdle) || m_throttlingReasons.contains(ThrottlingReason::OutsideViewport))
+        return aggressiveThrottlingAnimationInterval;
+
+    if (m_throttlingReasons.contains(ThrottlingReason::LowPowerMode))
+        return halfSpeedThrottlingAnimationInterval;
+
+    if (m_throttlingReasons.contains(ThrottlingReason::NonInteractedCrossOriginFrame))
+        return halfSpeedThrottlingAnimationInterval;
+
+    ASSERT(m_throttlingReasons.isEmpty());
+#endif
+    return fullSpeedAnimationInterval;
+}
+
+Page* ScriptedAnimationController::page() const
+{
+    return m_document ? m_document->page() : nullptr;
+}
+
 void ScriptedAnimationController::scheduleAnimation()
 {
     if (!requestAnimationFrameEnabled())
         return;
 
-    if (auto* page = this->page())
-        page->renderingUpdateScheduler().scheduleTimedRenderingUpdate();
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
+    if (!m_isUsingTimer && !isThrottled()) {
+        if (auto* page = this->page()) {
+            page->renderingUpdateScheduler().scheduleTimedRenderingUpdate();
+            return;
+        }
+
+        m_isUsingTimer = true;
+    }
+#endif
+    if (m_animationTimer.isActive())
+        return;
+
+    Seconds animationInterval = interval();
+    Seconds scheduleDelay = std::max(animationInterval - Seconds(m_document->domWindow()->nowTimestamp() - m_lastAnimationFrameTimestamp), 0_s);
+
+    if (isThrottled()) {
+        // FIXME: not ideal to snapshot time both in now() and nowTimestamp(), the latter of which also has reduced resolution.
+        MonotonicTime now = MonotonicTime::now();
+
+        MonotonicTime fireTime = now + scheduleDelay;
+        Seconds alignmentInterval = 10_ms;
+        // Snap to the nearest alignmentInterval.
+        Seconds alignment = (fireTime + alignmentInterval / 2) % alignmentInterval;
+        MonotonicTime alignedFireTime = fireTime - alignment;
+        scheduleDelay = alignedFireTime - now;
+    }
+
+    m_animationTimer.startOneShot(scheduleDelay);
+}
+
+void ScriptedAnimationController::animationTimerFired()
+{
+    m_lastAnimationFrameTimestamp = m_document->domWindow()->nowTimestamp();
+    serviceRequestAnimationFrameCallbacks(m_lastAnimationFrameTimestamp);
 }
 
 }
index b7b2107..0d21208 100644 (file)
@@ -1,6 +1,5 @@
 /*
  * Copyright (C) 2011 Google Inc. All Rights Reserved.
- * Copyright (C) 2019 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
 
 #pragma once
 
-#include "AnimationFrameRate.h"
 #include "DOMHighResTimeStamp.h"
+#include "Timer.h"
 #include <wtf/OptionSet.h>
 #include <wtf/RefCounted.h>
 #include <wtf/RefPtr.h>
 #include <wtf/Vector.h>
-#include <wtf/WeakPtr.h>
 
 namespace WebCore {
 
@@ -50,7 +48,6 @@ public:
     ~ScriptedAnimationController();
     void clearDocumentPointer() { m_document = nullptr; }
     bool requestAnimationFrameEnabled() const;
-    WEBCORE_EXPORT Seconds interval() const;
 
     typedef int CallbackId;
 
@@ -60,26 +57,41 @@ public:
 
     void suspend();
     void resume();
-    
-    void addThrottlingReason(ThrottlingReason reason) { m_throttlingReasons.add(reason); }
-    void removeThrottlingReason(ThrottlingReason reason) { m_throttlingReasons.remove(reason); }
+
+    enum class ThrottlingReason {
+        VisuallyIdle                    = 1 << 0,
+        OutsideViewport                 = 1 << 1,
+        LowPowerMode                    = 1 << 2,
+        NonInteractedCrossOriginFrame   = 1 << 3,
+    };
+    void addThrottlingReason(ThrottlingReason);
+    void removeThrottlingReason(ThrottlingReason);
+
     WEBCORE_EXPORT bool isThrottled() const;
+    WEBCORE_EXPORT Seconds interval() const;
 
 private:
     ScriptedAnimationController(Document&);
 
-    Page* page() const;
     void scheduleAnimation();
+    void animationTimerFired();
+
+    Page* page() const;
 
-    using CallbackList = Vector<RefPtr<RequestAnimationFrameCallback>>;
+    typedef Vector<RefPtr<RequestAnimationFrameCallback>> CallbackList;
     CallbackList m_callbacks;
-    DOMHighResTimeStamp m_lastAnimationFrameTimestamp { 0 };
 
     WeakPtr<Document> m_document;
     CallbackId m_nextCallbackId { 0 };
     int m_suspendCount { 0 };
 
+    Timer m_animationTimer;
+    double m_lastAnimationFrameTimestamp { 0 };
+
+#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     OptionSet<ThrottlingReason> m_throttlingReasons;
+    bool m_isUsingTimer { false };
+#endif
 };
 
 } // namespace WebCore
index 1bf35f4..04012f9 100644 (file)
@@ -2524,9 +2524,9 @@ void FrameView::updateScriptedAnimationsAndTimersThrottlingState(const IntRect&
 
     if (auto* scriptedAnimationController = document->scriptedAnimationController()) {
         if (shouldThrottle)
-            scriptedAnimationController->addThrottlingReason(ThrottlingReason::OutsideViewport);
+            scriptedAnimationController->addThrottlingReason(ScriptedAnimationController::ThrottlingReason::OutsideViewport);
         else
-            scriptedAnimationController->removeThrottlingReason(ThrottlingReason::OutsideViewport);
+            scriptedAnimationController->removeThrottlingReason(ScriptedAnimationController::ThrottlingReason::OutsideViewport);
     }
 
     document->setTimerThrottlingEnabled(shouldThrottle);
index a59cb32..5655dc2 100644 (file)
@@ -22,7 +22,6 @@
 
 #include "ActivityStateChangeObserver.h"
 #include "AlternativeTextClient.h"
-#include "AnimationFrameRate.h"
 #include "ApplicationCacheStorage.h"
 #include "ApplicationStateChangeListener.h"
 #include "AuthenticatorCoordinator.h"
@@ -1370,44 +1369,54 @@ void Page::updateRendering()
 void Page::suspendScriptedAnimations()
 {
     m_scriptedAnimationsSuspended = true;
-    forEachDocument([&] (Document& document) {
-        document.suspendScriptedAnimationControllerCallbacks();
-    });
+    for (Frame* frame = &mainFrame(); frame; frame = frame->tree().traverseNext()) {
+        if (frame->document())
+            frame->document()->suspendScriptedAnimationControllerCallbacks();
+    }
 }
 
 void Page::resumeScriptedAnimations()
 {
     m_scriptedAnimationsSuspended = false;
-    forEachDocument([&] (Document& document) {
-        document.resumeScriptedAnimationControllerCallbacks();
-    });
+    for (Frame* frame = &mainFrame(); frame; frame = frame->tree().traverseNext()) {
+        if (frame->document())
+            frame->document()->resumeScriptedAnimationControllerCallbacks();
+    }
 }
 
-Seconds Page::preferredRenderingUpdateInterval() const
+enum class ThrottlingReasonOperation { Add, Remove };
+static void updateScriptedAnimationsThrottlingReason(Page& page, ThrottlingReasonOperation operation, ScriptedAnimationController::ThrottlingReason reason)
 {
-    return preferredFrameInterval(m_throttlingReasons);
+    for (Frame* frame = &page.mainFrame(); frame; frame = frame->tree().traverseNext()) {
+        auto* document = frame->document();
+        if (!document)
+            continue;
+        auto* scriptedAnimationController = document->scriptedAnimationController();
+        if (!scriptedAnimationController)
+            continue;
+
+        if (operation == ThrottlingReasonOperation::Add)
+            scriptedAnimationController->addThrottlingReason(reason);
+        else
+            scriptedAnimationController->removeThrottlingReason(reason);
+    }
 }
 
 void Page::setIsVisuallyIdleInternal(bool isVisuallyIdle)
 {
-    if (isVisuallyIdle == m_throttlingReasons.contains(ThrottlingReason::VisuallyIdle))
-        return;
-
-    m_throttlingReasons = m_throttlingReasons ^ ThrottlingReason::VisuallyIdle;
-    renderingUpdateScheduler().adjustRenderingUpdateFrequency();
+    updateScriptedAnimationsThrottlingReason(*this, isVisuallyIdle ? ThrottlingReasonOperation::Add : ThrottlingReasonOperation::Remove, ScriptedAnimationController::ThrottlingReason::VisuallyIdle);
 }
 
 void Page::handleLowModePowerChange(bool isLowPowerModeEnabled)
 {
-    if (isLowPowerModeEnabled == m_throttlingReasons.contains(ThrottlingReason::LowPowerMode))
-        return;
-
-    m_throttlingReasons = m_throttlingReasons ^ ThrottlingReason::LowPowerMode;
-    renderingUpdateScheduler().adjustRenderingUpdateFrequency();
-
-    if (!RuntimeEnabledFeatures::sharedFeatures().webAnimationsCSSIntegrationEnabled())
+    updateScriptedAnimationsThrottlingReason(*this, isLowPowerModeEnabled ? ThrottlingReasonOperation::Add : ThrottlingReasonOperation::Remove, ScriptedAnimationController::ThrottlingReason::LowPowerMode);
+    if (RuntimeEnabledFeatures::sharedFeatures().webAnimationsCSSIntegrationEnabled()) {
+        forEachDocument([&] (Document& document) {
+            if (auto timeline = document.existingTimeline())
+                timeline->updateThrottlingState();
+        });
+    } else
         mainFrame().animation().updateThrottlingState();
-
     updateDOMTimerAlignmentInterval();
 }
 
index 18a1edc..5f4ceb0 100644 (file)
@@ -21,7 +21,6 @@
 #pragma once
 
 #include "ActivityState.h"
-#include "AnimationFrameRate.h"
 #include "DisabledAdaptations.h"
 #include "Document.h"
 #include "FindOptions.h"
@@ -274,7 +273,6 @@ public:
     PerformanceMonitor* performanceMonitor() { return m_performanceMonitor.get(); }
 
     RenderingUpdateScheduler& renderingUpdateScheduler();
-    bool isRenderingUpdateThrottled() const { return !m_throttlingReasons.isEmpty(); }
 
     ValidationMessageClient* validationMessageClient() const { return m_validationMessageClient.get(); }
     void updateValidationBubbleStateIfNeeded();
@@ -715,8 +713,6 @@ public:
     bool isLowPowerModeEnabled() const;
     WEBCORE_EXPORT void setLowPowerModeEnabledOverrideForTesting(Optional<bool>);
 
-    Seconds preferredRenderingUpdateInterval() const;
-
     WEBCORE_EXPORT void applicationWillResignActive();
     WEBCORE_EXPORT void applicationDidEnterBackground();
     WEBCORE_EXPORT void applicationWillEnterForeground();
@@ -1012,7 +1008,6 @@ private:
     bool m_mediaPlaybackIsSuspended { false };
     bool m_mediaBufferingIsSuspended { false };
     bool m_inUpdateRendering { false };
-    OptionSet<ThrottlingReason> m_throttlingReasons;
 };
 
 inline PageGroup& Page::group()
index a466fa6..3b881df 100644 (file)
@@ -42,27 +42,6 @@ RenderingUpdateScheduler::RenderingUpdateScheduler(Page& page)
 #endif
 }
 
-#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR) && PLATFORM(IOS_FAMILY)
-void RenderingUpdateScheduler::adjustFramesPerSecond()
-{
-    Seconds interval = m_page.preferredRenderingUpdateInterval();
-    // CADisplayLink.preferredFramesPerSecond is an integer. So a fraction PreferredFramesPerSecond can't be set.
-    if (interval < 1_s)
-        DisplayRefreshMonitorManager::sharedManager().setPreferredFramesPerSecond(*this, preferredFramesPerSecond(interval));
-}
-#endif
-
-void RenderingUpdateScheduler::adjustRenderingUpdateFrequency()
-{
-#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR) && PLATFORM(IOS_FAMILY)
-    adjustFramesPerSecond();
-#endif
-    if (isScheduled()) {
-        clearScheduled();
-        scheduleTimedRenderingUpdate();
-    }
-}
-
 void RenderingUpdateScheduler::scheduleTimedRenderingUpdate()
 {
     if (isScheduled())
@@ -76,25 +55,12 @@ void RenderingUpdateScheduler::scheduleTimedRenderingUpdate()
 
     tracePoint(ScheduleRenderingUpdate);
 
-    Seconds interval = m_page.preferredRenderingUpdateInterval();
-
 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
-    // CADisplayLink.preferredFramesPerSecond is an integer. Fall back to timer if the PreferredFramesPerSecond is a fraction.
-    if (interval < 1_s) {
-#if PLATFORM(IOS_FAMILY)
-        if (!m_isMonitorCreated) {
-            adjustFramesPerSecond();
-            m_isMonitorCreated = true;
-        }
-#else
-        if (interval == FullSpeedAnimationInterval)
-#endif
-            m_scheduled = DisplayRefreshMonitorManager::sharedManager().scheduleAnimation(*this);
-    }
+    if (!DisplayRefreshMonitorManager::sharedManager().scheduleAnimation(*this))
 #endif
+        startTimer(Seconds(1.0 / 60));
 
-    if (!isScheduled())
-        startTimer(interval);
+    m_scheduled = true;
 }
 
 bool RenderingUpdateScheduler::isScheduled() const
@@ -108,7 +74,6 @@ void RenderingUpdateScheduler::startTimer(Seconds delay)
     ASSERT(!isScheduled());
     m_refreshTimer = makeUnique<Timer>(*this, &RenderingUpdateScheduler::displayRefreshFired);
     m_refreshTimer->startOneShot(delay);
-    m_scheduled = true;
 }
 
 void RenderingUpdateScheduler::clearScheduled()
index 4fcb441..6f06081 100644 (file)
@@ -46,17 +46,12 @@ public:
     }
 
     RenderingUpdateScheduler(Page&);
-
-    void adjustRenderingUpdateFrequency();
     void scheduleTimedRenderingUpdate();
     void scheduleImmediateRenderingUpdate();
     void scheduleRenderingUpdate();
 
 private:
 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
-#if PLATFORM(IOS_FAMILY)
-    void adjustFramesPerSecond();
-#endif
     RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const final;
     void windowScreenDidChange(PlatformDisplayID);
     void displayRefreshFired() final;
@@ -69,9 +64,6 @@ private:
     void clearScheduled();
 
     Page& m_page;
-#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR) && PLATFORM(IOS_FAMILY)
-    bool m_isMonitorCreated;
-#endif
     bool m_scheduled { false };
     std::unique_ptr<Timer> m_refreshTimer;
 };
diff --git a/Source/WebCore/platform/graphics/AnimationFrameRate.h b/Source/WebCore/platform/graphics/AnimationFrameRate.h
deleted file mode 100644 (file)
index ed05915..0000000
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2019 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#pragma once
-
-#include <wtf/OptionSet.h>
-#include <wtf/Seconds.h>
-
-namespace WebCore {
-
-using FramesPerSecond = unsigned;
-
-enum class ThrottlingReason {
-    VisuallyIdle                    = 1 << 0,
-    OutsideViewport                 = 1 << 1,
-    LowPowerMode                    = 1 << 2,
-    NonInteractedCrossOriginFrame   = 1 << 3,
-};
-
-// Allow a little more than 60fps to make sure we can at least hit that frame rate.
-constexpr const Seconds FullSpeedAnimationInterval { 15_ms };
-// Allow a little more than 30fps to make sure we can at least hit that frame rate.
-constexpr const Seconds HalfSpeedThrottlingAnimationInterval { 30_ms };
-constexpr const Seconds AggressiveThrottlingAnimationInterval { 10_s };
-
-constexpr const FramesPerSecond FullSpeedFramesPerSecond = 60;
-constexpr const FramesPerSecond HalfSpeedThrottlingFramesPerSecond = 30;
-constexpr const FramesPerSecond ZeroFramesPerSecond = 0;
-
-inline Seconds preferredFrameInterval(const OptionSet<ThrottlingReason>& throttlingReasons)
-{
-    if (throttlingReasons.containsAny({ThrottlingReason::VisuallyIdle, ThrottlingReason::OutsideViewport }))
-        return AggressiveThrottlingAnimationInterval;
-
-    if (throttlingReasons.containsAny({ ThrottlingReason::LowPowerMode, ThrottlingReason::NonInteractedCrossOriginFrame }))
-        return HalfSpeedThrottlingAnimationInterval;
-
-    ASSERT(throttlingReasons.isEmpty());
-    return FullSpeedAnimationInterval;
-}
-
-inline FramesPerSecond preferredFramesPerSecond(Seconds preferredFrameInterval)
-{
-    if (preferredFrameInterval == FullSpeedAnimationInterval)
-        return FullSpeedFramesPerSecond;
-
-    if (preferredFrameInterval == HalfSpeedThrottlingAnimationInterval)
-        return HalfSpeedThrottlingFramesPerSecond;
-
-    ASSERT_NOT_REACHED();
-    return ZeroFramesPerSecond;
-}
-
-}
index 3ee7b51..d3542b0 100644 (file)
@@ -27,7 +27,6 @@
 
 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
 
-#include "AnimationFrameRate.h"
 #include "PlatformScreen.h"
 #include <wtf/HashSet.h>
 #include <wtf/Lock.h>
@@ -46,8 +45,6 @@ public:
 
     virtual void displayLinkFired() { }
 
-    virtual void setPreferredFramesPerSecond(FramesPerSecond) { }
-
     // Return true if callback request was scheduled, false if it couldn't be
     // (e.g., hardware refresh is not available)
     virtual bool requestRefreshCallback() = 0;
index 8fcc176..ce04729 100644 (file)
@@ -42,11 +42,8 @@ DisplayRefreshMonitorManager& DisplayRefreshMonitorManager::sharedManager()
     return manager.get();
 }
 
-DisplayRefreshMonitor* DisplayRefreshMonitorManager::monitorForClient(DisplayRefreshMonitorClient& client)
+DisplayRefreshMonitor* DisplayRefreshMonitorManager::createMonitorForClient(DisplayRefreshMonitorClient& client)
 {
-    if (!client.hasDisplayID())
-        return nullptr;
-
     PlatformDisplayID clientDisplayID = client.displayID();
     if (auto* existingMonitor = monitorForDisplayID(clientDisplayID)) {
         existingMonitor->addClient(client);
@@ -57,13 +54,21 @@ DisplayRefreshMonitor* DisplayRefreshMonitorManager::monitorForClient(DisplayRef
     if (!monitor)
         return nullptr;
 
-    LOG(RequestAnimationFrame, "DisplayRefreshMonitorManager::monitorForClient() - created monitor %p", monitor.get());
+    LOG(RequestAnimationFrame, "DisplayRefreshMonitorManager::createMonitorForClient() - created monitor %p", monitor.get());
     monitor->addClient(client);
     DisplayRefreshMonitor* result = monitor.get();
     m_monitors.append({ WTFMove(monitor) });
     return result;
 }
 
+void DisplayRefreshMonitorManager::registerClient(DisplayRefreshMonitorClient& client)
+{
+    if (!client.hasDisplayID())
+        return;
+
+    createMonitorForClient(client);
+}
+
 void DisplayRefreshMonitorManager::unregisterClient(DisplayRefreshMonitorClient& client)
 {
     if (!client.hasDisplayID())
@@ -80,19 +85,17 @@ void DisplayRefreshMonitorManager::unregisterClient(DisplayRefreshMonitorClient&
     }
 }
 
-void DisplayRefreshMonitorManager::setPreferredFramesPerSecond(DisplayRefreshMonitorClient& client, FramesPerSecond preferredFramesPerSecond)
-{
-    if (auto* monitor = monitorForClient(client))
-        monitor->setPreferredFramesPerSecond(preferredFramesPerSecond);
-}
-
 bool DisplayRefreshMonitorManager::scheduleAnimation(DisplayRefreshMonitorClient& client)
 {
-    if (auto* monitor = monitorForClient(client)) {
-        client.setIsScheduled(true);
-        return monitor->requestRefreshCallback();
-    }
-    return false;
+    if (!client.hasDisplayID())
+        return false;
+
+    DisplayRefreshMonitor* monitor = createMonitorForClient(client);
+    if (!monitor)
+        return false;
+
+    client.setIsScheduled(true);
+    return monitor->requestRefreshCallback();
 }
 
 void DisplayRefreshMonitorManager::displayDidRefresh(DisplayRefreshMonitor& monitor)
@@ -113,6 +116,7 @@ void DisplayRefreshMonitorManager::windowScreenDidChange(PlatformDisplayID displ
     
     unregisterClient(client);
     client.setDisplayID(displayID);
+    registerClient(client);
     if (client.isScheduled())
         scheduleAnimation(client);
 }
index bd1d86b..4e0d4ea 100644 (file)
@@ -27,7 +27,6 @@
 
 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
 
-#include "AnimationFrameRate.h"
 #include "DisplayRefreshMonitor.h"
 #include "PlatformScreen.h"
 #include <wtf/NeverDestroyed.h>
@@ -38,27 +37,28 @@ namespace WebCore {
 
 class DisplayRefreshMonitorManager {
     friend class NeverDestroyed<DisplayRefreshMonitorManager>;
-    friend class DisplayRefreshMonitor;
 public:
     WEBCORE_EXPORT static DisplayRefreshMonitorManager& sharedManager();
-
+    
+    void registerClient(DisplayRefreshMonitorClient&);
     void unregisterClient(DisplayRefreshMonitorClient&);
 
-    void setPreferredFramesPerSecond(DisplayRefreshMonitorClient&, FramesPerSecond);
     bool scheduleAnimation(DisplayRefreshMonitorClient&);
     void windowScreenDidChange(PlatformDisplayID, DisplayRefreshMonitorClient&);
 
     WEBCORE_EXPORT void displayWasUpdated(PlatformDisplayID);
-
+    
 private:
-    DisplayRefreshMonitorManager() = default;
-    virtual ~DisplayRefreshMonitorManager();
-
+    friend class DisplayRefreshMonitor;
     void displayDidRefresh(DisplayRefreshMonitor&);
+    
+    DisplayRefreshMonitorManager() { }
+    virtual ~DisplayRefreshMonitorManager();
 
     size_t findMonitorForDisplayID(PlatformDisplayID) const;
     DisplayRefreshMonitor* monitorForDisplayID(PlatformDisplayID) const;
-    DisplayRefreshMonitor* monitorForClient(DisplayRefreshMonitorClient&);
+
+    DisplayRefreshMonitor* createMonitorForClient(DisplayRefreshMonitorClient&);
 
     struct DisplayRefreshMonitorWrapper {
         DisplayRefreshMonitorWrapper(DisplayRefreshMonitorWrapper&&) = default;
index 9bcd23f..a911bdd 100644 (file)
@@ -35,6 +35,7 @@ namespace WebCore {
 GraphicsLayerUpdater::GraphicsLayerUpdater(GraphicsLayerUpdaterClient& client, PlatformDisplayID displayID)
     : m_client(client)
 {
+    DisplayRefreshMonitorManager::sharedManager().registerClient(*this);
     DisplayRefreshMonitorManager::sharedManager().windowScreenDidChange(displayID, *this);
     DisplayRefreshMonitorManager::sharedManager().scheduleAnimation(*this);
 }
index 18e809d..ee94779 100644 (file)
@@ -40,7 +40,6 @@ using WebCore::DisplayRefreshMonitorIOS;
 }
 
 - (id)initWithMonitor:(DisplayRefreshMonitorIOS*)monitor;
-- (void)setPreferredFramesPerSecond:(NSInteger)preferredFramesPerSecond;
 - (void)handleDisplayLink:(CADisplayLink *)sender;
 - (void)invalidate;
 
@@ -66,11 +65,6 @@ using WebCore::DisplayRefreshMonitorIOS;
     [super dealloc];
 }
 
-- (void)setPreferredFramesPerSecond:(NSInteger)preferredFramesPerSecond
-{
-    m_displayLink.preferredFramesPerSecond = preferredFramesPerSecond;
-}
-
 - (void)handleDisplayLink:(CADisplayLink *)sender
 {
     UNUSED_PARAM(sender);
index e72a65e..f7a6a9f 100644 (file)
@@ -1,3 +1,16 @@
+2019-12-09  Truitt Savell  <tsavell@apple.com>
+
+        Unreviewed, rolling out r253299.
+
+        Casued 30+ imported/ test failures on Mac wk2
+
+        Reverted changeset:
+
+        "Throttling requestAnimationFrame should be controlled by
+        RenderingUpdateScheduler"
+        https://bugs.webkit.org/show_bug.cgi?id=204713
+        https://trac.webkit.org/changeset/253299
+
 2019-12-09  Chris Dumez  <cdumez@apple.com>
 
         Regression(r249329) ViewGestureController::requestRenderTreeSizeNotificationIfNeeded() sometimes uses wrong webPageID for IPC
index b70d532..556591e 100644 (file)
@@ -28,7 +28,6 @@
 #include "DrawingAreaProxy.h"
 #include "RemoteLayerTreeHost.h"
 #include "TransactionID.h"
-#include <WebCore/AnimationFrameRate.h>
 #include <WebCore/FloatPoint.h>
 #include <WebCore/IntPoint.h>
 #include <WebCore/IntSize.h>
@@ -98,7 +97,6 @@ private:
     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
 
     // Message handlers
-    void setPreferredFramesPerSecond(WebCore::FramesPerSecond);
     void willCommitLayerTree(TransactionID);
     void commitLayerTree(const RemoteLayerTreeTransaction&, const RemoteScrollingCoordinatorTransaction&);
     
index ed0328d..d1047a9 100644 (file)
@@ -21,7 +21,6 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 messages -> RemoteLayerTreeDrawingAreaProxy : DrawingAreaProxy NotRefCounted {
-    void SetPreferredFramesPerSecond(unsigned preferredFramesPerSecond)
     void WillCommitLayerTree(WebKit::TransactionID transactionID)
     void CommitLayerTree(WebKit::RemoteLayerTreeTransaction layerTreeTransaction, WebKit::RemoteScrollingCoordinatorTransaction scrollingTreeTransaction)
 }
index ff31111..380f124 100644 (file)
@@ -49,7 +49,6 @@
 }
 
 - (id)initWithDrawingAreaProxy:(WebKit::RemoteLayerTreeDrawingAreaProxy*)drawingAreaProxy;
-- (void)setPreferredFramesPerSecond:(NSInteger)preferredFramesPerSecond;
 - (void)displayLinkFired:(CADisplayLink *)sender;
 - (void)invalidate;
 - (void)schedule;
     [super dealloc];
 }
 
-- (void)setPreferredFramesPerSecond:(NSInteger)preferredFramesPerSecond
-{
-    _displayLink.preferredFramesPerSecond = preferredFramesPerSecond;
-}
-
 - (void)displayLinkFired:(CADisplayLink *)sender
 {
     ASSERT(isUIThread());
@@ -189,15 +183,6 @@ void RemoteLayerTreeDrawingAreaProxy::sendUpdateGeometry()
     m_isWaitingForDidUpdateGeometry = true;
 }
 
-void RemoteLayerTreeDrawingAreaProxy::setPreferredFramesPerSecond(FramesPerSecond preferredFramesPerSecond)
-{
-#if PLATFORM(IOS_FAMILY)
-    [displayLinkHandler() setPreferredFramesPerSecond:preferredFramesPerSecond];
-#else
-    UNUSED_PARAM(preferredFramesPerSecond);
-#endif
-}
-
 void RemoteLayerTreeDrawingAreaProxy::willCommitLayerTree(TransactionID transactionID)
 {
     m_pendingLayerTreeTransactionID = transactionID;
index b97f1f4..d1f7747 100644 (file)
@@ -28,7 +28,6 @@
 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
 
 #include "RemoteLayerTreeDrawingArea.h"
-#include <WebCore/AnimationFrameRate.h>
 #include <WebCore/DisplayRefreshMonitor.h>
 
 namespace WebKit {
@@ -42,7 +41,6 @@ public:
     
     virtual ~RemoteLayerTreeDisplayRefreshMonitor();
 
-    void setPreferredFramesPerSecond(WebCore::FramesPerSecond) override;
     bool requestRefreshCallback() override;
 
     void didUpdateLayers();
index 157cf40..35c8141 100644 (file)
@@ -43,12 +43,6 @@ RemoteLayerTreeDisplayRefreshMonitor::~RemoteLayerTreeDisplayRefreshMonitor()
         m_drawingArea->willDestroyDisplayRefreshMonitor(this);
 }
 
-void RemoteLayerTreeDisplayRefreshMonitor::setPreferredFramesPerSecond(FramesPerSecond preferredFramesPerSecond)
-{
-    if (m_drawingArea)
-        m_drawingArea->setPreferredFramesPerSecond(preferredFramesPerSecond);
-}
-
 bool RemoteLayerTreeDisplayRefreshMonitor::requestRefreshCallback()
 {
     if (!m_drawingArea || !isActive())
index 0a6f428..1d383d9 100644 (file)
@@ -29,7 +29,6 @@
 #include "DrawingArea.h"
 #include "GraphicsLayerCARemote.h"
 #include "RemoteLayerTreeTransaction.h"
-#include <WebCore/AnimationFrameRate.h>
 #include <WebCore/GraphicsLayerClient.h>
 #include <WebCore/Timer.h>
 #include <atomic>
@@ -74,7 +73,6 @@ private:
 
     RefPtr<WebCore::DisplayRefreshMonitor> createDisplayRefreshMonitor(WebCore::PlatformDisplayID) override;
     void willDestroyDisplayRefreshMonitor(WebCore::DisplayRefreshMonitor*);
-    void setPreferredFramesPerSecond(WebCore::FramesPerSecond);
 
     bool shouldUseTiledBackingForFrameView(const WebCore::FrameView&) override;
 
index 0834a04..e8da19a 100644 (file)
@@ -126,11 +126,6 @@ void RemoteLayerTreeDrawingArea::adoptDisplayRefreshMonitorsFromDrawingArea(Draw
     }
 }
 
-void RemoteLayerTreeDrawingArea::setPreferredFramesPerSecond(FramesPerSecond preferredFramesPerSecond)
-{
-    send(Messages::RemoteLayerTreeDrawingAreaProxy::SetPreferredFramesPerSecond(preferredFramesPerSecond));
-}
-
 void RemoteLayerTreeDrawingArea::updateRootLayers()
 {
     Vector<Ref<GraphicsLayer>> children;