Changeset 242714 in webkit


Ignore:
Timestamp:
Mar 11, 2019, 10:19:20 AM (6 years ago)
Author:
Ryan Haddad
Message:

Unreviewed, rolling out r242688, r242643, r242624.

Caused multiple layout test failures and crashes on iOS and macOS.

Reverted changeset:

"requestAnimationFrame should execute before the next frame"
​https://bugs.webkit.org/show_bug.cgi?id=177484
​https://trac.webkit.org/changeset/242624/webkit

Source/WebCore:

  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • accessibility/mac/AXObjectCacheMac.mm:

(WebCore::AXObjectCache::platformHandleFocusedUIElementChanged):

  • animation/DocumentAnimationScheduler.cpp: Added.

(WebCore::DocumentAnimationScheduler::create):
(WebCore::DocumentAnimationScheduler::DocumentAnimationScheduler):
(WebCore::DocumentAnimationScheduler::detachFromDocument):
(WebCore::DocumentAnimationScheduler::scheduleWebAnimationsResolution):
(WebCore::DocumentAnimationScheduler::unscheduleWebAnimationsResolution):
(WebCore::DocumentAnimationScheduler::scheduleScriptedAnimationResolution):
(WebCore::DocumentAnimationScheduler::displayRefreshFired):
(WebCore::DocumentAnimationScheduler::windowScreenDidChange):
(WebCore::DocumentAnimationScheduler::createDisplayRefreshMonitor const):

  • animation/DocumentAnimationScheduler.h: Renamed from Source/WebCore/page/RenderingUpdateScheduler.h.

(WebCore::DocumentAnimationScheduler::lastTimestamp):
(WebCore::DocumentAnimationScheduler::isFiring const):

  • animation/DocumentTimeline.cpp:

(WebCore::DocumentTimeline::DocumentTimeline):
(WebCore::DocumentTimeline::updateThrottlingState):
(WebCore::DocumentTimeline::suspendAnimations):
(WebCore::DocumentTimeline::resumeAnimations):
(WebCore::DocumentTimeline::liveCurrentTime const):
(WebCore::DocumentTimeline::currentTime):
(WebCore::DocumentTimeline::cacheCurrentTime):
(WebCore::DocumentTimeline::scheduleAnimationResolutionIfNeeded):
(WebCore::DocumentTimeline::animationTimingDidChange):
(WebCore::DocumentTimeline::scheduleAnimationResolution):
(WebCore::DocumentTimeline::unscheduleAnimationResolution):
(WebCore::DocumentTimeline::animationResolutionTimerFired):
(WebCore::DocumentTimeline::updateAnimationsAndSendEvents):
(WebCore::DocumentTimeline::scheduleNextTick):
(WebCore::DocumentTimeline::updateListOfElementsWithRunningAcceleratedAnimationsForElement):
(WebCore::DocumentTimeline::resolveAnimationsForElement):
(WebCore::DocumentTimeline::internalUpdateAnimationsAndSendEvents): Deleted.

  • animation/DocumentTimeline.h:
  • dom/Document.cpp:

(WebCore::Document::resolveStyle):
(WebCore::Document::prepareForDestruction):
(WebCore::Document::windowScreenDidChange):
(WebCore::Document::updateIntersectionObservations):
(WebCore::Document::scheduleForcedIntersectionObservationUpdate):
(WebCore::Document::animationScheduler):
(WebCore::Document::updateAnimationsAndSendEvents): Deleted.
(WebCore::Document::serviceRequestAnimationFrameCallbacks): Deleted.

  • dom/Document.h:
  • dom/ScriptedAnimationController.cpp:

(WebCore::ScriptedAnimationController::serviceScriptedAnimations):
(WebCore::ScriptedAnimationController::scheduleAnimation):
(WebCore::ScriptedAnimationController::animationTimerFired):
(WebCore::ScriptedAnimationController::documentAnimationSchedulerDidFire):
(WebCore::ScriptedAnimationController::serviceRequestAnimationFrameCallbacks): Deleted.

  • dom/ScriptedAnimationController.h:
  • page/FrameView.cpp:

(WebCore::FrameView::viewportContentsChanged):

  • page/IntersectionObserver.cpp:

(WebCore::IntersectionObserver::observe):

  • page/Page.cpp:

(WebCore::Page::Page):
(WebCore::Page::willDisplayPage):
(WebCore::Page::addDocumentNeedingIntersectionObservationUpdate):
(WebCore::Page::updateIntersectionObservations):
(WebCore::Page::scheduleForcedIntersectionObservationUpdate):
(WebCore::Page::layoutIfNeeded): Deleted.
(WebCore::Page::renderingUpdate): Deleted.
(WebCore::Page::renderingUpdateScheduler): Deleted.

  • page/Page.h:
  • page/PageOverlayController.cpp:

(WebCore::PageOverlayController::didChangeViewExposedRect):
(WebCore::PageOverlayController::notifyFlushRequired):

  • page/RenderingUpdateScheduler.cpp: Removed.
  • page/ios/ContentChangeObserver.h:
  • page/mac/ServicesOverlayController.mm:

(WebCore::ServicesOverlayController::Highlight::notifyFlushRequired):

  • rendering/RenderLayerCompositor.cpp:

(WebCore::RenderLayerCompositor::scheduleLayerFlushNow):

Source/WebKit:

  • WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.cpp:

(WebKit::DrawingAreaCoordinatedGraphics::scheduleCompositingLayerFlush):
(WebKit::DrawingAreaCoordinatedGraphics::updateBackingStoreState):
(WebKit::DrawingAreaCoordinatedGraphics::display):

  • WebProcess/WebPage/CoordinatedGraphics/LayerTreeHost.cpp:

(WebKit::LayerTreeHost::layerFlushTimerFired):

  • WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:

(WebKit::RemoteLayerTreeDrawingArea::flushLayers):

  • WebProcess/WebPage/WebPage.cpp:

(WebKit::WebPage::layoutIfNeeded):
(WebKit::WebPage::willDisplayPage):
(WebKit::WebPage::renderingUpdate): Deleted.

  • WebProcess/WebPage/WebPage.h:
  • WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:

(WebKit::TiledCoreAnimationDrawingArea::flushLayers):

Source/WebKitLegacy/mac:

  • WebView/WebView.mm:

(-[WebView _viewWillDrawInternal]):

Source/WebKitLegacy/win:

  • WebView.cpp:

(WebView::updateBackingStore):
(WebView::flushPendingGraphicsLayerChangesSoon):
(WebView::flushPendingGraphicsLayerChanges):

Source/WTF:

  • wtf/SystemTracing.h:

Tools:

  • Tracing/SystemTracePoints.plist:

LayoutTests:

  • TestExpectations:
  • animations/animation-multiple-callbacks-timestamp.html:
  • animations/no-style-recalc-during-accelerated-animation-expected.txt:
  • animations/no-style-recalc-during-accelerated-animation.html:
  • platform/mac-wk2/TestExpectations:
Location:
trunk
Files:
1 added
1 deleted
39 edited
1 moved

Legend:

