216122 2020-09-03 05:57:52 -0700 Consecutive requestAnimationFrame callbacks may be passed the same timestamp 2020-09-04 10:15:27 -0700 1 1 1 Unclassified WebKit Animations WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 graouts graouts cdumez dino esprehn+autocc ews-watchlist graouts kangil.han sabouhallawa simon.fraser webkit-bug-importer oldest_to_newest 1685231 0 graouts 2020-09-03 05:57:52 -0700 In some circumstances ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() may be called more than once with the same timestamp which means that requestAnimationFrame() callbacks may end up being called twice for the same timestamp. 1685232 1 graouts 2020-09-03 05:58:20 -0700 <rdar://problem/68269445> 1685234 2 407876 graouts 2020-09-03 06:02:35 -0700 Created attachment 407876 Patch 1685236 3 407878 graouts 2020-09-03 06:09:14 -0700 Created attachment 407878 Patch 1685289 4 ews-feeder 2020-09-03 09:31:10 -0700 Committed r266526: <https://trac.webkit.org/changeset/266526> All reviewed patches have been landed. Closing bug and clearing flags on attachment 407878. 1685320 5 407878 sabouhallawa 2020-09-03 10:20:45 -0700 Comment on attachment 407878 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=407878&action=review > Source/WebCore/dom/ScriptedAnimationController.cpp:101 > + return timestamp <= m_lastAnimationFrameTimestamp || (isThrottledRelativeToPage() && (timestamp - m_lastAnimationFrameTimestamp < preferredScriptedAnimationInterval())); How can this happen? timestamp should be always greater than m_lastAnimationFrameTimestamp. And assuming "timestamp < m_lastAnimationFrameTimestamp" can happen seems wrong. And rescheduling for the next rAF in this case looks wrong also. We already passed the timestamp the current rAF callbacks should be processed. What is the point in delaying processing them to the next rAF timestamp? So I assume to meant to check "timestamp == m_lastAnimationFrameTimestamp". But this should not happen also. ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() should be called only once for every document through Page::updateRendering(). If this happen either 1) we freezeNowTimestamp() more than we should. So multiple Page::updateRendering() get called with the same timestamp 2) or we call ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() multiple times from the same Page::updateRendering() while the timestamp is frozen. And none of them should happen. So I would expect the bug is somewhere else unless I am confused. But the neither the bug description nor the ChangeLog explains the cause of this bug. 1685579 6 graouts 2020-09-04 01:01:06 -0700 (In reply to Said Abou-Hallawa from comment #5) > Comment on attachment 407878 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=407878&action=review > > > Source/WebCore/dom/ScriptedAnimationController.cpp:101 > > + return timestamp <= m_lastAnimationFrameTimestamp || (isThrottledRelativeToPage() && (timestamp - m_lastAnimationFrameTimestamp < preferredScriptedAnimationInterval())); > > How can this happen? I don't have the answer to this question yet, I'm still investigating. > timestamp should be always greater than > m_lastAnimationFrameTimestamp. And assuming "timestamp < > m_lastAnimationFrameTimestamp" can happen seems wrong. And rescheduling for > the next rAF in this case looks wrong also. We already passed the timestamp > the current rAF callbacks should be processed. What is the point in delaying > processing them to the next rAF timestamp? Triggering two rounds of callbacks with the same timestamp tripped up two WPT tests: imported/w3c/web-platform-tests/css/css-animations/event-dispatch.tentative.html imported/w3c/web-platform-tests/web-animations/interfaces/Animation/onremove.html Those tests relied on the premise that a rAF callback being fired is indicative of "update the rendering" steps being ran. > So I assume to meant to check "timestamp == m_lastAnimationFrameTimestamp". > But this should not happen also. > ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() should > be called only once for every document through Page::updateRendering(). If > this happen either > > 1) we freezeNowTimestamp() more than we should. So multiple > Page::updateRendering() get called with the same timestamp > 2) or we call > ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() > multiple times from the same Page::updateRendering() while the timestamp is > frozen. > > And none of them should happen. So I would expect the bug is somewhere else > unless I am confused. But the neither the bug description nor the ChangeLog > explains the cause of this bug. Yes, I am investigating this still. However the codechange felt like a way to stabilize tests and address an obviously incorrect behavior while we look for the real culprit. Once that's done, we can change this to ASSERT(timestamp > m_lastAnimationFrameTimestamp). 1685582 7 graouts 2020-09-04 01:21:21 -0700 (In reply to Said Abou-Hallawa from comment #5) > 1) we freezeNowTimestamp() more than we should. So multiple > Page::updateRendering() get called with the same timestamp This is not happening, the unfrozen timestamp returned by document.domWindow()->performance().now() is the same. > 2) or we call > ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() > multiple times from the same Page::updateRendering() while the timestamp is > frozen. That is not happening either, m_renderingUpdateCount is increasing between calls to ScriptedAnimationController::serviceRequestAnimationFrameCallbacks() with the same timestamp. 1685590 8 graouts 2020-09-04 02:35:07 -0700 Added some logging, here's a sequence of calls that eventually leads to a case where timestamp == m_lastAnimationFrameTimestamp. 02:26:37.313047-0700 TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() 02:26:37.313127-0700 [0x10dcdcb00] Page::updateRendering(), updates = 0 02:26:37.313313-0700 [page 0x10dcdcb00, document 0x10dbe5780] now = 4.000000s, updates = 0 02:26:37.327353-0700 TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() 02:26:37.327383-0700 [0x10dcdcb00] Page::updateRendering(), updates = 1 02:26:37.327564-0700 [page 0x10dcdcb00, document 0x10dbe5780] now = 18.000000s, updates = 1 02:26:37.327940-0700 TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() 02:26:37.327960-0700 [0x10dcdcb00] Page::updateRendering(), updates = 2 02:26:37.327974-0700 [page 0x10dcdcb00, document 0x10dbe5780] now = 19.000000s, updates = 2 02:26:37.333055-0700 TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() 02:26:37.333077-0700 [0x10dcdcb00] Page::updateRendering(), updates = 3 02:26:37.333098-0700 [page 0x10dcdcb00, document 0x10dbe5780] now = 24.000000s, updates = 3 02:26:37.352863-0700 TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() 02:26:37.352893-0700 [0x10dcdcb00] Page::updateRendering(), updates = 4 02:26:37.352932-0700 [page 0x10dcdcb00, document 0x10dbe6430] now = 17.000000s, updates = 4 02:26:37.352948-0700 serviceRequestAnimationFrameCallbacks(), timestamp = 0.017000s, m_lastAnimationFrameTimestamp = 0.000000s 02:26:37.353653-0700 TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() 02:26:37.353676-0700 [0x10dcdcb00] Page::updateRendering(), updates = 5 02:26:37.353693-0700 [page 0x10dcdcb00, document 0x10dbe6430] now = 17.000000s, updates = 5 02:26:37.353708-0700 serviceRequestAnimationFrameCallbacks(), timestamp = 0.017000s, m_lastAnimationFrameTimestamp = 0.017000s All the calls come from TiledCoreAnimationDrawingArea::updateRenderingRunLoopCallback() and the two consecutive calls to that function come within 0.79ms (02:26:37.352863 and 02:26:37.353653) explaining why performance.now() returns the same value since I expect it's not expected to have more than 1ms-accuracy. 1685722 9 sabouhallawa 2020-09-04 10:00:04 -0700 Okay I see. RenderingUpdateScheduler can schedule a renderingUpdate at the next DisplayRefreshMonitor interval. This ensures there is a least 16ms between two consecutive renderingUpdates. But RenderingUpdateScheduler also can schedule an immediate renderingUpdate which asks for a renderingUpdate at the next run-loop. See RenderingUpdateScheduler::scheduleRenderingUpdate(). So it seems what is happening with the flaky tests is we schedule an immediate renderingUpdate which is fast enough to hit the same timestamp we used in the previous renderingUpdate. So I think the patch is okay. But maybe the right thing to do is to ensure rAF is served after at least 16ms bool ScriptedAnimationController::shouldRescheduleRequestAnimationFrame(ReducedResolutionSeconds timestamp) const { << return timestamp <= m_lastAnimationFrameTimestamp || (isThrottledRelativeToPage() && (timestamp - m_lastAnimationFrameTimestamp < preferredScriptedAnimationInterval())); >> return timestamp - m_lastAnimationFrameTimestamp < preferredScriptedAnimationInterval()); } I think, if the difference between timestamp and m_lastAnimationFrameTimestamp is 1ms for example, rAF should not be served. The reason for adding the immediate renderingUpdate scheduling is in some cases we want to update the page urgently and we can not wait for the next DisplayRefreshMonitor interval. But I think rAF never needs to be served in this case. 1685732 10 graouts 2020-09-04 10:15:27 -0700 (In reply to Said Abou-Hallawa from comment #9) > Okay I see. > > RenderingUpdateScheduler can schedule a renderingUpdate at the next > DisplayRefreshMonitor interval. This ensures there is a least 16ms between > two consecutive renderingUpdates. > > But RenderingUpdateScheduler also can schedule an immediate renderingUpdate > which asks for a renderingUpdate at the next run-loop. See > RenderingUpdateScheduler::scheduleRenderingUpdate(). > > So it seems what is happening with the flaky tests is we schedule an > immediate renderingUpdate which is fast enough to hit the same timestamp we > used in the previous renderingUpdate. > > So I think the patch is okay. But maybe the right thing to do is to ensure > rAF is served after at least 16ms > > bool > ScriptedAnimationController:: > shouldRescheduleRequestAnimationFrame(ReducedResolutionSeconds timestamp) > const > { > << return timestamp <= m_lastAnimationFrameTimestamp || > (isThrottledRelativeToPage() && (timestamp - m_lastAnimationFrameTimestamp < > preferredScriptedAnimationInterval())); > >> return timestamp - m_lastAnimationFrameTimestamp < preferredScriptedAnimationInterval()); > } > > I think, if the difference between timestamp and > m_lastAnimationFrameTimestamp is 1ms for example, rAF should not be served. > The reason for adding the immediate renderingUpdate scheduling is in some > cases we want to update the page urgently and we can not wait for the next > DisplayRefreshMonitor interval. But I think rAF never needs to be served in > this case. I think we need to consider the other steps under Page::updateRendering(). This patch addressed requestAnimationFrame() callbacks but updating animations is another step that likely shouldn’t be performed until the next “real” frame. I guess we need to distinguish between the work required internally to update the rendering and what is Web-observable. 407876 2020-09-03 06:02:35 -0700 2020-09-03 06:09:11 -0700 Patch bug-216122-20200903150234.patch text/plain 4233 graouts U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2Mzg2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2ExZWU1Njg3ODkxYTZk ZDNkZTIxZWMxYWExN2E1NDIyMDAyNTExMi4uNWIyNTBmNDdiNDM0ODU3MDI3MDBiZmIyZDU3YmJh ODU3OWI5NWUzYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDIwLTA5LTAzICBBbnRv aW5lIFF1aW50ICA8Z3Jhb3V0c0B3ZWJraXQub3JnPgorCisgICAgICAgIENvbnNlY3V0aXZlIHJl cXVlc3RBbmltYXRpb25GcmFtZSBjYWxsYmFja3MgbWF5IGJlIHBhc3NlZCB0aGUgc2FtZSB0aW1l c3RhbXAKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIx NjEyMgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjgyNjk0NDU+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFzdC9hbmltYXRpb24vcmVx dWVzdC1hbmltYXRpb24tZnJhbWUtdW5pcXVlLXRpbWVzdGFtcC5odG1sCisKKyAgICAgICAgRW5z dXJlIHRoYXQgdGhlIHBhZ2Ugb25seSBzZWVzIGluY3JlYXNpbmcgdGltZXN0YW1wcyBpbiByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUoKSBjYWxsYmFja3MuCisKKyAgICAgICAgKiBkb20vU2NyaXB0ZWRB bmltYXRpb25Db250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcjo6c2hvdWxkUmVzY2hlZHVsZVJlcXVlc3RBbmltYXRpb25GcmFtZSBjb25z dCk6CisKIDIwMjAtMDgtMzEgIE1hcmsgTGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAg ICAgIE1pc3NpbmcgZXhjZXB0aW9uIGNoZWNrIHdoaWxlIGhhbmRsaW5nIHRoZSBvbmJlZm9yZXVu bG9hZCBldmVudC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1h dGlvbkNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9u Q29udHJvbGxlci5jcHAKaW5kZXggYTZmZjU1NWFmZjcyMjkzNTVhM2FmZjIyMTA3NThlYzg1NDM5 OTNiMi4uZjE1NGE0ZWUwOWU3OWIwNzU3NDY1N2M2OGVmODU2ZWE5ZGEwMmUzMSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKQEAg LTk4LDcgKzk4LDcgQEAgYm9vbCBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OmlzVGhyb3R0 bGVkUmVsYXRpdmVUb1BhZ2UoKSBjb25zdAogCiBib29sIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlcjo6c2hvdWxkUmVzY2hlZHVsZVJlcXVlc3RBbmltYXRpb25GcmFtZShSZWR1Y2VkUmVzb2x1 dGlvblNlY29uZHMgdGltZXN0YW1wKSBjb25zdAogewotICAgIHJldHVybiBpc1Rocm90dGxlZFJl bGF0aXZlVG9QYWdlKCkgJiYgKHRpbWVzdGFtcCAtIG1fbGFzdEFuaW1hdGlvbkZyYW1lVGltZXN0 YW1wIDwgcHJlZmVycmVkU2NyaXB0ZWRBbmltYXRpb25JbnRlcnZhbCgpKTsKKyAgICByZXR1cm4g dGltZXN0YW1wIDw9IG1fbGFzdEFuaW1hdGlvbkZyYW1lVGltZXN0YW1wIHx8IChpc1Rocm90dGxl ZFJlbGF0aXZlVG9QYWdlKCkgJiYgKHRpbWVzdGFtcCAtIG1fbGFzdEFuaW1hdGlvbkZyYW1lVGlt ZXN0YW1wIDwgcHJlZmVycmVkU2NyaXB0ZWRBbmltYXRpb25JbnRlcnZhbCgpKSk7CiB9CiAKIFNj cmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Q2FsbGJhY2tJZCBTY3JpcHRlZEFuaW1hdGlvbkNv bnRyb2xsZXI6OnJlZ2lzdGVyQ2FsbGJhY2soUmVmPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrPiYmIGNhbGxiYWNrKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGVmYWVmODI0M2M0MTM5ZWE4ZGRmZmVlOGRjNmYwN2E0 NzI5MDg0ZTMuLjVjOTk0Y2MzZTEyYmVkMWI4NmVkOWQ1ZmY5ZjkzZjU5ZTkyY2MzMDQgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwxNyBAQAorMjAyMC0wOS0wMyAgQW50b2luZSBRdWludCAgPGdyYW91dHNAd2Vi a2l0Lm9yZz4KKworICAgICAgICBDb25zZWN1dGl2ZSByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2Fs bGJhY2tzIG1heSBiZSBwYXNzZWQgdGhlIHNhbWUgdGltZXN0YW1wCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMjIKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzY4MjY5NDQ1PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBhIHRlc3QgdGhhdCB0d28gc3Vic2VxdWVudCBhbmltYXRpb24gZnJhbWVz IGFzIGlkZW50aWZpZWQgdmlhIHJlcXVlc3RBbmltYXRpb25GcmFtZSgpIGNhbGxiYWNrcworICAg ICAgICBhcmUgcHJvdmlkZWQgaW5jcmVhc2luZyB0aW1lc3RhbXBzLgorCisgICAgICAgICogZmFz dC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtdW5pcXVlLXRpbWVzdGFtcC1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0 aW9uLWZyYW1lLXVuaXF1ZS10aW1lc3RhbXAuaHRtbDogQWRkZWQuCisKIDIwMjAtMDgtMzEgIENv bW1pdCBRdWV1ZSAgPGNvbW1pdC1xdWV1ZUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3 ZWQsIHJldmVydGluZyByMjY2Mzc4IGFuZCByMjY2MzgxLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtdW5pcXVlLXRpbWVzdGFt cC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1h dGlvbi1mcmFtZS11bmlxdWUtdGltZXN0YW1wLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lZTU4 YzE1Njg1OTQzZDUyZjhmMDNmNWRiYTI1Y2RjOTRhMDRiZDkyCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtdW5pcXVl LXRpbWVzdGFtcC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwzIEBACisKK1BBU1MgVGltZXN0YW1w cyBvZiByZXF1ZXN0QW5pbWF0aW9uRnJhbWUoKSBjYWxsYmFja3MgaW5jcmVhc2UuIAorCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFt ZS11bmlxdWUtdGltZXN0YW1wLmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlvbi9yZXF1 ZXN0LWFuaW1hdGlvbi1mcmFtZS11bmlxdWUtdGltZXN0YW1wLmh0bWwKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNjJm NDI5NTE2NTEyODI5MDI5MDJjMzczMzU0YmU0OTg0ZTJkZDA0NgotLS0gL2Rldi9udWxsCisrKyBi L0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLXVuaXF1 ZS10aW1lc3RhbXAuaHRtbApAQCAtMCwwICsxLDE2IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1s PgorPGJvZHk+Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL3Rlc3RoYXJuZXNzLmpzIj48 L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9yZXNvdXJjZXMvdGVzdGhhcm5lc3NyZXBvcnQu anMiPjwvc2NyaXB0PgorPHNjcmlwdD4KKworcHJvbWlzZV90ZXN0KGFzeW5jIHQgPT4geworCWxl dCBmaXJzdEZyYW1lVGltZXN0YW1wID0gYXdhaXQgbmV3IFByb21pc2UocmVxdWVzdEFuaW1hdGlv bkZyYW1lKTsKKwlsZXQgc2Vjb25kRnJhbWVUaW1lc3RhbXAgPSBhd2FpdCBuZXcgUHJvbWlzZShy ZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOworCWFzc2VydF9ncmVhdGVyX3RoYW4oc2Vjb25kRnJhbWVU aW1lc3RhbXAsIGZpcnN0RnJhbWVUaW1lc3RhbXApOworfSwgIlRpbWVzdGFtcHMgb2YgcmVxdWVz dEFuaW1hdGlvbkZyYW1lKCkgY2FsbGJhY2tzIGluY3JlYXNlLiIpOworCis8L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4K 407878 2020-09-03 06:09:14 -0700 2020-09-03 09:31:11 -0700 Patch bug-216122-20200903150913.patch text/plain 6170 graouts U3VidmVyc2lvbiBSZXZpc2lvbjogMjY2Mzg2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2ExZWU1Njg3ODkxYTZk ZDNkZTIxZWMxYWExN2E1NDIyMDAyNTExMi4uNWIyNTBmNDdiNDM0ODU3MDI3MDBiZmIyZDU3YmJh ODU3OWI5NWUzYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDIwLTA5LTAzICBBbnRv aW5lIFF1aW50ICA8Z3Jhb3V0c0B3ZWJraXQub3JnPgorCisgICAgICAgIENvbnNlY3V0aXZlIHJl cXVlc3RBbmltYXRpb25GcmFtZSBjYWxsYmFja3MgbWF5IGJlIHBhc3NlZCB0aGUgc2FtZSB0aW1l c3RhbXAKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIx NjEyMgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjgyNjk0NDU+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogZmFzdC9hbmltYXRpb24vcmVx dWVzdC1hbmltYXRpb24tZnJhbWUtdW5pcXVlLXRpbWVzdGFtcC5odG1sCisKKyAgICAgICAgRW5z dXJlIHRoYXQgdGhlIHBhZ2Ugb25seSBzZWVzIGluY3JlYXNpbmcgdGltZXN0YW1wcyBpbiByZXF1 ZXN0QW5pbWF0aW9uRnJhbWUoKSBjYWxsYmFja3MuCisKKyAgICAgICAgKiBkb20vU2NyaXB0ZWRB bmltYXRpb25Db250cm9sbGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdGVkQW5pbWF0 aW9uQ29udHJvbGxlcjo6c2hvdWxkUmVzY2hlZHVsZVJlcXVlc3RBbmltYXRpb25GcmFtZSBjb25z dCk6CisKIDIwMjAtMDgtMzEgIE1hcmsgTGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAg ICAgIE1pc3NpbmcgZXhjZXB0aW9uIGNoZWNrIHdoaWxlIGhhbmRsaW5nIHRoZSBvbmJlZm9yZXVu bG9hZCBldmVudC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRlZEFuaW1h dGlvbkNvbnRyb2xsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9u Q29udHJvbGxlci5jcHAKaW5kZXggYTZmZjU1NWFmZjcyMjkzNTVhM2FmZjIyMTA3NThlYzg1NDM5 OTNiMi4uZjE1NGE0ZWUwOWU3OWIwNzU3NDY1N2M2OGVmODU2ZWE5ZGEwMmUzMSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlci5jcHAKQEAg LTk4LDcgKzk4LDcgQEAgYm9vbCBTY3JpcHRlZEFuaW1hdGlvbkNvbnRyb2xsZXI6OmlzVGhyb3R0 bGVkUmVsYXRpdmVUb1BhZ2UoKSBjb25zdAogCiBib29sIFNjcmlwdGVkQW5pbWF0aW9uQ29udHJv bGxlcjo6c2hvdWxkUmVzY2hlZHVsZVJlcXVlc3RBbmltYXRpb25GcmFtZShSZWR1Y2VkUmVzb2x1 dGlvblNlY29uZHMgdGltZXN0YW1wKSBjb25zdAogewotICAgIHJldHVybiBpc1Rocm90dGxlZFJl bGF0aXZlVG9QYWdlKCkgJiYgKHRpbWVzdGFtcCAtIG1fbGFzdEFuaW1hdGlvbkZyYW1lVGltZXN0 YW1wIDwgcHJlZmVycmVkU2NyaXB0ZWRBbmltYXRpb25JbnRlcnZhbCgpKTsKKyAgICByZXR1cm4g dGltZXN0YW1wIDw9IG1fbGFzdEFuaW1hdGlvbkZyYW1lVGltZXN0YW1wIHx8IChpc1Rocm90dGxl ZFJlbGF0aXZlVG9QYWdlKCkgJiYgKHRpbWVzdGFtcCAtIG1fbGFzdEFuaW1hdGlvbkZyYW1lVGlt ZXN0YW1wIDwgcHJlZmVycmVkU2NyaXB0ZWRBbmltYXRpb25JbnRlcnZhbCgpKSk7CiB9CiAKIFNj cmlwdGVkQW5pbWF0aW9uQ29udHJvbGxlcjo6Q2FsbGJhY2tJZCBTY3JpcHRlZEFuaW1hdGlvbkNv bnRyb2xsZXI6OnJlZ2lzdGVyQ2FsbGJhY2soUmVmPFJlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxi YWNrPiYmIGNhbGxiYWNrKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGVmYWVmODI0M2M0MTM5ZWE4ZGRmZmVlOGRjNmYwN2E0 NzI5MDg0ZTMuLjBmZmM4OTZlNDEyNTNmYmJjM2QwNTk5ZmEzZDg2MzA1ZGNlNDExM2UgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cK QEAgLTEsMyArMSwyMCBAQAorMjAyMC0wOS0wMyAgQW50b2luZSBRdWludCAgPGdyYW91dHNAd2Vi a2l0Lm9yZz4KKworICAgICAgICBDb25zZWN1dGl2ZSByZXF1ZXN0QW5pbWF0aW9uRnJhbWUgY2Fs bGJhY2tzIG1heSBiZSBwYXNzZWQgdGhlIHNhbWUgdGltZXN0YW1wCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTYxMjIKKyAgICAgICAgPHJkYXI6Ly9w cm9ibGVtLzY4MjY5NDQ1PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBhIHRlc3QgdGhhdCB0d28gc3Vic2VxdWVudCBhbmltYXRpb24gZnJhbWVz IGFzIGlkZW50aWZpZWQgdmlhIHJlcXVlc3RBbmltYXRpb25GcmFtZSgpIGNhbGxiYWNrcworICAg ICAgICBhcmUgcHJvdmlkZWQgaW5jcmVhc2luZyB0aW1lc3RhbXBzLgorCisgICAgICAgIEFsc28g cmVtb3ZpbmcgZmxha3kgZXhwZWN0YXRpb24gZm9yIHR3byBXUFQgYW5pbWF0aW9ucyB0ZXN0cyB3 aGljaCBwYXNzIHJlbGlhYmx5IGFmdGVyIHRoaXMgZml4LiAKKworICAgICAgICAqIGZhc3QvYW5p bWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLXVuaXF1ZS10aW1lc3RhbXAtZXhwZWN0ZWQu dHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1m cmFtZS11bmlxdWUtdGltZXN0YW1wLmh0bWw6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3JtL21h Yy13azIvVGVzdEV4cGVjdGF0aW9uczoKKwogMjAyMC0wOC0zMSAgQ29tbWl0IFF1ZXVlICA8Y29t bWl0LXF1ZXVlQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcmV2ZXJ0aW5nIHIy NjYzNzggYW5kIHIyNjYzODEuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2FuaW1hdGlv bi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS11bmlxdWUtdGltZXN0YW1wLWV4cGVjdGVkLnR4dCBi L0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLXVuaXF1 ZS10aW1lc3RhbXAtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmVlNThjMTU2ODU5NDNkNTJmOGYw M2Y1ZGJhMjVjZGM5NGEwNGJkOTIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2FuaW1hdGlvbi9yZXF1ZXN0LWFuaW1hdGlvbi1mcmFtZS11bmlxdWUtdGltZXN0YW1wLWV4cGVj dGVkLnR4dApAQCAtMCwwICsxLDMgQEAKKworUEFTUyBUaW1lc3RhbXBzIG9mIHJlcXVlc3RBbmlt YXRpb25GcmFtZSgpIGNhbGxiYWNrcyBpbmNyZWFzZS4gCisKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZyYW1lLXVuaXF1ZS10aW1lc3Rh bXAuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvYW5pbWF0aW9uL3JlcXVlc3QtYW5pbWF0aW9uLWZy YW1lLXVuaXF1ZS10aW1lc3RhbXAuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42MmY0Mjk1MTY1MTI4MjkwMjkw MmMzNzMzNTRiZTQ5ODRlMmRkMDQ2Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9hbmltYXRpb24vcmVxdWVzdC1hbmltYXRpb24tZnJhbWUtdW5pcXVlLXRpbWVzdGFtcC5odG1s CkBAIC0wLDAgKzEsMTYgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxzY3Jp cHQgc3JjPSIuLi8uLi9yZXNvdXJjZXMvdGVzdGhhcm5lc3MuanMiPjwvc2NyaXB0PgorPHNjcmlw dCBzcmM9Ii4uLy4uL3Jlc291cmNlcy90ZXN0aGFybmVzc3JlcG9ydC5qcyI+PC9zY3JpcHQ+Cis8 c2NyaXB0PgorCitwcm9taXNlX3Rlc3QoYXN5bmMgdCA9PiB7CisJbGV0IGZpcnN0RnJhbWVUaW1l c3RhbXAgPSBhd2FpdCBuZXcgUHJvbWlzZShyZXF1ZXN0QW5pbWF0aW9uRnJhbWUpOworCWxldCBz ZWNvbmRGcmFtZVRpbWVzdGFtcCA9IGF3YWl0IG5ldyBQcm9taXNlKHJlcXVlc3RBbmltYXRpb25G cmFtZSk7CisJYXNzZXJ0X2dyZWF0ZXJfdGhhbihzZWNvbmRGcmFtZVRpbWVzdGFtcCwgZmlyc3RG cmFtZVRpbWVzdGFtcCk7Cit9LCAiVGltZXN0YW1wcyBvZiByZXF1ZXN0QW5pbWF0aW9uRnJhbWUo KSBjYWxsYmFja3MgaW5jcmVhc2UuIik7CisKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhwZWN0YXRpb25z IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjLXdrMi9UZXN0RXhwZWN0YXRpb25zCmluZGV4IGZj Y2YyOTg3OWViYzYwNmU5YWJiZTliOWY2MmJhNTg4NjQ2MzZhN2QuLmIzYTg5MjZhNmYxMWJkYjMw Y2UyMjUxYzQ0NTEzM2RhMzI3MDUxM2YgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3Jt L21hYy13azIvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMt d2syL1Rlc3RFeHBlY3RhdGlvbnMKQEAgLTEyNTAsOSArMTI1MCw2IEBAIHdlYmtpdC5vcmcvYi8x Nzk3OTYgaHR0cC90ZXN0cy9jYWNoZS9kaXNrLWNhY2hlL2Rpc2stY2FjaGUtdmFsaWRhdGlvbi1i YWNrLW5hdmlnCiBbIGFybTY0IF0gaW5zcGVjdG9yL2NhbnZhcy9tZW1vcnkuaHRtbCBbIEZhaWx1 cmUgXQogWyBhcm02NCBdIG1lZGlhL3ZpZGVvLWNhbnZhcy1jcmVhdGVQYXR0ZXJuLmh0bWwgWyBG YWlsdXJlIF0KIAotIyByZGFyOi8vNjY3OTg3NTEgKFJFR1JFU1NJT04gKDIwQTIzMjFhLTIwQTIz MjdhKTogaW1wb3J0ZWQvdzNjL3dlYi1wbGF0Zm9ybS10ZXN0cy9jc3MvY3NzLWFuaW1hdGlvbnMv ZXZlbnQtZGlzcGF0Y2gudGVudGF0aXZlLmh0bWwgaXMgYSBmbGFreSBmYWlsdXJlKQotWyBhcm02 NCBdIGltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0tdGVzdHMvY3NzL2Nzcy1hbmltYXRpb25zL2V2 ZW50LWRpc3BhdGNoLnRlbnRhdGl2ZS5odG1sIFsgUGFzcyBGYWlsdXJlIF0KLQogIyByZGFyOi8v NjY4MDYwNTkgKFJFR1JFU1NJT04gKDIwQTIzMjFhLTIwQTIzNDhiKTogNCBmYXN0IGhpZHBpIHRl c3RzIGFyZSBhIGZsYWt5IGltYWdlIGZhaWx1cmUpCiBbIGFybTY0IF0gZmFzdC9mbGV4Ym94L2hp ZHBpLXNpbXBsZS1saW5lLWxheW91dC13aXRoLWZsZXhib3gtYW5kLXRyYW5zaXRpb24uaHRtbCBb IEltYWdlT25seUZhaWx1cmUgXQogWyBhcm02NCBdIGZhc3QvZm9ybXMvaGlkcGktZmllbGRzZXQt b24tc3VicGl4ZWwtcG9zaXRpb24td2hlbi1sZWdlbmQtaXMtcHJlc2VudC5odG1sIFsgSW1hZ2VP bmx5RmFpbHVyZSBdCkBAIC0xMjYyLDkgKzEyNTksNiBAQCB3ZWJraXQub3JnL2IvMTc5Nzk2IGh0 dHAvdGVzdHMvY2FjaGUvZGlzay1jYWNoZS9kaXNrLWNhY2hlLXZhbGlkYXRpb24tYmFjay1uYXZp ZwogIyByZGFyOi8vNjY4MDc1NTQKIFsgYXJtNjQgXSBpbXBvcnRlZC93M2Mvd2ViLXBsYXRmb3Jt LXRlc3RzL2Nzcy9jc3MtdHJhbnNpdGlvbnMvdHJhbnNpdGlvbi1iYXNlLXJlc3BvbnNlLTAwMi5o dG1sICBbIEZhaWx1cmUgXQogCi0jIHJkYXI6Ly82NjgwODIyOCAoUkVHUkVTU0lPTiAoMjBBMjMy MWEtMjBBMjM0OGIpOiBpbXBvcnRlZC93M2Mvd2ViLXBsYXRmb3JtLXRlc3RzL3dlYi1hbmltYXRp b25zL2ludGVyZmFjZXMvQW5pbWF0aW9uL29ucmVtb3ZlLmh0bWwgaXMgYSBmbGFreSBmYWlsdXJl KQotWyBhcm02NCBdIGltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0tdGVzdHMvd2ViLWFuaW1hdGlv bnMvaW50ZXJmYWNlcy9BbmltYXRpb24vb25yZW1vdmUuaHRtbCBbIEZhaWx1cmUgXQotCiB3ZWJr aXQub3JnL2IvMjE1NTgxIGltcG9ydGVkL3czYy93ZWItcGxhdGZvcm0tdGVzdHMvd2VicnRjL1JU Q1J0cFJlY2VpdmVyLWdldFN0YXRzLmh0dHBzLmh0bWwgWyBQYXNzIEZhaWx1cmUgXQogCiB3ZWJr aXQub3JnL2IvMjE1NjA2IHdlYmdwdS93aGxzbC9kby13aGlsZS1sb29wLWJyZWFrLmh0bWwgWyBQ YXNzIEZhaWx1cmUgXQo=