205734 2020-01-03 10:58:58 -0800 REGRESSION: [ Mac ] fast/canvas/webgl/texImage2D-video-flipY-false.html is Timing out 2020-11-17 11:31:03 -0800 1 1 1 Unclassified WebKit WebGL WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=205483 https://bugs.webkit.org/show_bug.cgi?id=207857 https://bugs.webkit.org/show_bug.cgi?id=209837 https://bugs.webkit.org/show_bug.cgi?id=218971 https://bugs.webkit.org/show_bug.cgi?id=216915 InRadar P2 Normal --- 200904 205483 212260 207857 209837 1 tsavell kbr commit-queue dino eric.carlson ews-watchlist glenn jacob_uphoff jdarpinian jer.noble kbr philipj sergio webkit-bot-watchers-bugzilla webkit-bug-importer oldest_to_newest 1602513 0 tsavell 2020-01-03 10:58:58 -0800 fast/canvas/webgl/texImage2D-video-flipY-false.html Description: This test began timing out flakily after https://trac.webkit.org/changeset/253926/webkit History: https://results.webkit.org/?suite=layout-tests&test=fast%2Fcanvas%2Fwebgl%2FtexImage2D-video-flipY-false.html 1602514 1 webkit-bug-importer 2020-01-03 10:59:18 -0800 <rdar://problem/58302063> 1602717 2 ap 2020-01-03 20:02:18 -0800 rdar://problem/58228020 1620336 3 kbr 2020-02-18 14:48:13 -0800 I'll investigate. 1621332 4 kbr 2020-02-20 11:35:08 -0800 Presumably this started timing out again after the recent switch to ANGLE in bug 205483. 1621795 5 kbr 2020-02-21 15:56:44 -0800 Something's going wrong with the handling of LayoutTests/fast/canvas/webgl/resources/orientation-flipped.mp4 . Playback of that video when ANGLE is the WebGL backend is broken; the frame counter in the video never advances past 0, and there are strange green glitches on the right-hand side of the video. timeupdate events aren't fired past currentTime=3, and the browser isn't responsive - the only way to switch URLs is to close the current window. This doesn't happen with resources/orientation-normal.mp4. Continuing to investigate what code paths are taken when this video is displayed. Note that neither Chrome nor Firefox will load resources/orientation-flipped.mp4 - both browsers' media stacks report that the media resource was not suitable. 1621797 6 kbr 2020-02-21 16:08:40 -0800 Here's ffmpeg's information for the two videos: Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'orientation-normal.mp4': Metadata: major_brand : mp42 minor_version : 512 compatible_brands: isomiso2avc1mp41 creation_time : 2017-08-28T20:46:43.000000Z encoder : HandBrake 1.0.7 2017040900 Duration: 00:00:10.01, start: 0.000000, bitrate: 110 kb/s Stream #0:0(und): Video: h264 (Main) (avc1 / 0x31637661), yuv420p(tv, smpte170m/smpte170m/bt709), 300x300 [SAR 1:1 DAR 1:1], 106 kb/s, 29.97 fps, 29.97 tbr, 90k tbn, 180k tbc (default) Metadata: creation_time : 2017-08-28T20:46:43.000000Z handler_name : VideoHandler Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'orientation-flipped.mp4': Metadata: major_brand : mp42 minor_version : 1 compatible_brands: mp42mp41 creation_time : 2017-09-05T23:25:39.000000Z Duration: 00:00:10.01, start: 0.000000, bitrate: 152 kb/s Stream #0:0(eng): Video: mpeg4 (Simple Profile) (mp4v / 0x7634706D), yuv420p(pc, smpte170m/unknown/smpte170m), 300x300 [SAR 1:1 DAR 1:1], 149 kb/s, 29.97 fps, 29.97 tbr, 1k tbn, 1k tbc (default) Metadata: creation_time : 2017-09-05T23:25:39.000000Z handler_name : Apple Video Media Handler 1621821 7 kbr 2020-02-21 17:29:34 -0800 It looks like the video's currentTime never advances past 3 when the test fails. Still debugging what is going on. One interesting thing to note is that this test takes the software uploading path: frame #0: 0x000000010ff55697 WebCore`WebCore::VideoTextureCopierCV::copyImageToPlatformTexture(this=0x000000013ad9d4c8, image=0x000000012ffe1650, width=300, height=300, outputTexture=2, outputTarget=3553, level=0, internalFormat=6408, format=6408, type=5121, premultiplyAlpha=false, flipY=false) at VideoTextureCopierCV.cpp:810:9 807 OSType pixelFormat = CVPixelBufferGetPixelFormatType(image); 808 if (pixelFormat != kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange && pixelFormat != kCVPixelFormatType_420YpCbCr8BiPlanarFullRange) { 809 LOG(WebGL, "VideoTextureCopierCV::copyVideoTextureToPlatformTexture(%p) - Asked to copy an unsupported pixel format ('%s').", this, FourCC(pixelFormat).toString().utf8().data()); -> 810 return false; 811 } 812 813 IOSurfaceRef surface = CVPixelBufferGetIOSurface(image); Target 0: (MiniBrowser) stopped. (lldb) p pixelFormat (OSType) $3 = '2vuy' '2vuy' 1621827 8 kbr 2020-02-21 17:47:54 -0800 When the test times out, the video is staying in the "seeking" state; HTMLMediaElement::m_seeking is repeatedly true. The test case seems to be able to set the video's currentTime multiple times, but changing it to avoid that doesn't address the problem. Couple of things to investigate: 1) Whether the use of ANGLE is somehow causing the video to be decoded in a different format. 2) Why the video and/or MediaPlayer doesn't successfully seek when ANGLE is enabled. 1622860 9 kbr 2020-02-25 17:42:17 -0800 When ANGLE is disabled for this test case, WebKit goes down the TextureCacheCV code path in VideoTextureCopierCV::copyImageToPlatformTexture, so it retains hardware-accelerated video-to-texture copies. (I thought that CVOpenGLTextureCache was deprecated - in my earlier experiments it looked like CVOpenGLTextureCacheCreateTextureFromImage was failing in WebKit's ANGLE build.) Will see whether this is the root cause of the test timeout or whether there are more issues. 1623302 10 kbr 2020-02-26 17:27:07 -0800 The bugs are in the software fallback path for uploading video elements to WebGL textures. This code path is taken because when ANGLE is enabled, TextureCacheCV (which uses CVOpenGLTextureCache / CVOpenGLESTextureCache) is not used; only the IOSurface code path (for GPU-accelerated video-to-texture uploads, as implemented in Bug 200904) and the MediaPlayer::paintCurrentFrameInContext (the software fallback) are implemented. The basic bug is that when MediaPlayerPrivateAVFoundationObjC::seekToTime calls [AVPlayerItem seekToTime:toleranceBefore:toleranceAfter:completionHandler:], the completion handler is never called. The reason for this is an apparent bug in AVFoundation. Fetching a CoreGraphics image from the video is done in MediaPlayerPrivateAVFoundationObjC::createImageForTimeInRect using the AVAssetImageGenerator. Calling [AVAssetImageGenerator copyCGImageAtTime:actualTime:error:] causes the completion handler from [AVPlayerItem seekToTime:] to get squelched somehow, and the seek never completes. This is why the test times out with the software video upload path - the seek to 3 seconds never finishes. There's another bug where the software path always displays only the first frame of the video. This happens because MediaPlayerPrivateAVFoundationObjC must override and implement: float currentTime() const; Still trying to figure out whether there's any workaround for the above AVFoundation issue. 1623322 11 kbr 2020-02-26 18:14:56 -0800 Tried changing MediaPlayerPrivateAVFoundationObjC::createImageGenerator to stop setting requestedTimeToleranceBefore and requestedTimeToleranceAfter, on the AVAssetImageGenerator, instead using the default values. Thought this might prevent it from interfering with the AVPlayerItem's seeking (though I see that all AVAssetImageGenerator receives is the AVURLAsset) - unfortunately the problem still happens. jer.noble@ - do you have any ideas or suggestions about this AVFoundation problem? Thanks in advance. 1623990 12 jer.noble 2020-02-28 10:29:40 -0800 We should avoid using AVAssetImageGenerator whenever possible, preferring to use AVPlayerItemVideoOutput. The reason is twofold: 1) AVAssetImageGenerator will fetch the video again, separately, effectively doubling network cost and 2) it will redecode the resource, effectively doubling CPU cost. If the asset generator is running, it's probably because the AVPlayerItemVideoOutput doesn't never receive a decoded frame, which indicates a deeper problem with the media stream. I don't remember how I generated the flipped video; it could just be that the stream is corrupt or malformed in a way that used to work in AVFoundation and stopped. One solution to this test may be to generate a "correct" flipped video that decodes in all the major browsers. IIRC, it was a matter of setting the video transform inside the 'mvhd' box. 1625930 13 392532 kbr 2020-03-04 20:15:07 -0800 Created attachment 392532 Patch 1625931 14 kbr 2020-03-04 20:17:13 -0800 dino, jer.noble: could you please review? It makes this layout test run reliably on my machine. Ran all four of the texImage2D-video-flipY-* and texImage2D-mse-flipY-* tests repeatedly; all pass reliably. Thanks. 1626146 15 kbr 2020-03-05 09:59:30 -0800 FYI, the win layout test failures are unrelated to this patch. Do I need to do anything in response to them? 1626151 16 392532 dino 2020-03-05 10:03:12 -0800 Comment on attachment 392532 Patch Thanks Ken! 1626209 17 commit-queue 2020-03-05 11:02:17 -0800 The commit-queue encountered the following flaky tests while processing attachment 392532: editing/spelling/spellcheck-async-remove-frame.html bug 158401 (authors: morrita@google.com, rniwa@webkit.org, and tony@chromium.org) The commit-queue is continuing to process your patch. 1626210 18 392532 commit-queue 2020-03-05 11:02:58 -0800 Comment on attachment 392532 Patch Clearing flags on attachment: 392532 Committed r257932: <https://trac.webkit.org/changeset/257932> 1626211 19 commit-queue 2020-03-05 11:03:00 -0800 All reviewed patches have been landed. Closing bug. 1626221 20 kbr 2020-03-05 11:37:00 -0800 *** Bug 207857 has been marked as a duplicate of this bug. *** 392532 2020-03-04 20:15:07 -0800 2020-03-05 11:02:58 -0800 Patch bug-205734-20200304201507.patch text/plain 6735 kbr U3VidmVyc2lvbiBSZXZpc2lvbjogMjU3ODk5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzhmZDRlNjM5ODQ0YjQ2 MTgyY2ViN2RjZTMzODMyZmU0OTk0YjFmMy4uY2M5MjU0OTg3ZjJjZmI5MDkzYzQyMDVhMmNkNmY0 OTkwMDVlOTU4MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIwLTAzLTA0ICBLZW5u ZXRoIFJ1c3NlbGwgIDxrYnJAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJFR1JFU1NJT046IFsg TWFjIF0gZmFzdC9jYW52YXMvd2ViZ2wvdGV4SW1hZ2UyRC12aWRlby1mbGlwWS1mYWxzZS5odG1s IGlzIFRpbWluZyBvdXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwNTczNAorCisgICAgICAgIEZpeCB0d28gYnVncyBpbiBNZWRpYVBsYXllclByaXZh dGVBVkZvdW5kYXRpb25PYmpDIGNhdXNpbmcgdGhlCisgICAgICAgIHByZWZlcnJlZCBBVlBsYXll ckl0ZW1WaWRlb091dHB1dCBjb2RlIHBhdGggdG8gbm90IGJlIHRha2VuLCBpbgorICAgICAgICB0 aGUgc2l0dWF0aW9uIHdoZXJlIEdQVS10by1HUFUgY29waWVzIGFyZSBub3QgcG9zc2libGUgYmVj YXVzZSB0aGUKKyAgICAgICAgdmlkZW8ncyBmb3JtYXQgZG9lc24ndCBhbGxvdyB0aGVtLgorCisg ICAgICAgIEltcGxlbWVudCBjdXJyZW50VGltZSwgZml4aW5nIGxvbmdzdGFuZGluZyBidWcgaW4g dGhlCisgICAgICAgIEFWQXNzZXRJbWFnZUdlbmVyYXRvciBmYWxsYmFjayB3aGVyZSBvbmx5IHRo ZSBmaXJzdCBmcmFtZSBvZiB0aGUKKyAgICAgICAgdmlkZW8gd291bGQgYmUgZGlzcGxheWVkLgor CisgICAgICAgIENvdmVyZWQgYnkgZXhpc3RpbmcgbGF5b3V0IHRlc3QuCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9h dmZvdW5kYXRpb24vb2JqYy9NZWRpYVBsYXllclByaXZhdGVBVkZvdW5kYXRpb25PYmpDLmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvYXZmb3VuZGF0aW9uL29iamMvTWVkaWFQbGF5ZXJQ cml2YXRlQVZGb3VuZGF0aW9uT2JqQy5tbToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVy UHJpdmF0ZUFWRm91bmRhdGlvbk9iakM6OmN1cnJlbnRUaW1lIGNvbnN0KToKKyAgICAgICAgKFdl YkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUFWRm91bmRhdGlvbk9iakM6OnBhaW50Q3VycmVudEZy YW1lSW5Db250ZXh0KToKKyAgICAgICAgKFdlYkNvcmU6Ok1lZGlhUGxheWVyUHJpdmF0ZUFWRm91 bmRhdGlvbk9iakM6OnBhaW50V2l0aFZpZGVvT3V0cHV0KToKKwogMjAyMC0wMy0wNCAgWmFsYW4g QnVqdGFzICA8emFsYW5AYXBwbGUuY29tPgogCiAgICAgICAgIFtWTkUgbGF5b3V0XSBNb3ZlIHZp c3VhbGx5IG5vbi1lbXB0eSBjb250ZW50IHJlcG9ydGluZyB0byBSZW5kZXJUcmVlQnVpbGRlcgpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvYXZmb3VuZGF0aW9u L29iamMvTWVkaWFQbGF5ZXJQcml2YXRlQVZGb3VuZGF0aW9uT2JqQy5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvYXZmb3VuZGF0aW9uL29iamMvTWVkaWFQbGF5ZXJQcml2YXRl QVZGb3VuZGF0aW9uT2JqQy5oCmluZGV4IDM5OTkwMGQ2OTkwZTA0MTkwZGNlY2Y2ZDhlYmZjZGU4 OGNkMzU5ZTcuLjMyMzM2ZWU2M2I4ZGZiYzk1ZTk4ZDUxZTFmOGUxZGMzZmQzMmJkNWUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2F2Zm91bmRhdGlvbi9vYmpj L01lZGlhUGxheWVyUHJpdmF0ZUFWRm91bmRhdGlvbk9iakMuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9hdmZvdW5kYXRpb24vb2JqYy9NZWRpYVBsYXllclByaXZhdGVB VkZvdW5kYXRpb25PYmpDLmgKQEAgLTE1NSw2ICsxNTUsNyBAQCBwdWJsaWM6CiAgICAgYm9vbCB3 YWl0aW5nRm9yS2V5KCkgY29uc3QgZmluYWwgeyByZXR1cm4gbV93YWl0aW5nRm9yS2V5OyB9CiAj ZW5kaWYKIAorICAgIGZsb2F0IGN1cnJlbnRUaW1lKCkgY29uc3Qgb3ZlcnJpZGU7CiAgICAgTWVk aWFUaW1lIGN1cnJlbnRNZWRpYVRpbWUoKSBjb25zdCBvdmVycmlkZTsKIAogcHJpdmF0ZToKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2F2Zm91bmRhdGlvbi9v YmpjL01lZGlhUGxheWVyUHJpdmF0ZUFWRm91bmRhdGlvbk9iakMubW0gYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9hdmZvdW5kYXRpb24vb2JqYy9NZWRpYVBsYXllclByaXZhdGVB VkZvdW5kYXRpb25PYmpDLm1tCmluZGV4IGQ5MTg2M2IzZjU1NGZmOTU0MGQ0M2Q1MTMwYWFjODll YWZjNzVhNDMuLmQ3MTAzNmFmNTAyYTE0MzFkNGM0MGZlZjJkOTBiZmFiMTRhNjBiOTUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2F2Zm91bmRhdGlvbi9vYmpj L01lZGlhUGxheWVyUHJpdmF0ZUFWRm91bmRhdGlvbk9iakMubW0KKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvYXZmb3VuZGF0aW9uL29iamMvTWVkaWFQbGF5ZXJQcml2YXRl QVZGb3VuZGF0aW9uT2JqQy5tbQpAQCAtMTIyMSw2ICsxMjIxLDExIEBAIE1lZGlhVGltZSBNZWRp YVBsYXllclByaXZhdGVBVkZvdW5kYXRpb25PYmpDOjpwbGF0Zm9ybUR1cmF0aW9uKCkgY29uc3QK ICAgICByZXR1cm4gTWVkaWFUaW1lOjppbnZhbGlkVGltZSgpOwogfQogCitmbG9hdCBNZWRpYVBs YXllclByaXZhdGVBVkZvdW5kYXRpb25PYmpDOjpjdXJyZW50VGltZSgpIGNvbnN0Cit7CisgICAg cmV0dXJuIGN1cnJlbnRNZWRpYVRpbWUoKS50b0Zsb2F0KCk7Cit9CisKIE1lZGlhVGltZSBNZWRp YVBsYXllclByaXZhdGVBVkZvdW5kYXRpb25PYmpDOjpjdXJyZW50TWVkaWFUaW1lKCkgY29uc3QK IHsKICAgICBpZiAoIW1ldGFEYXRhQXZhaWxhYmxlKCkgfHwgIW1fYXZQbGF5ZXJJdGVtKQpAQCAt MTQ5Nyw3ICsxNTAyLDE2IEBAIHZvaWQgTWVkaWFQbGF5ZXJQcml2YXRlQVZGb3VuZGF0aW9uT2Jq Qzo6cGFpbnRDdXJyZW50RnJhbWVJbkNvbnRleHQoR3JhcGhpY3NDb250CiAgICAgc2V0RGVsYXlD YWxsYmFja3ModHJ1ZSk7CiAgICAgQkVHSU5fQkxPQ0tfT0JKQ19FWENFUFRJT05TOwogCi0gICAg aWYgKHZpZGVvT3V0cHV0SGFzQXZhaWxhYmxlRnJhbWUoKSkKKyAgICAvLyBDYWxsZXJzIG9mIHRo aXMgd2lsbCBvZnRlbiBjYWxsIGNvcHlWaWRlb1RleHR1cmVUb1BsYXRmb3JtVGV4dHVyZSBmaXJz dCwKKyAgICAvLyB3aGljaCBjYWxscyB1cGRhdGVMYXN0UGl4ZWxCdWZmZXIsIHdoaWNoIGNsZWFy cyBtX2xhc3RJbWFnZSB3aGVuZXZlciB0aGUKKyAgICAvLyB2aWRlbyBkZWxpdmVycyBhIG5ldyBm cmFtZS4gVGhpcyBicmVha3MgdmlkZW9PdXRwdXRIYXNBdmFpbGFibGVGcmFtZSdzCisgICAgLy8g c2hvcnQtY2lyY3VpdGluZyB3aGVuIG1fbGFzdEltYWdlIGlzIG5vbi1udWxsLCBidXQgdGhlIHZp ZGVvIG9mdGVuCisgICAgLy8gZG9lc24ndCBoYXZlIGEgbmV3IGZyYW1lIHRvIGRlbGl2ZXIgc2lu Y2UgdGhlIGxhc3QgdGltZQorICAgIC8vIGhhc05ld1BpeGVsQnVmZmVyRm9ySXRlbVRpbWUgd2Fz IGNhbGxlZCBhZ2FpbnN0IG1fdmlkZW9PdXRwdXQuIFRvIGF2b2lkCisgICAgLy8gY2hhbmdpbmcg dGhlIHNlbWFudGljcyBvZiB2aWRlb091dHB1dEhhc0F2YWlsYWJsZUZyYW1lIGluIHdheXMgdGhh dCBtaWdodAorICAgIC8vIGJyZWFrIG90aGVyIGNhbGxlcnMsIGxvb2sgZm9yIHByb2R1Y3Rpb24g b2YgYSByZWNlbnQgcGl4ZWwgYnVmZmVyIGZyb20KKyAgICAvLyB0aGUgdmlkZW8gb3V0cHV0LCB0 b28uCisgICAgaWYgKHZpZGVvT3V0cHV0SGFzQXZhaWxhYmxlRnJhbWUoKSB8fCAobV92aWRlb091 dHB1dCAmJiBtX2xhc3RQaXhlbEJ1ZmZlcikpCiAgICAgICAgIHBhaW50V2l0aFZpZGVvT3V0cHV0 KGNvbnRleHQsIHJlY3QpOwogICAgIGVsc2UKICAgICAgICAgcGFpbnRXaXRoSW1hZ2VHZW5lcmF0 b3IoY29udGV4dCwgcmVjdCk7CkBAIC0yMjE4LDcgKzIyMzIsMTEgQEAgdm9pZCBNZWRpYVBsYXll clByaXZhdGVBVkZvdW5kYXRpb25PYmpDOjp1cGRhdGVMYXN0SW1hZ2UoVXBkYXRlVHlwZSB0eXBl KQogCiB2b2lkIE1lZGlhUGxheWVyUHJpdmF0ZUFWRm91bmRhdGlvbk9iakM6OnBhaW50V2l0aFZp ZGVvT3V0cHV0KEdyYXBoaWNzQ29udGV4dCYgY29udGV4dCwgY29uc3QgRmxvYXRSZWN0JiBvdXRw dXRSZWN0KQogewotICAgIHVwZGF0ZUxhc3RJbWFnZShVcGRhdGVUeXBlOjpVcGRhdGVTeW5jaHJv bm91c2x5KTsKKyAgICAvLyBJdCdzIGNydWNpYWwgdG8gbm90IHdhaXQgc3luY2hyb25vdXNseSBm b3IgdGhlIG5leHQgaW1hZ2UuIFZpZGVvcyB0aGF0CisgICAgLy8gY29tZSBkb3duIHRoaXMgcGF0 aCBhcmUgcGVyZm9ybWluZyBzbG93LWNhc2Ugc29mdHdhcmUgdXBsb2FkcywgYW5kIHN1Y2gKKyAg ICAvLyB2aWRlb3MgbWF5IG5vdCByZXR1cm4gbWV0YWRhdGEgaW4gYSB0aW1lbHkgZmFzaGlvbi4g VXNlIHRoZSBtb3N0IHJlY2VudGx5CisgICAgLy8gYXZhaWxhYmxlIHBpeGVsIGJ1ZmZlciwgaWYg YW55LgorICAgIHVwZGF0ZUxhc3RJbWFnZSgpOwogICAgIGlmICghbV9sYXN0SW1hZ2UpCiAgICAg ICAgIHJldHVybjsKIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDgzMGU5YjQ5ZGU2MTczMTAyOWNjNDQ5OGQ2NDhlMDQzMWY2 OTdhYmMuLmRhMTFiZGMxMTg2ZjEwYmRjZTgwMzQ1YmFkNjBmZGNjNmJkNjQwMWIgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNCBAQAorMjAyMC0wMy0wNCAgS2VubmV0aCBSdXNzZWxsICA8a2JyQGNocm9taXVt Lm9yZz4KKworICAgICAgICBSRUdSRVNTSU9OOiBbIE1hYyBdIGZhc3QvY2FudmFzL3dlYmdsL3Rl eEltYWdlMkQtdmlkZW8tZmxpcFktZmFsc2UuaHRtbCBpcyBUaW1pbmcgb3V0CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDU3MzQKKworICAgICAgICBS ZWVuYWJsZSBsYXlvdXQgdGVzdCBvbiBtYWNPUy4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRmb3JtL21hYy9UZXN0RXhwZWN0YXRpb25zOgor CiAyMDIwLTAzLTA0ICBEb3VnIEtlbGx5ICA8ZG91Z2tAYXBwbGUuY29tPgogCiAgICAgICAgIENy YXNoIGluIFNWR0VsZW1lbnQ6OnJlbW92ZUV2ZW50TGlzdGVuZXIgd2l0aCBzeW1ib2wgZWxlbWVu dApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL1Rlc3RFeHBlY3RhdGlvbnMg Yi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvVGVzdEV4cGVjdGF0aW9ucwppbmRleCA2OTQ1ZTAx NDI3ODRkMDlmMmJlMTEzOTVmNWMwMmZkOTgwMjA4NDk5Li5lYjk3ZWU1MjFlZTJiYmIxMjQ0ZTRk YmQ1YWMwN2M4YmQyOGVjNGFmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMv VGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvVGVzdEV4cGVj dGF0aW9ucwpAQCAtMjAyOSw3ICsyMDI5LDYgQEAgd2Via2l0Lm9yZy9iLzIwNzg1OCBmYXN0L2Nh bnZhcy93ZWJnbC9yZWFkUGl4ZWxzLWZsb2F0Lmh0bWwgWyBGYWlsdXJlIF0KIHdlYmtpdC5vcmcv Yi8yMDc4NTggZmFzdC9jYW52YXMvd2ViZ2wvZHJhdy1lbGVtZW50cy1vdXQtb2YtYm91bmRzLXVp bnQtaW5kZXguaHRtbCBbIEZhaWx1cmUgXQogd2Via2l0Lm9yZy9iLzIwNzg1OCBmYXN0L2NhbnZh cy93ZWJnbC9zaW11bGF0ZWQtdmVydGV4QXR0cmliMC1pbnZhbGlkLWluZGljaWVzLmh0bWwgWyBG YWlsdXJlIF0KIHdlYmtpdC5vcmcvYi8yMDc4NTggZmFzdC9jYW52YXMvd2ViZ2wvd2ViZ2wyLXRl eHR1cmUtdXBsb2FkLWVudW1zLmh0bWwgWyBGYWlsdXJlIF0KLXdlYmtpdC5vcmcvYi8yMDc4NTgg ZmFzdC9jYW52YXMvd2ViZ2wvdGV4SW1hZ2UyRC12aWRlby1mbGlwWS1mYWxzZS5odG1sIFsgU2tp cCBdCiB3ZWJraXQub3JnL2IvMjA3ODU4IHdlYmdsLzEuMC4zL2NvbmZvcm1hbmNlL3Byb2dyYW1z L3Byb2dyYW0tdGVzdC5odG1sIFsgRmFpbHVyZSBdCiAKIHdlYmtpdC5vcmcvYi8yMDc5NzEgY3Nz My9zZWxlY3RvcnMzL3htbC9jc3MzLW1vZHNlbC1kMS54bWwgWyBQYXNzIEZhaWx1cmUgXQpAQCAt MjA1Nyw0ICsyMDU2LDQgQEAgd2Via2l0Lm9yZy9iLzIwODQ2NyBbIERlYnVnIF0gaW1wb3J0ZWQv dzNjL0luZGV4ZWREQi1wcml2YXRlLWJyb3dzaW5nL2lkYm9iamVjdHMKIAogd2Via2l0Lm9yZy9i LzIwODUxOSBbIENhdGFsaW5hIF0gd2ViYW5pbWF0aW9ucy9hY2NlbGVyYXRlZC1hbmltYXRpb24t c2xvdC1pbnZhbGlkYXRpb24uaHRtbCBbIFBhc3MgSW1hZ2VPbmx5RmFpbHVyZSBdCiAKLXdlYmtp dC5vcmcvYi8yMDg1NzQgbWF0aG1sL3NjcmlwdHMtcmVtb3ZlQ2hpbGQuaHRtbCBbIFBhc3MgSW1h Z2VPbmx5RmFpbHVyZSBdClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQord2Via2l0Lm9yZy9i LzIwODU3NCBtYXRobWwvc2NyaXB0cy1yZW1vdmVDaGlsZC5odG1sIFsgUGFzcyBJbWFnZU9ubHlG YWlsdXJlIF0K