Unmodified
Added
Removed

  • trunk/LayoutTests/ChangeLog

    r242712 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * TestExpectations:
     14        * animations/animation-multiple-callbacks-timestamp.html:
     15        * animations/no-style-recalc-during-accelerated-animation-expected.txt:
     16        * animations/no-style-recalc-during-accelerated-animation.html:
     17        * platform/mac-wk2/TestExpectations:
     18
    1192019-03-11  John Wilander  <wilander@apple.com>
    220

  • trunk/LayoutTests/TestExpectations

    r242704 r242714  
    30403040# This is fallout from turning Web Animations on.
    30413041webkit.org/b/190032 animations/animation-playstate-paused-style-resolution.html [ Failure ]
    3042 webkit.org/b/190032 animations/missing-values-first-keyframe.html [ Failure ]
    3043 webkit.org/b/190032 animations/missing-values-last-keyframe.html [ Failure ]
    30443042webkit.org/b/190032 compositing/backing/backing-store-attachment-fill-forwards-animation.html [ Failure ]
    30453043webkit.org/b/190032 compositing/backing/transform-transition-from-outside-view.html [ Failure ]

  • trunk/LayoutTests/animations/animation-multiple-callbacks-timestamp.html

    r242624 r242714  
    3636            const WarmupFrames = 5;
    3737            if (++currentFrame > WarmupFrames && timestamp != timestamp1) {
    38                 testFailed("timestamp = " + timestamp + ", timestamp1 = " + timestamp1  + ", window.performance.now() = " + window.performance.now());
     38                testFailed("timestamp1 = " + timestamp1 + ", timestamp2 = " + timestamp2  + ", window.performance.now() = " + window.performance.now());
    3939                failed = true;
    4040            }

  • trunk/LayoutTests/animations/no-style-recalc-during-accelerated-animation-expected.txt

    r242624 r242714  
    11Got iteration event.
    2 PASS: saw three or fewer style recalcs during the animation.
     2PASS: saw two or fewer style recalcs during the animation.

  • trunk/LayoutTests/animations/no-style-recalc-during-accelerated-animation.html

    r242624 r242714  
    3636            box.addEventListener("animationend", () => {
    3737                const numRecalcs = internals.styleRecalcCount();
    38                 if (numRecalcs > 3)
    39                     result.innerText += "FAIL: saw " + numRecalcs + " style recalcs during the animation, should only see three."
     38                if (numRecalcs > 2)
     39                    result.innerText += "FAIL: saw " + numRecalcs + " style recalcs during the animation, should only see two."
    4040                else
    41                     result.innerText += "PASS: saw three or fewer style recalcs during the animation."
     41                    result.innerText += "PASS: saw two or fewer style recalcs during the animation."
    4242
    4343                if (window.testRunner)

  • trunk/LayoutTests/platform/mac-wk2/TestExpectations

    r242688 r242714  
    926926
    927927webkit.org/b/194916 fast/mediastream/MediaStream-video-element.html [ Pass Failure ]
    928 
    929 webkit.org/b/195531 accessibility/mac/selection-notification-focus-change.html [ Failure ]
    930 webkit.org/b/195531 compositing/video/video-clip-change-src.html [ ImageOnlyFailure ]

  • trunk/Source/WTF/ChangeLog

    r242713 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * wtf/SystemTracing.h:
     14
    1152019-03-11  Darin Adler  <darin@apple.com>
    216

  • trunk/Source/WTF/wtf/SystemTracing.h

    r242624 r242714  
    7878    ComputeEventRegionsEnd,
    7979
    80     ScheduleRenderingUpdate,
    81     TriggerRenderingUpdate,
    82     RenderingUpdateStart,
    83     RenderingUpdateEnd,
    84 
    8580    WebKitRange = 10000,
    8681    WebHTMLViewPaintStart,

  • trunk/Source/WebCore/ChangeLog

    r242713 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * Sources.txt:
     14        * WebCore.xcodeproj/project.pbxproj:
     15        * accessibility/mac/AXObjectCacheMac.mm:
     16        (WebCore::AXObjectCache::platformHandleFocusedUIElementChanged):
     17        * animation/DocumentAnimationScheduler.cpp: Added.
     18        (WebCore::DocumentAnimationScheduler::create):
     19        (WebCore::DocumentAnimationScheduler::DocumentAnimationScheduler):
     20        (WebCore::DocumentAnimationScheduler::detachFromDocument):
     21        (WebCore::DocumentAnimationScheduler::scheduleWebAnimationsResolution):
     22        (WebCore::DocumentAnimationScheduler::unscheduleWebAnimationsResolution):
     23        (WebCore::DocumentAnimationScheduler::scheduleScriptedAnimationResolution):
     24        (WebCore::DocumentAnimationScheduler::displayRefreshFired):
     25        (WebCore::DocumentAnimationScheduler::windowScreenDidChange):
     26        (WebCore::DocumentAnimationScheduler::createDisplayRefreshMonitor const):
     27        * animation/DocumentAnimationScheduler.h: Renamed from Source/WebCore/page/RenderingUpdateScheduler.h.
     28        (WebCore::DocumentAnimationScheduler::lastTimestamp):
     29        (WebCore::DocumentAnimationScheduler::isFiring const):
     30        * animation/DocumentTimeline.cpp:
     31        (WebCore::DocumentTimeline::DocumentTimeline):
     32        (WebCore::DocumentTimeline::updateThrottlingState):
     33        (WebCore::DocumentTimeline::suspendAnimations):
     34        (WebCore::DocumentTimeline::resumeAnimations):
     35        (WebCore::DocumentTimeline::liveCurrentTime const):
     36        (WebCore::DocumentTimeline::currentTime):
     37        (WebCore::DocumentTimeline::cacheCurrentTime):
     38        (WebCore::DocumentTimeline::scheduleAnimationResolutionIfNeeded):
     39        (WebCore::DocumentTimeline::animationTimingDidChange):
     40        (WebCore::DocumentTimeline::scheduleAnimationResolution):
     41        (WebCore::DocumentTimeline::unscheduleAnimationResolution):
     42        (WebCore::DocumentTimeline::animationResolutionTimerFired):
     43        (WebCore::DocumentTimeline::updateAnimationsAndSendEvents):
     44        (WebCore::DocumentTimeline::scheduleNextTick):
     45        (WebCore::DocumentTimeline::updateListOfElementsWithRunningAcceleratedAnimationsForElement):
     46        (WebCore::DocumentTimeline::resolveAnimationsForElement):
     47        (WebCore::DocumentTimeline::internalUpdateAnimationsAndSendEvents): Deleted.
     48        * animation/DocumentTimeline.h:
     49        * dom/Document.cpp:
     50        (WebCore::Document::resolveStyle):
     51        (WebCore::Document::prepareForDestruction):
     52        (WebCore::Document::windowScreenDidChange):
     53        (WebCore::Document::updateIntersectionObservations):
     54        (WebCore::Document::scheduleForcedIntersectionObservationUpdate):
     55        (WebCore::Document::animationScheduler):
     56        (WebCore::Document::updateAnimationsAndSendEvents): Deleted.
     57        (WebCore::Document::serviceRequestAnimationFrameCallbacks): Deleted.
     58        * dom/Document.h:
     59        * dom/ScriptedAnimationController.cpp:
     60        (WebCore::ScriptedAnimationController::serviceScriptedAnimations):
     61        (WebCore::ScriptedAnimationController::scheduleAnimation):
     62        (WebCore::ScriptedAnimationController::animationTimerFired):
     63        (WebCore::ScriptedAnimationController::documentAnimationSchedulerDidFire):
     64        (WebCore::ScriptedAnimationController::serviceRequestAnimationFrameCallbacks): Deleted.
     65        * dom/ScriptedAnimationController.h:
     66        * page/FrameView.cpp:
     67        (WebCore::FrameView::viewportContentsChanged):
     68        * page/IntersectionObserver.cpp:
     69        (WebCore::IntersectionObserver::observe):
     70        * page/Page.cpp:
     71        (WebCore::Page::Page):
     72        (WebCore::Page::willDisplayPage):
     73        (WebCore::Page::addDocumentNeedingIntersectionObservationUpdate):
     74        (WebCore::Page::updateIntersectionObservations):
     75        (WebCore::Page::scheduleForcedIntersectionObservationUpdate):
     76        (WebCore::Page::layoutIfNeeded): Deleted.
     77        (WebCore::Page::renderingUpdate): Deleted.
     78        (WebCore::Page::renderingUpdateScheduler): Deleted.
     79        * page/Page.h:
     80        * page/PageOverlayController.cpp:
     81        (WebCore::PageOverlayController::didChangeViewExposedRect):
     82        (WebCore::PageOverlayController::notifyFlushRequired):
     83        * page/RenderingUpdateScheduler.cpp: Removed.
     84        * page/ios/ContentChangeObserver.h:
     85        * page/mac/ServicesOverlayController.mm:
     86        (WebCore::ServicesOverlayController::Highlight::notifyFlushRequired):
     87        * rendering/RenderLayerCompositor.cpp:
     88        (WebCore::RenderLayerCompositor::scheduleLayerFlushNow):
     89
    1902019-03-11  Darin Adler  <darin@apple.com>
    291

  • trunk/Source/WebCore/Sources.txt

    r242664 r242714  
    421421animation/CSSTransition.cpp
    422422animation/DeclarativeAnimation.cpp
     423animation/DocumentAnimationScheduler.cpp
    423424animation/DocumentTimeline.cpp
    424425animation/KeyframeEffect.cpp
    … …  
    15411542page/RemoteDOMWindow.cpp
    15421543page/RemoteFrame.cpp
    1543 page/RenderingUpdateScheduler.cpp
    15441544page/ResourceUsageOverlay.cpp
    15451545page/ResourceUsageThread.cpp

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r242696 r242714  
    17851785                555130011E7CCCCB00A69E38 /* DecodingOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 555130001E7CCCCA00A69E38 /* DecodingOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17861786                555B87ED1CAAF0AB00349425 /* ImageDecoderCG.h in Headers */ = {isa = PBXBuildFile; fileRef = 555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */; };
    1787                 556C7C4B22123997009B06CA /* RenderingUpdateScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 556C7C4722123942009B06CA /* RenderingUpdateScheduler.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17881787                5576A5651D88A70800CCC04C /* ImageFrame.h in Headers */ = {isa = PBXBuildFile; fileRef = 5576A5631D88A70800CCC04C /* ImageFrame.h */; settings = {ATTRIBUTES = (Private, ); }; };
    17891788                55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers */ = {isa = PBXBuildFile; fileRef = 55A336F81D821E3C0022C4C7 /* ImageBackingStore.h */; settings = {ATTRIBUTES = (Private, ); }; };
    … …  
    21232122                715AD7202050513200D592DC /* DeclarativeAnimation.h in Headers */ = {isa = PBXBuildFile; fileRef = 715AD71D2050512400D592DC /* DeclarativeAnimation.h */; settings = {ATTRIBUTES = (Private, ); }; };
    21242123                715AD7212050513F00D592DC /* CSSTransition.h in Headers */ = {isa = PBXBuildFile; fileRef = 7123C186204739BA00789392 /* CSSTransition.h */; };
     2124                716E55B020DBABF100F0CF29 /* DocumentAnimationScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 716E55AD20DBABDC00F0CF29 /* DocumentAnimationScheduler.h */; settings = {ATTRIBUTES = (Private, ); }; };
    21252125                71729F7B20F3BA4900801CE6 /* DocumentTimelineOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 71729F7A20F3BA3A00801CE6 /* DocumentTimelineOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
    21262126                71729F7E20F3BB4700801CE6 /* JSDocumentTimelineOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 71729F7C20F3BAB900801CE6 /* JSDocumentTimelineOptions.h */; };
    … …  
    86568656                555B87EA1CAAF0AB00349425 /* ImageDecoderCG.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageDecoderCG.cpp; sourceTree = "<group>"; };
    86578657                555B87EB1CAAF0AB00349425 /* ImageDecoderCG.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageDecoderCG.h; sourceTree = "<group>"; };
    8658                 556C7C4722123942009B06CA /* RenderingUpdateScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderingUpdateScheduler.h; sourceTree = "<group>"; };
    8659                 556C7C4922123943009B06CA /* RenderingUpdateScheduler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RenderingUpdateScheduler.cpp; sourceTree = "<group>"; };
    86608658                5576A5621D88A70800CCC04C /* ImageFrame.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ImageFrame.cpp; sourceTree = "<group>"; };
    86618659                5576A5631D88A70800CCC04C /* ImageFrame.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ImageFrame.h; sourceTree = "<group>"; };
    … …  
    93849382                716C8DF31E48B284005BD0DA /* volume-down-button.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = "volume-down-button.js"; sourceTree = "<group>"; };
    93859383                716C8DF41E48B284005BD0DA /* volume-up-button.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = "volume-up-button.js"; sourceTree = "<group>"; };
     9384                716E55AD20DBABDC00F0CF29 /* DocumentAnimationScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DocumentAnimationScheduler.h; sourceTree = "<group>"; };
     9385                716E55AF20DBABDD00F0CF29 /* DocumentAnimationScheduler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DocumentAnimationScheduler.cpp; sourceTree = "<group>"; };
    93869386                716FA0D81DB26591007323CC /* airplay-button.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = "airplay-button.css"; sourceTree = "<group>"; };
    93879387                716FA0D91DB26591007323CC /* airplay-button.js */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.javascript; path = "airplay-button.js"; sourceTree = "<group>"; };
    … …  
    2050820508                                46B9518C207D632900A7D2DD /* RemoteFrame.cpp */,
    2050920509                                46B95192207D632E00A7D2DD /* RemoteFrame.h */,
    20510                                 556C7C4922123943009B06CA /* RenderingUpdateScheduler.cpp */,
    20511                                 556C7C4722123942009B06CA /* RenderingUpdateScheduler.h */,
    2051220510                                A5071E821C56D079009951BE /* ResourceUsageData.h */,
    2051320511                                ADBAD6EC1BCDD95000381325 /* ResourceUsageOverlay.cpp */,
    … …  
    2066220660                                715AD71F2050512400D592DC /* DeclarativeAnimation.cpp */,
    2066320661                                715AD71D2050512400D592DC /* DeclarativeAnimation.h */,
     20662                                716E55AF20DBABDD00F0CF29 /* DocumentAnimationScheduler.cpp */,
     20663                                716E55AD20DBABDC00F0CF29 /* DocumentAnimationScheduler.h */,
    2066420664                                71025EC41F99F096004A250C /* DocumentTimeline.cpp */,
    2066520665                                71025EC51F99F096004A250C /* DocumentTimeline.h */,
    … …  
    2909529095                                7EE6846F12D26E3800E73215 /* DNSResolveQueueCFNet.h in Headers */,
    2909629096                                A8185F4009765766005826D9 /* Document.h in Headers */,
     29097                                716E55B020DBABF100F0CF29 /* DocumentAnimationScheduler.h in Headers */,
    2909729098                                A3BB59F41457A40D00AC56FE /* DocumentEventQueue.h in Headers */,
    2909829099                                A8185F3D09765766005826D9 /* DocumentFragment.h in Headers */,
    … …  
    3129731298                                08F2F00A1213E61700DCEC48 /* RenderImageResource.h in Headers */,
    3129831299                                08641D4812142F7D008DE9F6 /* RenderImageResourceStyleImage.h in Headers */,
    31299                                 556C7C4B22123997009B06CA /* RenderingUpdateScheduler.h in Headers */,
    3130031300                                BCEA4878097D93020094C9E4 /* RenderInline.h in Headers */,
    3130131301                                B595FF471824CEE300FF51CD /* RenderIterator.h in Headers */,

  • trunk/Source/WebCore/accessibility/mac/AXObjectCacheMac.mm

    r242624 r242714  
    540540    NSAccessibilityHandleFocusChanged();
    541541    // AXFocusChanged is a test specific notification name and not something a real AT will be listening for
    542     if (UNLIKELY(!axShouldRepostNotificationsForTests))
    543         return;
    544 
    545     auto* rootWebArea = this->rootWebArea();
    546     if (!rootWebArea)
    547         return;
    548 
    549     [rootWebArea->wrapper() accessibilityPostedNotification:@"AXFocusChanged" userInfo:nil];
     542    if (UNLIKELY(axShouldRepostNotificationsForTests))
     543        [rootWebArea()->wrapper() accessibilityPostedNotification:@"AXFocusChanged" userInfo:nil];
    550544}
    551545

  • trunk/Source/WebCore/animation/DocumentAnimationScheduler.h

    r242713 r242714  
    11/*
    2  * Copyright (C) 2019 Apple Inc. All rights reserved.
     2 * Copyright (C) 2018 Apple Inc. All rights reserved.
    33 *
    44 * Redistribution and use in source and binary forms, with or without
    … …  
    2626#pragma once
    2727
     28#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     29
    2830#include "DisplayRefreshMonitorClient.h"
     31#include "PlatformScreen.h"
     32#include <wtf/Ref.h>
     33#include <wtf/RefCounted.h>
     34#include <wtf/RefPtr.h>
    2935#include <wtf/Seconds.h>
    3036
    3137namespace WebCore {
    3238
    33 class Page;
    34 class Timer;
     39class Document;
    3540
    36 class RenderingUpdateScheduler
    37 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
    38     : public DisplayRefreshMonitorClient
    39 #endif
    40 {
    41     WTF_MAKE_FAST_ALLOCATED;
     41class DocumentAnimationScheduler : public RefCounted<DocumentAnimationScheduler>
     42    , public DisplayRefreshMonitorClient {
    4243public:
    43     static std::unique_ptr<RenderingUpdateScheduler> create(Page& page)
    44     {
    45         return std::make_unique<RenderingUpdateScheduler>(page);
    46     }
     44    static Ref<DocumentAnimationScheduler> create(Document&, PlatformDisplayID);
     45    ~DocumentAnimationScheduler();
    4746
    48     RenderingUpdateScheduler(Page&);
    49     void scheduleRenderingUpdate();
     47    void detachFromDocument();
     48    void windowScreenDidChange(PlatformDisplayID);
    5049
    51 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
    52     void windowScreenDidChange(PlatformDisplayID);
    53 #endif
     50    bool scheduleWebAnimationsResolution();
     51    void unscheduleWebAnimationsResolution();
     52    bool scheduleScriptedAnimationResolution();
     53
     54    Seconds lastTimestamp() { return m_lastTimestamp; }
     55    bool isFiring() const { return m_isFiring; }
    5456
    5557private:
    56 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
    57     RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const final;
    58     void displayRefreshFired() final;
    59 #else
    60     void displayRefreshFired();
    61 #endif
     58    DocumentAnimationScheduler(Document&, PlatformDisplayID);
    6259
    63     bool isScheduled() const;
    64     void startTimer(Seconds);
    65     void clearScheduled();
     60    RefPtr<Document> m_document;
     61    bool m_scheduledWebAnimationsResolution { false };
     62    bool m_scheduledScriptedAnimationResolution { false };
     63    bool m_isFiring { false };
     64    Seconds m_lastTimestamp { 0_s };
    6665
    67     Page& m_page;
    68 #if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
    69     bool m_scheduled { false };
    70 #endif
    71     std::unique_ptr<Timer> m_refreshTimer;
     66    void displayRefreshFired() override;
     67    RefPtr<DisplayRefreshMonitor> createDisplayRefreshMonitor(PlatformDisplayID) const override;
    7268};
    7369
    74 }
     70} // namespace WebCore
     71
     72#endif // USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)

  • trunk/Source/WebCore/animation/DocumentTimeline.cpp

    r242624 r242714  
    3434#include "DeclarativeAnimation.h"
    3535#include "Document.h"
     36#include "DocumentAnimationScheduler.h"
    3637#include "GraphicsLayer.h"
    3738#include "KeyframeEffect.h"
    … …  
    6162DocumentTimeline::DocumentTimeline(Document& document, Seconds originTime)
    6263    : AnimationTimeline()
    63     , m_tickScheduleTimer(*this, &DocumentTimeline::scheduleAnimationResolution)
     64#if !USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     65    , m_animationResolutionTimer(*this, &DocumentTimeline::animationResolutionTimerFired)
     66#endif
     67    , m_tickScheduleTimer(*this, &DocumentTimeline::scheduleAnimationResolutionIfNeeded)
    6468    , m_document(&document)
    6569    , m_originTime(originTime)
    … …  
    191195void DocumentTimeline::updateThrottlingState()
    192196{
    193     scheduleAnimationResolution();
     197    scheduleAnimationResolutionIfNeeded();
    194198}
    195199
    … …  
    207211
    208212    if (!m_cachedCurrentTime)
    209         m_cachedCurrentTime = Seconds(liveCurrentTime());
     213        m_cachedCurrentTime = liveCurrentTime();
    210214
    211215    for (const auto& animation : m_animations)
    … …  
    231235        animation->setSuspended(false);
    232236
    233     scheduleAnimationResolution();
     237    scheduleAnimationResolutionIfNeeded();
    234238}
    235239
    … …  
    249253}
    250254
    251 DOMHighResTimeStamp DocumentTimeline::liveCurrentTime() const
    252 {
    253     return m_document->domWindow()->nowTimestamp();
     255Seconds DocumentTimeline::liveCurrentTime() const
     256{
     257#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     258    return m_document->animationScheduler().lastTimestamp();
     259#else
     260    return Seconds(m_document->domWindow()->nowTimestamp());
     261#endif
    254262}
    255263
    … …  
    267275    }
    268276
    269     if (!m_cachedCurrentTime)
    270         cacheCurrentTime(liveCurrentTime());
    271    
     277    auto currentTime = liveCurrentTime();
     278
     279#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     280    // If we're in the middle of firing a frame, either due to a requestAnimationFrame callback
     281    // or scheduling an animation update, we want to ensure we use the same time we're using as
     282    // the timestamp for requestAnimationFrame() callbacks.
     283    if (m_document->animationScheduler().isFiring())
     284        cacheCurrentTime(currentTime);
     285#endif
     286
     287    if (!m_cachedCurrentTime) {
     288#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     289        // If we're not in the middle of firing a frame, let's make our best guess at what the currentTime should
     290        // be since the last time a frame fired by increment of our update interval. This way code using something
     291        // like setTimeout() or handling events will get a time that's only updating at around 60fps, or less if
     292        // we're throttled.
     293        auto lastAnimationSchedulerTimestamp = currentTime;
     294        auto delta = Seconds(m_document->domWindow()->nowTimestamp()) - lastAnimationSchedulerTimestamp;
     295        int frames = std::floor(delta.seconds() / animationInterval().seconds());
     296        cacheCurrentTime(lastAnimationSchedulerTimestamp + Seconds(frames * animationInterval().seconds()));
     297#else
     298        cacheCurrentTime(currentTime);
     299#endif
     300    }
    272301    return m_cachedCurrentTime.value() - m_originTime;
    273302}
    274303
    275 void DocumentTimeline::cacheCurrentTime(DOMHighResTimeStamp newCurrentTime)
    276 {
    277     m_cachedCurrentTime = Seconds(newCurrentTime);
     304void DocumentTimeline::cacheCurrentTime(Seconds newCurrentTime)
     305{
     306    m_cachedCurrentTime = newCurrentTime;
    278307    // We want to be sure to keep this time cached until we've both finished running JS and finished updating
    279308    // animations, so we schedule the invalidation task and register a whenIdle callback on the VM, which will
    … …  
    298327}
    299328
     329void DocumentTimeline::scheduleAnimationResolutionIfNeeded()
     330{
     331    if (!m_isUpdatingAnimations && !m_isSuspended && !m_animations.isEmpty())
     332        scheduleAnimationResolution();
     333}
     334
    300335void DocumentTimeline::animationTimingDidChange(WebAnimation& animation)
    301336{
    302337    AnimationTimeline::animationTimingDidChange(animation);
    303     scheduleAnimationResolution();
     338    scheduleAnimationResolutionIfNeeded();
    304339}
    305340
    … …  
    314349void DocumentTimeline::scheduleAnimationResolution()
    315350{
    316     if (m_isSuspended || m_animations.isEmpty() || m_animationResolutionScheduled)
    317         return;
    318 
    319     if (!m_document || !m_document->page())
    320         return;
    321    
    322     m_document->page()->renderingUpdateScheduler().scheduleRenderingUpdate();
    323     m_animationResolutionScheduled = true;
     351#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     352    m_document->animationScheduler().scheduleWebAnimationsResolution();
     353#else
     354    // FIXME: We need to use the same logic as ScriptedAnimationController here,
     355    // which will be addressed by the refactor tracked by webkit.org/b/179293.
     356    m_animationResolutionTimer.startOneShot(animationInterval());
     357#endif
    324358}
    325359
    … …  
    327361{
    328362    m_tickScheduleTimer.stop();
    329     m_animationResolutionScheduled = false;
    330 }
    331 
    332 void DocumentTimeline::updateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp)
    333 {
    334     // We need to freeze the current time even if no animation is running.
    335     // document.timeline.currentTime may be called from a rAF callback and
    336     // it has to match the rAF timestamp.
    337     if (!m_isSuspended)
    338         cacheCurrentTime(timestamp);
    339 
    340     if (m_isSuspended || m_animations.isEmpty() || !m_animationResolutionScheduled)
    341         return;
    342 
    343     internalUpdateAnimationsAndSendEvents();
     363#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     364    m_document->animationScheduler().unscheduleWebAnimationsResolution();
     365#else
     366    // FIXME: We need to use the same logic as ScriptedAnimationController here,
     367    // which will be addressed by the refactor tracked by webkit.org/b/179293.
     368    m_animationResolutionTimer.stop();
     369#endif
     370}
     371
     372#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     373void DocumentTimeline::documentAnimationSchedulerDidFire()
     374#else
     375void DocumentTimeline::animationResolutionTimerFired()
     376#endif
     377{
     378    updateAnimationsAndSendEvents();
    344379    applyPendingAcceleratedAnimations();
    345 
    346     m_animationResolutionScheduled = false;
    347380    scheduleNextTick();
    348381}
    349382
    350 void DocumentTimeline::internalUpdateAnimationsAndSendEvents()
     383void DocumentTimeline::updateAnimationsAndSendEvents()
    351384{
    352385    m_numberOfAnimationTimelineInvalidationsForTesting++;
     386
     387    m_isUpdatingAnimations = true;
    353388
    354389    // https://drafts.csswg.org/web-animations/#update-animations-and-send-events
    … …  
    414449    for (auto& completedTransition : completedTransitions)
    415450        transitionDidComplete(completedTransition);
     451
     452    m_isUpdatingAnimations = false;
    416453}
    417454
    … …  
    437474    for (const auto& animation : m_animations) {
    438475        if (!animation->isRunningAccelerated()) {
    439             scheduleAnimationResolution();
     476            scheduleAnimationResolutionIfNeeded();
    440477            return;
    441478        }
    … …  
    447484        auto animationTimeToNextRequiredTick = animation->timeToNextTick();
    448485        if (animationTimeToNextRequiredTick < animationInterval()) {
    449             scheduleAnimationResolution();
     486            scheduleAnimationResolutionIfNeeded();
    450487            return;
    451488        }
    … …  
    557594{
    558595    auto animations = animationsForElement(element);
    559 
    560     if (animations.isEmpty()) {
    561         m_elementsWithRunningAcceleratedAnimations.remove(&element);
    562         return;
    563     }
    564 
     596    bool runningAnimationsForElementAreAllAccelerated = !animations.isEmpty();
    565597    for (const auto& animation : animations) {
    566598        if (!animation->isRunningAccelerated()) {
    567             m_elementsWithRunningAcceleratedAnimations.remove(&element);
    568             return;
    569         }
    570     }
    571 
    572     m_elementsWithRunningAcceleratedAnimations.add(&element);
     599            runningAnimationsForElementAreAllAccelerated = false;
     600            break;
     601        }
     602    }
     603
     604    if (runningAnimationsForElementAreAllAccelerated)
     605        m_elementsWithRunningAcceleratedAnimations.add(&element);
     606    else
     607        m_elementsWithRunningAcceleratedAnimations.remove(&element);
    573608}
    574609
    … …  
    591626bool DocumentTimeline::resolveAnimationsForElement(Element& element, RenderStyle& targetStyle)
    592627{
    593     bool hasNonAcceleratedAnimationProperty = false;
    594 
     628    bool hasNonAcceleratedAnimations = false;
     629    bool hasPendingAcceleratedAnimations = true;
    595630    for (const auto& animation : animationsForElement(element)) {
    596631        animation->resolve(targetStyle);
    597 
    598         if (hasNonAcceleratedAnimationProperty)
    599             continue;
    600 
    601         auto* effect = animation->effect();
    602         if (!effect || !is<KeyframeEffect>(effect))
    603             continue;
    604 
    605         auto* keyframeEffect = downcast<KeyframeEffect>(effect);
    606         for (auto cssPropertyId : keyframeEffect->animatedProperties()) {
    607             if (!CSSPropertyAnimation::animationOfPropertyIsAccelerated(cssPropertyId)) {
    608                 hasNonAcceleratedAnimationProperty = true;
    609                 break;
     632        if (!hasNonAcceleratedAnimations) {
     633            if (auto* effect = animation->effect()) {
     634                if (is<KeyframeEffect>(effect)) {
     635                    auto* keyframeEffect = downcast<KeyframeEffect>(effect);
     636                    for (auto cssPropertyId : keyframeEffect->animatedProperties()) {
     637                        if (!CSSPropertyAnimation::animationOfPropertyIsAccelerated(cssPropertyId)) {
     638                            hasNonAcceleratedAnimations = true;
     639                            continue;
     640                        }
     641                        if (!hasPendingAcceleratedAnimations)
     642                            hasPendingAcceleratedAnimations = keyframeEffect->hasPendingAcceleratedAction();
     643                    }
     644                }
    610645            }
    611646        }
    612647    }
    613648
    614     return !hasNonAcceleratedAnimationProperty;
     649    // If there are no non-accelerated animations and we've encountered at least one pending
     650    // accelerated animation, we should recomposite this element's layer for animation purposes.
     651    return !hasNonAcceleratedAnimations && hasPendingAcceleratedAnimations;
    615652}
    616653

  • trunk/Source/WebCore/animation/DocumentTimeline.h

    r242624 r242714  
    7272
    7373    void enqueueAnimationPlaybackEvent(AnimationPlaybackEvent&);
    74    
    75     void updateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp);
     74
     75#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     76    void documentAnimationSchedulerDidFire();
     77#endif
    7678
    7779    void updateThrottlingState();
    … …  
    8789    DocumentTimeline(Document&, Seconds);
    8890
    89     DOMHighResTimeStamp liveCurrentTime() const;
    90     void cacheCurrentTime(DOMHighResTimeStamp);
    91     void maybeClearCachedCurrentTime();
     91    Seconds liveCurrentTime() const;
     92    void cacheCurrentTime(Seconds);
     93    void scheduleAnimationResolutionIfNeeded();
    9294    void scheduleInvalidationTaskIfNeeded();
    9395    void performInvalidationTask();
     96    void animationScheduleTimerFired();
    9497    void scheduleAnimationResolution();
    9598    void unscheduleAnimationResolution();
    96     void internalUpdateAnimationsAndSendEvents();
     99    void updateAnimationsAndSendEvents();
    97100    void performEventDispatchTask();
     101    void maybeClearCachedCurrentTime();
    98102    void updateListOfElementsWithRunningAcceleratedAnimationsForElement(Element&);
    99103    void transitionDidComplete(RefPtr<CSSTransition>);
    100104    void scheduleNextTick();
     105
     106#if !USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     107    void animationResolutionTimerFired();
     108    Timer m_animationResolutionTimer;
     109#endif
    101110
    102111    Timer m_tickScheduleTimer;
    … …  
    111120    bool m_isSuspended { false };
    112121    bool m_waitingOnVMIdle { false };
    113     bool m_animationResolutionScheduled { false };
     122    bool m_isUpdatingAnimations { false };
    114123};
    115124

  • trunk/Source/WebCore/dom/Document.cpp

    r242696 r242714  
    5858#include "DateComponents.h"
    5959#include "DebugPageOverlays.h"
     60#include "DocumentAnimationScheduler.h"
    6061#include "DocumentLoader.h"
    6162#include "DocumentMarkerController.h"
    … …  
    19581959
    19591960        // Usually this is handled by post-layout.
    1960         if (!frameView.needsLayout())
     1961        if (!frameView.needsLayout()) {
    19611962            frameView.frame().selection().scheduleAppearanceUpdateAfterStyleChange();
     1963            if (m_needsForcedIntersectionObservationUpdate)
     1964                page()->scheduleForcedIntersectionObservationUpdate(*this);
     1965        }
    19621966
    19631967        // As a result of the style recalculation, the currently hovered element might have been
    … …  
    25562560    }
    25572561
     2562#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     2563    if (m_animationScheduler) {
     2564        m_animationScheduler->detachFromDocument();
     2565        m_animationScheduler = nullptr;
     2566    }
     2567#endif
     2568
    25582569#if ENABLE(CSS_PAINTING_API)
    25592570    for (auto& scope : m_paintWorkletGlobalScopes.values())
    … …  
    62526263}
    62536264
    6254 void Document::updateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp)
    6255 {
    6256     if (m_timeline)
    6257         m_timeline->updateAnimationsAndSendEvents(timestamp);
    6258 }
    6259 
    6260 void Document::serviceRequestAnimationFrameCallbacks(DOMHighResTimeStamp timestamp)
    6261 {
    6262     if (m_scriptedAnimationController)
    6263         m_scriptedAnimationController->serviceRequestAnimationFrameCallbacks(timestamp);
    6264 }
    6265 
    62666265void Document::windowScreenDidChange(PlatformDisplayID displayID)
    62676266{
     6267#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     6268    if (m_animationScheduler)
     6269        m_animationScheduler->windowScreenDidChange(displayID);
     6270#endif
     6271
    62686272    if (RenderView* view = renderView()) {
    62696273        if (view->usesCompositing())
    … …  
    79277931        return;
    79287932
     7933    m_needsForcedIntersectionObservationUpdate = false;
     7934
    79297935    for (const auto& observer : m_intersectionObservers) {
    79307936        bool needNotify = false;
    … …  
    80018007    if (m_intersectionObserversWithPendingNotifications.size())
    80028008        m_intersectionObserversNotifyTimer.startOneShot(0_s);
     8009}
     8010
     8011void Document::scheduleForcedIntersectionObservationUpdate()
     8012{
     8013    ASSERT(!m_intersectionObservers.isEmpty());
     8014    if (m_needsForcedIntersectionObservationUpdate)
     8015        return;
     8016
     8017    m_needsForcedIntersectionObservationUpdate = true;
     8018    if (auto* page = this->page())
     8019        page->scheduleForcedIntersectionObservationUpdate(*this);
    80038020}
    80048021
    … …  
    84368453}
    84378454
     8455#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     8456DocumentAnimationScheduler& Document::animationScheduler()
     8457{
     8458    if (!m_animationScheduler)
     8459        m_animationScheduler = DocumentAnimationScheduler::create(*this, page() ? page()->chrome().displayID() : 0);
     8460
     8461    return *m_animationScheduler;
     8462}
     8463#endif
     8464
    84388465DocumentTimeline& Document::timeline()
    84398466{

  • trunk/Source/WebCore/dom/Document.h

    r242696 r242714  
    109109class DatabaseThread;
    110110class DeferredPromise;
     111class DocumentAnimationScheduler;
    111112class DocumentFragment;
    112113class DocumentLoader;
    … …  
    10531054    void suspendScriptedAnimationControllerCallbacks();
    10541055    void resumeScriptedAnimationControllerCallbacks();
    1055 
    1056     void updateAnimationsAndSendEvents(DOMHighResTimeStamp timestamp);
    1057     void serviceRequestAnimationFrameCallbacks(DOMHighResTimeStamp timestamp);
    1058 
     1056   
    10591057    void windowScreenDidChange(PlatformDisplayID);
    10601058
    … …  
    14131411    void removeIntersectionObserver(IntersectionObserver&);
    14141412    unsigned numberOfIntersectionObservers() const { return m_intersectionObservers.size(); }
     1413    void scheduleForcedIntersectionObservationUpdate();
    14151414    void updateIntersectionObservations();
    14161415#endif
    … …  
    14851484    WEBCORE_EXPORT void setConsoleMessageListener(RefPtr<StringCallback>&&); // For testing.
    14861485
     1486#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     1487    DocumentAnimationScheduler& animationScheduler();
     1488#endif
     1489
    14871490    WEBCORE_EXPORT DocumentTimeline& timeline();
    14881491    DocumentTimeline* existingTimeline() const { return m_timeline.get(); }
    … …  
    20422045#endif
    20432046
     2047#if ENABLE(INTERSECTION_OBSERVER)
     2048    bool m_needsForcedIntersectionObservationUpdate { false };
     2049#endif
     2050
    20442051#if ENABLE(MEDIA_STREAM)
    20452052    HashSet<HTMLMediaElement*> m_mediaStreamStateChangeElements;
    … …  
    20612068    bool m_grantStorageAccessOverride { false };
    20622069
     2070#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     2071    RefPtr<DocumentAnimationScheduler> m_animationScheduler;
     2072#endif
    20632073    RefPtr<DocumentTimeline> m_timeline;
    20642074    DocumentIdentifier m_identifier;

  • trunk/Source/WebCore/dom/ScriptedAnimationController.cpp

    r242624 r242714  
    3131#include "DOMWindow.h"
    3232#include "Document.h"
     33#include "DocumentAnimationScheduler.h"
    3334#include "DocumentLoader.h"
    3435#include "Frame.h"
    … …  
    189190}
    190191
    191 void ScriptedAnimationController::serviceRequestAnimationFrameCallbacks(DOMHighResTimeStamp timestamp)
     192void ScriptedAnimationController::serviceScriptedAnimations(double timestamp)
    192193{
    193194    if (!m_callbacks.size() || m_suspendCount || !requestAnimationFrameEnabled())
    … …  
    197198
    198199    // We round this to the nearest microsecond so that we can return a time that matches what is returned by document.timeline.currentTime.
    199     DOMHighResTimeStamp highResNowMs = std::round(1000 * timestamp);
    200     DOMHighResTimeStamp legacyHighResNowMs = 1000 * (timestamp + m_document->loader()->timing().referenceWallTime().secondsSinceEpoch().seconds());
     200    double highResNowMs = std::round(1000 * timestamp);
     201    double legacyHighResNowMs = 1000 * (timestamp + m_document->loader()->timing().referenceWallTime().secondsSinceEpoch().seconds());
    201202
    202203    // First, generate a list of callbacks to consider.  Callbacks registered from this point
    … …  
    210211
    211212    for (auto& callback : callbacks) {
    212         if (callback->m_firedOrCancelled)
    213             continue;
    214         callback->m_firedOrCancelled = true;
    215         InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireAnimationFrame(protectedDocument, callback->m_id);
    216         if (callback->m_useLegacyTimeBase)
    217             callback->handleEvent(legacyHighResNowMs);
     213        if (!callback->m_firedOrCancelled) {
     214            callback->m_firedOrCancelled = true;
     215            InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireAnimationFrame(protectedDocument, callback->m_id);
     216            if (callback->m_useLegacyTimeBase)
     217                callback->handleEvent(legacyHighResNowMs);
     218            else
     219                callback->handleEvent(highResNowMs);
     220            InspectorInstrumentation::didFireAnimationFrame(cookie);
     221        }
     222    }
     223
     224    // Remove any callbacks we fired from the list of pending callbacks.
     225    for (size_t i = 0; i < m_callbacks.size();) {
     226        if (m_callbacks[i]->m_firedOrCancelled)
     227            m_callbacks.remove(i);
    218228        else
    219             callback->handleEvent(highResNowMs);
    220         InspectorInstrumentation::didFireAnimationFrame(cookie);
    221     }
    222 
    223     // Remove any callbacks we fired from the list of pending callbacks.
    224     m_callbacks.removeAllMatching([](auto& callback) {
    225         return callback->m_firedOrCancelled;
    226     });
     229            ++i;
     230    }
    227231
    228232    if (m_callbacks.size())
    … …  
    259263#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
    260264    if (!m_isUsingTimer && !isThrottled()) {
    261         if (auto* page = this->page()) {
    262             page->renderingUpdateScheduler().scheduleRenderingUpdate();
     265        if (m_document->animationScheduler().scheduleScriptedAnimationResolution())
    263266            return;
    264         }
    265267
    266268        m_isUsingTimer = true;
    … …  
    291293{
    292294    m_lastAnimationFrameTimestamp = m_document->domWindow()->nowTimestamp();
    293     serviceRequestAnimationFrameCallbacks(m_lastAnimationFrameTimestamp);
    294 }
    295 
    296 }
     295    serviceScriptedAnimations(m_lastAnimationFrameTimestamp);
     296}
     297
     298#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     299void ScriptedAnimationController::documentAnimationSchedulerDidFire()
     300{
     301    // We obtain the time from the animation scheduler so that we use the same timestamp as the DocumentTimeline.
     302    serviceScriptedAnimations(m_document->animationScheduler().lastTimestamp().seconds());
     303}
     304#endif
     305
     306}

  • trunk/Source/WebCore/dom/ScriptedAnimationController.h

    r242624 r242714  
    5353    CallbackId registerCallback(Ref<RequestAnimationFrameCallback>&&);
    5454    void cancelCallback(CallbackId);
    55     void serviceRequestAnimationFrameCallbacks(DOMHighResTimeStamp timestamp);
     55    void serviceScriptedAnimations(double timestamp);
    5656
    5757    void suspend();
    … …  
    6969    WEBCORE_EXPORT bool isThrottled() const;
    7070    WEBCORE_EXPORT Seconds interval() const;
     71
     72#if USE(REQUEST_ANIMATION_FRAME_DISPLAY_MONITOR)
     73    void documentAnimationSchedulerDidFire();
     74#endif
    7175
    7276private:

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

    r242624 r242714  
    19631963            renderView->updateVisibleViewportRect(visibleRect);
    19641964    });
     1965
     1966#if ENABLE(INTERSECTION_OBSERVER)
     1967    if (auto* document = frame().document()) {
     1968        if (auto* page = frame().page()) {
     1969            if (document->numberOfIntersectionObservers())
     1970                page->addDocumentNeedingIntersectionObservationUpdate(*document);
     1971            if (!frame().isMainFrame()) {
     1972                if (auto* mainDocument = frame().mainFrame().document()) {
     1973                    if (mainDocument->numberOfIntersectionObservers())
     1974                        page->addDocumentNeedingIntersectionObservationUpdate(*mainDocument);
     1975                }
     1976            }
     1977        }
     1978    }
     1979#endif
    19651980}
    19661981

  • trunk/Source/WebCore/page/IntersectionObserver.cpp

    r242624 r242714  
    158158    if (!hadObservationTargets)
    159159        document->addIntersectionObserver(*this);
     160    document->scheduleForcedIntersectionObservationUpdate();
    160161}
    161162

  • trunk/Source/WebCore/page/Page.cpp

    r242624 r242714  
    251251    , m_userContentProvider(*WTFMove(pageConfiguration.userContentProvider))
    252252    , m_visitedLinkStore(*WTFMove(pageConfiguration.visitedLinkStore))
     253#if ENABLE(INTERSECTION_OBSERVER)
     254    , m_intersectionObservationUpdateTimer(*this, &Page::updateIntersectionObservations)
     255#endif
    253256    , m_sessionID(PAL::SessionID::defaultSessionID())
    254257#if ENABLE(VIDEO)
    … …  
    11091112}
    11101113
     1114void Page::willDisplayPage()
     1115{
     1116#if ENABLE(INTERSECTION_OBSERVER)
     1117    updateIntersectionObservations();
     1118#endif
     1119}
     1120
    11111121bool Page::isOnlyNonUtilityPage() const
    11121122{
    … …  
    12501260}
    12511261
    1252 void Page::layoutIfNeeded()
    1253 {
    1254     if (FrameView* view = m_mainFrame->view())
    1255         view->updateLayoutAndStyleIfNeededRecursive();
    1256 }
    1257 
    1258 void Page::renderingUpdate()
    1259 {
    1260     // This function is not reentrant, e.g. a rAF callback may force repaint.
    1261     if (m_inRenderingUpdate) {
    1262         layoutIfNeeded();
    1263         return;
    1264     }
    1265 
    1266     SetForScope<bool> change(m_inRenderingUpdate, true);
    1267 
    1268     Vector<RefPtr<Document>> documents;
    1269 
    1270     // The requestAnimationFrame callbacks may change the frame hierarchy of the page
    1271     forEachDocument([&documents] (Document& document) {
    1272         documents.append(&document);
    1273     });
    1274 
    1275     for (auto& document : documents) {
    1276         DOMHighResTimeStamp timestamp = document->domWindow()->nowTimestamp();
    1277         document->updateAnimationsAndSendEvents(timestamp);
    1278         document->serviceRequestAnimationFrameCallbacks(timestamp);
    1279     }
    1280 
    1281     layoutIfNeeded();
    1282 
    1283     for (auto& document : documents) {
    12841262#if ENABLE(INTERSECTION_OBSERVER)
    1285         document->updateIntersectionObservations();
    1286 #endif
    1287     }
    1288 }
     1263void Page::addDocumentNeedingIntersectionObservationUpdate(Document& document)
     1264{
     1265    if (m_documentsNeedingIntersectionObservationUpdate.find(&document) == notFound)
     1266        m_documentsNeedingIntersectionObservationUpdate.append(makeWeakPtr(document));
     1267}
     1268
     1269void Page::updateIntersectionObservations()
     1270{
     1271    m_intersectionObservationUpdateTimer.stop();
     1272    for (const auto& document : m_documentsNeedingIntersectionObservationUpdate) {
     1273        if (document)
     1274            document->updateIntersectionObservations();
     1275    }
     1276    m_documentsNeedingIntersectionObservationUpdate.clear();
     1277}
     1278
     1279void Page::scheduleForcedIntersectionObservationUpdate(Document& document)
     1280{
     1281    addDocumentNeedingIntersectionObservationUpdate(document);
     1282    if (m_intersectionObservationUpdateTimer.isActive())
     1283        return;
     1284    m_intersectionObservationUpdateTimer.startOneShot(0_s);
     1285}
     1286#endif
    12891287
    12901288void Page::suspendScriptedAnimations()
    … …  
    28262824}
    28272825
    2828 RenderingUpdateScheduler& Page::renderingUpdateScheduler()
    2829 {
    2830     if (!m_renderingUpdateScheduler)
    2831         m_renderingUpdateScheduler = RenderingUpdateScheduler::create(*this);
    2832     return *m_renderingUpdateScheduler;
    2833 }
    2834 
    28352826void Page::forEachDocument(const Function<void(Document&)>& functor)
    28362827{

  • trunk/Source/WebCore/page/Page.h

    r242624 r242714  
    3434#include "Region.h"
    3535#include "RegistrableDomain.h"
    36 #include "RenderingUpdateScheduler.h"
    3736#include "ScrollTypes.h"
    3837#include "Supplementable.h"
    … …  
    264263    PerformanceMonitor* performanceMonitor() { return m_performanceMonitor.get(); }
    265264
    266     RenderingUpdateScheduler& renderingUpdateScheduler();
    267 
    268265    ValidationMessageClient* validationMessageClient() const { return m_validationMessageClient.get(); }
    269266    void updateValidationBubbleStateIfNeeded();
    … …  
    338335    void didFinishLoad(); // Called when the load has been committed in the main frame.
    339336
     337    WEBCORE_EXPORT void willDisplayPage();
     338
    340339    // The view scale factor is multiplied into the page scale factor by all
    341340    // callers of setPageScaleFactor.
    … …  
    465464    WEBCORE_EXPORT void removeActivityStateChangeObserver(ActivityStateChangeObserver&);
    466465
    467     WEBCORE_EXPORT void layoutIfNeeded();
    468     WEBCORE_EXPORT void renderingUpdate();
     466#if ENABLE(INTERSECTION_OBSERVER)
     467    void addDocumentNeedingIntersectionObservationUpdate(Document&);
     468    void scheduleForcedIntersectionObservationUpdate(Document&);
     469    void updateIntersectionObservations();
     470#endif
    469471
    470472    WEBCORE_EXPORT void suspendScriptedAnimations();
    … …  
    860862    int m_headerHeight { 0 };
    861863    int m_footerHeight { 0 };
    862 
    863     std::unique_ptr<RenderingUpdateScheduler> m_renderingUpdateScheduler;
    864864
    865865    HashSet<RenderObject*> m_relevantUnpaintedRenderObjects;
    … …  
    902902
    903903    HashSet<ActivityStateChangeObserver*> m_activityStateChangeObservers;
     904
     905#if ENABLE(INTERSECTION_OBSERVER)
     906    Vector<WeakPtr<Document>> m_documentsNeedingIntersectionObservationUpdate;
     907
     908    // FIXME: Schedule intersection observation updates in a way that fits into the HTML
     909    // EventLoop. See https://bugs.webkit.org/show_bug.cgi?id=160711.
     910    Timer m_intersectionObservationUpdateTimer;
     911#endif
    904912
    905913#if ENABLE(RESOURCE_USAGE)
    … …  
    963971    bool m_mediaPlaybackIsSuspended { false };
    964972    bool m_mediaBufferingIsSuspended { false };
    965     bool m_inRenderingUpdate { false };
    966973};
    967974

  • trunk/Source/WebCore/page/PageOverlayController.cpp

    r242624 r242714  
    319319void PageOverlayController::didChangeViewExposedRect()
    320320{
    321     m_page.renderingUpdateScheduler().scheduleRenderingUpdate();
     321    m_page.chrome().client().scheduleCompositingLayerFlush();
    322322}
    323323
    … …  
    413413void PageOverlayController::notifyFlushRequired(const WebCore::GraphicsLayer*)
    414414{
    415     m_page.renderingUpdateScheduler().scheduleRenderingUpdate();
     415    m_page.chrome().client().scheduleCompositingLayerFlush();
    416416}
    417417

  • trunk/Source/WebCore/page/ios/ContentChangeObserver.h

    r242689 r242714  
    2828#if PLATFORM(IOS_FAMILY)
    2929
    30 #include "Document.h"
    3130#include "PlatformEvent.h"
    32 #include "RenderStyleConstants.h"
    3331#include "Timer.h"
    3432#include "WKContentObservation.h"
    35 #include <wtf/HashSet.h>
    36 #include <wtf/Seconds.h>
    3733
    3834namespace WebCore {
    3935
    4036class DOMTimer;
    41 class Element;
     37class Document;
    4238
    4339class ContentChangeObserver {

  • trunk/Source/WebCore/page/mac/ServicesOverlayController.mm

    r242624 r242714  
    122122        return;
    123123
    124     m_controller->page().renderingUpdateScheduler().scheduleRenderingUpdate();
     124    m_controller->page().chrome().client().scheduleCompositingLayerFlush();
    125125}
    126126

  • trunk/Source/WebCore/rendering/RenderLayerCompositor.cpp

    r242624 r242714  
    432432{
    433433    m_hasPendingLayerFlush = false;
    434     page().renderingUpdateScheduler().scheduleRenderingUpdate();
     434    page().chrome().client().scheduleCompositingLayerFlush();
    435435}
    436436

  • trunk/Source/WebKit/ChangeLog

    r242713 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.cpp:
     14        (WebKit::DrawingAreaCoordinatedGraphics::scheduleCompositingLayerFlush):
     15        (WebKit::DrawingAreaCoordinatedGraphics::updateBackingStoreState):
     16        (WebKit::DrawingAreaCoordinatedGraphics::display):
     17        * WebProcess/WebPage/CoordinatedGraphics/LayerTreeHost.cpp:
     18        (WebKit::LayerTreeHost::layerFlushTimerFired):
     19        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
     20        (WebKit::RemoteLayerTreeDrawingArea::flushLayers):
     21        * WebProcess/WebPage/WebPage.cpp:
     22        (WebKit::WebPage::layoutIfNeeded):
     23        (WebKit::WebPage::willDisplayPage):
     24        (WebKit::WebPage::renderingUpdate): Deleted.
     25        * WebProcess/WebPage/WebPage.h:
     26        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
     27        (WebKit::TiledCoreAnimationDrawingArea::flushLayers):
     28
    1292019-03-11  Darin Adler  <darin@apple.com>
    230

  • trunk/Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/DrawingAreaCoordinatedGraphics.cpp

    r242643 r242714  
    304304    if (m_layerTreeHost)
    305305        m_layerTreeHost->scheduleLayerFlush();
    306     else
    307         setNeedsDisplay();
    308306}
    309307
    … …  
    384382        m_webPage.setDeviceScaleFactor(deviceScaleFactor);
    385383        m_webPage.setSize(size);
    386         m_webPage.renderingUpdate();
     384        m_webPage.layoutIfNeeded();
    387385        m_webPage.flushPendingEditorStateUpdate();
    388386        m_webPage.scrollMainFrameIfNotAtMaxScrollPosition(scrollOffset);
     387        m_webPage.willDisplayPage();
    389388
    390389        if (m_layerTreeHost)
    … …  
    705704    ASSERT(!m_webPage.size().isEmpty());
    706705
    707     m_webPage.renderingUpdate();
     706    m_webPage.layoutIfNeeded();
    708707    m_webPage.flushPendingEditorStateUpdate();
    709708
    … …  
    713712        return;
    714713
     714    m_webPage.willDisplayPage();
    715715    updateInfo.viewSize = m_webPage.size();
    716716    updateInfo.deviceScaleFactor = m_webPage.corePage()->deviceScaleFactor();

  • trunk/Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/LayerTreeHost.cpp

    r242624 r242714  
    146146
    147147    m_coordinator.syncDisplayState();
    148     m_webPage.renderingUpdate();
    149148    m_webPage.flushPendingEditorStateUpdate();
     149    m_webPage.willDisplayPage();
    150150
    151151    if (!m_isValid || !m_coordinator.rootCompositingLayer())

  • trunk/Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm

    r242624 r242714  
    350350    backingStoreCollection.willFlushLayers();
    351351
    352     m_webPage.renderingUpdate();
     352    m_webPage.layoutIfNeeded();
     353    m_webPage.willDisplayPage();
    353354
    354355    FloatRect visibleRect(FloatPoint(), m_viewSize);

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.cpp

    r242710 r242714  
    15551555}
    15561556
     1557void WebPage::layoutIfNeeded()
     1558{
     1559    if (m_mainFrame->coreFrame()->view())
     1560        m_mainFrame->coreFrame()->view()->updateLayoutAndStyleIfNeededRecursive();
     1561}
     1562
    15571563WebPage* WebPage::fromCorePage(Page* page)
    15581564{
    … …  
    35763582#endif
    35773583
    3578 void WebPage::layoutIfNeeded()
    3579 {
    3580     m_page->layoutIfNeeded();
    3581 }
    3582    
    3583 void WebPage::renderingUpdate()
    3584 {
    3585     m_page->renderingUpdate();
     3584void WebPage::willDisplayPage()
     3585{
     3586    m_page->willDisplayPage();
    35863587}
    35873588

  • trunk/Source/WebKit/WebProcess/WebPage/WebPage.h

    r242696 r242714  
    303303#endif
    304304
    305     void layoutIfNeeded();
    306     void renderingUpdate();
     305    void willDisplayPage();
    307306
    308307    enum class LazyCreationPolicy { UseExistingOnly, CreateIfNeeded };
    … …  
    337336    // FIXME: We could genericize these into a DrawingArea client interface. Would that be beneficial?
    338337    void drawRect(WebCore::GraphicsContext&, const WebCore::IntRect&);
     338    void layoutIfNeeded();
    339339
    340340    // -- Called from WebCore clients.

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

    r242687 r242714  
    6060#import <wtf/MachSendRight.h>
    6161#import <wtf/MainThread.h>
    62 #import <wtf/SystemTracing.h>
    6362
    6463#if ENABLE(ASYNC_SCROLLING)
    … …  
    461460        return;
    462461
    463     TraceScope traceScope(RenderingUpdateStart, RenderingUpdateEnd);
    464 
    465462    @autoreleasepool {
    466463        scaleViewToFitDocumentIfNeeded();
    467464
    468         m_webPage.renderingUpdate();
     465        m_webPage.layoutIfNeeded();
    469466        m_webPage.flushPendingEditorStateUpdate();
     467        m_webPage.willDisplayPage();
    470468
    471469        updateIntrinsicContentSizeIfNeeded();

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r242681 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * WebView/WebView.mm:
     14        (-[WebView _viewWillDrawInternal]):
     15
    1162019-03-09  Andy Estes  <aestes@apple.com>
    217

  • trunk/Source/WebKitLegacy/mac/WebView/WebView.mm

    r242624 r242714  
    16211621- (void)_viewWillDrawInternal
    16221622{
    1623     if (_private->page)
    1624         _private->page->renderingUpdate();
     1623    Frame* frame = [self _mainCoreFrame];
     1624    if (frame && frame->view())
     1625        frame->view()->updateLayoutAndStyleIfNeededRecursive();
    16251626}
    16261627

  • trunk/Source/WebKitLegacy/win/ChangeLog

    r242624 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * WebView.cpp:
     14        (WebView::updateBackingStore):
     15        (WebView::flushPendingGraphicsLayerChangesSoon):
     16        (WebView::flushPendingGraphicsLayerChanges):
     17
    1182019-03-07  Said Abou-Hallawa  <sabouhallawa@apple.com>
    219

  • trunk/Source/WebKitLegacy/win/WebView.cpp

    r242624 r242714  
    11741174    if (m_backingStoreBitmap && (m_backingStoreDirtyRegion || backingStoreCompletelyDirty)) {
    11751175        // Do a layout first so that everything we render to the backing store is always current.
    1176         m_page->renderingUpdate();
     1176        if (Frame* coreFrame = core(m_mainFrame))
     1177            if (FrameView* view = coreFrame->view())
     1178                view->updateLayoutAndStyleIfNeededRecursive();
    11771179
    11781180        Vector<IntRect> paintRects;
    … …  
    71587160{
    71597161#if USE(CA)
    7160     if (!m_layerTreeHost) {
    7161         m_page->renderingUpdate();
     7162    if (!m_layerTreeHost)
    71627163        return;
    7163     }
    71647164    m_layerTreeHost->flushPendingGraphicsLayerChangesSoon();
    71657165#elif USE(TEXTURE_MAPPER_GL)
    … …  
    73897389        return;
    73907390
    7391     m_page->renderingUpdate();
     7391    view->updateLayoutAndStyleIfNeededRecursive();
    73927392
    73937393    // Updating layout might have taken us out of compositing mode.

  • trunk/Tools/ChangeLog

    r242712 r242714  
     12019-03-11  Ryan Haddad  <ryanhaddad@apple.com>
     2
     3        Unreviewed, rolling out r242688, r242643, r242624.
     4
     5        Caused multiple layout test failures and crashes on iOS and macOS.
     6
     7        Reverted changeset:
     8
     9        "requestAnimationFrame should execute before the next frame"
     10        https://bugs.webkit.org/show_bug.cgi?id=177484
     11        https://trac.webkit.org/changeset/242624/webkit
     12
     13        * Tracing/SystemTracePoints.plist:
     14
    1152019-03-11  John Wilander  <wilander@apple.com>
    216

  • trunk/Tools/Tracing/SystemTracePoints.plist

    r242624 r242714  
    219219             <dict>
    220220                 <key>Name</key>
    221                  <string>Schedule rendering update</string>
    222                  <key>Type</key>
    223                  <string>Impulse</string>
    224                  <key>Component</key>
    225                  <string>47</string>
    226                  <key>Code</key>
    227                  <string>5028</string>
    228              </dict>
    229              <dict>
    230                  <key>Name</key>
    231                  <string>Trigger rendering update</string>
    232                  <key>Type</key>
    233                  <string>Impulse</string>
    234                  <key>Component</key>
    235                  <string>47</string>
    236                  <key>Code</key>
    237                  <string>5029</string>
    238              </dict>
    239              <dict>
    240                  <key>Name</key>
    241                  <string>Rendering update</string>
    242                  <key>Type</key>
    243                  <string>Interval</string>
    244                  <key>Component</key>
    245                  <string>47</string>
    246                  <key>CodeBegin</key>
    247                  <string>5030</string>
    248                  <key>CodeEnd</key>
    249                  <string>5031</string>
    250              </dict>
    251              <dict>
    252                  <key>Name</key>
    253221                 <string>Paint WebHTMLView</string>
    254222                 <key>Type</key>
Note: See TracChangeset for help on using the changeset viewer.