212647 2020-06-02 11:02:28 -0700 REGRESSION (r262366): [ Mac wk1 ] webgl/webgl-backing-store-size-update.html is failing 2020-06-05 13:56:09 -0700 1 1 1 Unclassified WebKit WebGL WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 212461 1 tsavell dino cdumez darin dino eric.carlson esprehn+autocc ews-watchlist kangil.han kbr Lawrence.j webkit-bot-watchers-bugzilla webkit-bug-importer oldest_to_newest 1658377 0 tsavell 2020-06-02 11:02:28 -0700 webgl/webgl-backing-store-size-update.html This test became a consistent failure on Mac wk1 after the changes in https://trac.webkit.org/changeset/262366/webkit history: https://results.webkit.org/?suite=layout-tests&test=webgl%2Fwebgl-backing-store-size-update.html Diff: https://build.webkit.org/results/Apple-Catalina-Release-WK1-Tests/r262400%20(6339)/webgl/webgl-backing-store-size-update-diffs.html Reproduced with: run-webkit-tests --iterations 2000 --exit-after-n-failures 1 --exit-after-n-crashes-or-timeouts 1 --debug-rwt-logging --no-retry --force --no-build -f -1 webgl/webgl-backing-store-size-update.html 1658378 1 webkit-bug-importer 2020-06-02 11:02:48 -0700 <rdar://problem/63882960> 1658451 2 Lawrence.j 2020-06-02 14:31:29 -0700 This test appears to have started failing with the changes in r262366 also: webgl/webgl2-primitive-restart.html History: https://results.webkit.org/?suite=layout-tests&suite=layout-tests&test=webgl%2Fwebgl-backing-store-size-update.html&test=webgl%2Fwebgl2-primitive-restart.html 1658940 3 dino 2020-06-03 18:26:53 -0700 This test: - starts with a canvas that has a composited size of 100x100 - sets the canvas drawing buffer size to 200x200 - renders into the canvas - changes the composited size of the canvas to 50x50 - waits for a layout pass - sets the canvas drawing buffer size to 50x50 - renders into the canvas I'm not sure why the issues are specific to WK1. 1658948 4 dino 2020-06-03 19:09:25 -0700 For WK1, at least in the test harness, it appears to be possible for display to be called *before* prepare. Notice that the "canvas is displayed" happens earlier. Good case --------- canvas size set to 200x200 GCGL reshape to 200x200 Paint happens - document takes note canvas size set to 100x200 (via setting just .width) GCGL reshape to 100x200 canvas size set to 100x100 (via setting just .height) GCGL reshape to 100x100 Paint happens - document takes note All JS finishes, Document looks for canvas elements needing prep Document calls prepare on canvas canvas is displayed Bad case --------- canvas size set to 200x200 GCGL reshape to 200x200 Paint happens - document takes note canvas size set to 100x200 (via setting just .width) GCGL reshape to 100x200 canvas size set to 100x100 (via setting just .height) GCGL reshape to 100x100 Paint happens - document takes note canvas is displayed All JS finishes, Document looks for canvas elements needing prep Document calls prepare on canvas 1658950 5 dino 2020-06-03 19:36:19 -0700 So either the logic of doing the preparation in Page::doAfterUpdateRendering() is incorrect for WebKit1, or something about the canvas backbuffer sizing causes a display to trigger early. Calling setNeedsDisplay from prepare would probably fix this particular test, but would still be two paints - we need the prepare to happen before the paint. Maybe it is the fact that the resize and paint happens inside a rAF? 1658951 6 dino 2020-06-03 19:43:31 -0700 It's the test app that triggers the issue: dino> display 0x10d7c06b8 1 0x11ef0ad84 -[WebGLLayer display] 2 0x108da1224 CA::Layer::display_if_needed(CA::Transaction*) 3 0x108ed35b5 CA::Context::commit_transaction(CA::Transaction*, double, double*) 4 0x108d7ec59 CA::Transaction::commit() 5 0x10b3d5772 -[WebView(WebPrivate) _forceRepaintForTesting] 6 0x1013a2d87 updateDisplay() 7 0x1013a2753 dump() 8 0x10140e892 TestRunner::notifyDone() TestRunner forces a repaint. 1658953 7 dino 2020-06-03 19:47:32 -0700 The backing store test fix is easy. Now for the primitive restart issue.... 1658954 8 dino 2020-06-03 19:54:17 -0700 Same problem. Rather than fixing the tests I should probably call the document's canvas preparation stuff from _forceRepaintForTesting 1659311 9 dino 2020-06-04 14:02:02 -0700 I was hoping I could just call Page::updateRendering() inside the forceRepaint, but that doesn't appear to help - display is still called before prepare. I'll work out why this is. 1659317 10 dino 2020-06-04 14:06:31 -0700 Ah. _forceRepaintForTesting already triggers the Page::updateRendering code to run, but it exits early because it is already updating the rendering. 1659324 11 dino 2020-06-04 14:14:18 -0700 updateRendering calls document.serviceRequestAnimationFrameCallbacks(timestamp) and this particular test is triggering _forceRepaintForTesting from within the callback. I could try calling Page::doAfterUpdateRendering() from within _forceRepaintForTesting. Under normal circumstances it would have run through whatever triggered updateRendering. However, rendering definitely hasn't been updated by this point, so it could be a mistake. All this is to avoid having to edit the tests, but it would be more accurate. 1659447 12 401108 dino 2020-06-04 18:55:49 -0700 Created attachment 401108 Patch 1659724 13 401108 kbr 2020-06-05 12:13:22 -0700 Comment on attachment 401108 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401108&action=review Looks good to me - one small comment. > Source/WebCore/platform/graphics/cocoa/WebGLLayer.mm:223 > + [self setNeedsDisplay]; Is this call cheap? If not, should it be done only if _preparedForDisplay == NO? 1659728 14 401108 dino 2020-06-05 12:20:35 -0700 Comment on attachment 401108 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401108&action=review >> Source/WebCore/platform/graphics/cocoa/WebGLLayer.mm:223 >> + [self setNeedsDisplay]; > > Is this call cheap? If not, should it be done only if _preparedForDisplay == NO? This is probably the most concerning part of the patch. We really shouldn't have to do this, and it is only necessary because the test infrastructure can bypass the normal rendering cycle. Changing that might impact a lot of tests across all features, but probably should be done anyway. However, my understanding is that this call is cheap. It's just setting a bit that will be detected in CoreAnimation's rendering loop that will cause it to execute `display`. Technically we shouldn't have even got into this method without it already being called, since the same logic that tells the system that this method is necessary also calls setNeedsDisplay itself. The problem is that the test infrastructure can trigger a `display` before the code in Page that would make preparation happen. 1659755 15 dino 2020-06-05 12:56:31 -0700 Committed r262643: <https://trac.webkit.org/changeset/262643> 1659758 16 401108 darin 2020-06-05 12:58:11 -0700 Comment on attachment 401108 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=401108&action=review > Source/WebCore/dom/Document.cpp:8597 > + auto protectedCanvas = makeRefPtr(canvas); I would have done makeRef(*canvas) > LayoutTests/webgl/webgl-backing-store-size-update.html:35 > + window.requestAnimationFrame(function() { This "window." is not needed and in future I would suggest leaving it out. 1659781 17 dino 2020-06-05 13:56:09 -0700 Follow-up in r262652. 401108 2020-06-04 18:55:49 -0700 2020-06-05 12:28:22 -0700 Patch bug-212647-20200605115548.patch text/plain 9002 dino U3VidmVyc2lvbiBSZXZpc2lvbjogMjYyNTQ4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZmRiODc2ZWY4ZjgyYTY4 OTI2MGQzZWZmZmFkN2JjZDU5NGVjZDM2Yi4uMWY2NjBiOWUxODRlNTg5ZTVhNzI0MWQ1NmQyYmJk MzU1ZGJiYmIyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIwLTA2LTA0ICBEZWFu IEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OIChyMjYyMzY2 KTogWyBNYWMgd2sxIF0gd2ViZ2wvd2ViZ2wtYmFja2luZy1zdG9yZS1zaXplLXVwZGF0ZS5odG1s IGlzIGZhaWxpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIxMjY0NworICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjM4ODI5NjA+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSW4gc29tZSB1bnVzdWFsIGNh c2VzLCBzcGVjaWZpY2FsbHkgV2ViS2l0IDEsIGEgV2ViR0xMYXllciBjb3VsZCBwcmVwYXJlRm9y RGlzcGxheQorICAgICAgICBidXQgbmV2ZXIgZ2V0IHRvbGQgdG8gYWN0dWFsbHkgZGlzcGxheSwg cHJvZHVjaW5nIGluY29ycmVjdCByZXN1bHRzLiBGaXggdGhpcyBieQorICAgICAgICBzaW1wbHkg Y2FsbGluZyBzZXROZWVkc0Rpc3BsYXkuCisKKyAgICAgICAgV2hpbGUgaGVyZSwgYWRkcmVzcyBz b21lIGNvbW1lbnRzIGZyb20gU2ltb24gRnJhc2VyIHRoYXQgd2VyZSBtYWRlCisgICAgICAgIGFm dGVyIHIyNjIzNjYuCisKKyAgICAgICAgKiBkb20vRG9jdW1lbnQuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6RG9jdW1lbnQ6OnByZXBhcmVDYW52YXNlc0ZvckRpc3BsYXlJZk5lZWRlZCk6CisgICAg ICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvV2ViR0xMYXllci5oOiBNb3ZlIHRoZSBpbnN0 YW5jZSB2YXJpYWJsZXMgaW50byB0aGUgaW1wbGVtZW50YXRpb24gZmlsZQorICAgICAgICBzaW5j ZSB0aGV5IGFyZSBub3QgZXhwb3NlZCBhcyBhbiBpbnRlcmZhY2UuCisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvY29jb2EvV2ViR0xMYXllci5tbToKKyAgICAgICAgKC1bV2ViR0xMYXllciBp bml0V2l0aEdyYXBoaWNzQ29udGV4dEdMOl0pOgorICAgICAgICAoLVtXZWJHTExheWVyIHByZXBh cmVGb3JEaXNwbGF5XSk6CisgICAgICAgICgtW1dlYkdMTGF5ZXIgZGlzcGxheV0pOgorCiAyMDIw LTA2LTA0ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgW2lPU10g VmFsaWRhdGUgaW5kZXggcGFyYW1ldGVyIGluIFBsYXRmb3JtUGFzdGVib2FyZApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9E b2N1bWVudC5jcHAKaW5kZXggOTk1MzljNjZhN2NiNDkwZThhNjYyMjQ5YzhmZTQ3NDcyZWFmYzI4 Yi4uZWM4Yjg2YjVjODAzZDNiN2I0NDdjMzk1ZTBhZjgzYTQ2MTU2N2M2YyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20v RG9jdW1lbnQuY3BwCkBAIC04NTk0LDggKzg1OTQsOCBAQCB2b2lkIERvY3VtZW50OjpwcmVwYXJl Q2FudmFzZXNGb3JEaXNwbGF5SWZOZWVkZWQoKQogICAgICAgICBpZiAoIWNhbnZhcy0+aXNJblRy ZWVTY29wZSgpKQogICAgICAgICAgICAgY29udGludWU7CiAKLSAgICAgICAgYXV0byByZWZDb3Vu dGVkQ2FudmFzID0gbWFrZVJlZlB0cihjYW52YXMpOwotICAgICAgICByZWZDb3VudGVkQ2FudmFz LT5wcmVwYXJlRm9yRGlzcGxheSgpOworICAgICAgICBhdXRvIHByb3RlY3RlZENhbnZhcyA9IG1h a2VSZWZQdHIoY2FudmFzKTsKKyAgICAgICAgcHJvdGVjdGVkQ2FudmFzLT5wcmVwYXJlRm9yRGlz cGxheSgpOwogICAgIH0KICAgICBtX2NhbnZhc2VzTmVlZGluZ0Rpc3BsYXlQcmVwYXJhdGlvbi5j bGVhcigpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y29jb2EvV2ViR0xMYXllci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29j b2EvV2ViR0xMYXllci5oCmluZGV4IDU1MDE1NjY3ZjZiNWE3MGNmNWQ1NjVmNDdlODkzY2E2NDhk NDMxMGUuLjI4NzI5YjE4N2YwM2FlNzIzMmM5YTRhYmZiYmMyNzczOWRkZWE4NWEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL1dlYkdMTGF5ZXIuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9XZWJHTExheWVyLmgK QEAgLTQ0LDI2ICs0NCw2IEBAIEFMTE9XX0RFUFJFQ0FURURfREVDTEFSQVRJT05TX0JFR0lOCiAj ZWxzZQogI2Vycm9yIFVuc3VwcG9ydGVkIHBsYXRmb3JtCiAjZW5kaWYKLXsKLSAgICBOYWtlZFB0 cjxXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTE9wZW5HTD4gX2NvbnRleHQ7Ci0gICAgZmxvYXQg X2RldmljZVBpeGVsUmF0aW87Ci0jaWYgVVNFKE9QRU5HTCkgfHwgVVNFKEFOR0xFKQotICAgIHN0 ZDo6dW5pcXVlX3B0cjxXZWJDb3JlOjpJT1N1cmZhY2U+IF9jb250ZW50c0J1ZmZlcjsKLSAgICBz dGQ6OnVuaXF1ZV9wdHI8V2ViQ29yZTo6SU9TdXJmYWNlPiBfZHJhd2luZ0J1ZmZlcjsKLSAgICBz dGQ6OnVuaXF1ZV9wdHI8V2ViQ29yZTo6SU9TdXJmYWNlPiBfc3BhcmVCdWZmZXI7Ci0gICAgV2Vi Q29yZTo6SW50U2l6ZSBfYnVmZmVyU2l6ZTsKLSAgICBCT09MIF91c2luZ0FscGhhOwotI2VuZGlm Ci0jaWYgVVNFKEFOR0xFKQotICAgIHZvaWQqIF9lZ2xEaXNwbGF5OwotICAgIHZvaWQqIF9lZ2xD b25maWc7Ci0gICAgdm9pZCogX2NvbnRlbnRzUGJ1ZmZlcjsKLSAgICB2b2lkKiBfZHJhd2luZ1Bi dWZmZXI7Ci0gICAgdm9pZCogX3NwYXJlUGJ1ZmZlcjsKLSAgICB2b2lkKiBfbGF0Y2hlZFBidWZm ZXI7Ci0jZW5kaWYKLSAgICBCT09MIF9wcmVwYXJlZDsKLX0KIAogQHByb3BlcnR5IChub25hdG9t aWMpIE5ha2VkUHRyPFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdMT3BlbkdMPiBjb250ZXh0Owog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9XZWJH TExheWVyLm1tIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY29jb2EvV2ViR0xM YXllci5tbQppbmRleCAyODY4NTE3NjZjYTRmM2VjYmQ3NzU3MzM2MDdlODY5NzM0ZmQ3NWE2Li43 OGE2ZjAzNTg4NDRmNDY0ZTRkNmM5ODMzZmMwMzgzNTA4N2U2NmEwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jb2NvYS9XZWJHTExheWVyLm1tCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NvY29hL1dlYkdMTGF5ZXIubW0KQEAgLTc4 LDExICs3OCwyNyBAQCBuYW1lc3BhY2UgewogICAgIH07CiB9CiAKLUBpbXBsZW1lbnRhdGlvbiBX ZWJHTExheWVyCi0KLUBzeW50aGVzaXplIGNvbnRleHQ9X2NvbnRleHQ7CitAaW1wbGVtZW50YXRp b24gV2ViR0xMYXllciB7CisgICAgZmxvYXQgX2RldmljZVBpeGVsUmF0aW87CisjaWYgVVNFKE9Q RU5HTCkgfHwgVVNFKEFOR0xFKQorICAgIHN0ZDo6dW5pcXVlX3B0cjxXZWJDb3JlOjpJT1N1cmZh Y2U+IF9jb250ZW50c0J1ZmZlcjsKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8V2ViQ29yZTo6SU9TdXJm YWNlPiBfZHJhd2luZ0J1ZmZlcjsKKyAgICBzdGQ6OnVuaXF1ZV9wdHI8V2ViQ29yZTo6SU9TdXJm YWNlPiBfc3BhcmVCdWZmZXI7CisgICAgV2ViQ29yZTo6SW50U2l6ZSBfYnVmZmVyU2l6ZTsKKyAg ICBCT09MIF91c2luZ0FscGhhOworI2VuZGlmCisjaWYgVVNFKEFOR0xFKQorICAgIHZvaWQqIF9l Z2xEaXNwbGF5OworICAgIHZvaWQqIF9lZ2xDb25maWc7CisgICAgdm9pZCogX2NvbnRlbnRzUGJ1 ZmZlcjsKKyAgICB2b2lkKiBfZHJhd2luZ1BidWZmZXI7CisgICAgdm9pZCogX3NwYXJlUGJ1ZmZl cjsKKyAgICB2b2lkKiBfbGF0Y2hlZFBidWZmZXI7CisjZW5kaWYKKyAgICBCT09MIF9wcmVwYXJl ZEZvckRpc3BsYXk7Cit9CiAKLS0oaWQpaW5pdFdpdGhHcmFwaGljc0NvbnRleHRHTDooTmFrZWRQ dHI8V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0R0xPcGVuR0w+KWNvbnRleHQKKy0gKGlkKWluaXRX aXRoR3JhcGhpY3NDb250ZXh0R0w6KE5ha2VkUHRyPFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dEdM T3BlbkdMPiljb250ZXh0CiB7CiAgICAgX2NvbnRleHQgPSBjb250ZXh0OwogICAgIHNlbGYgPSBb c3VwZXIgaW5pdF07CkBAIC0yMDQsOCArMjIwLDggQEAgc3RhdGljIHZvaWQgZnJlZURhdGEodm9p ZCAqLCBjb25zdCB2b2lkICpkYXRhLCBzaXplX3QgLyogc2l6ZSAqLykKICAgICAgICAgW3NlbGYg YmluZEZyYW1lYnVmZmVyVG9OZXh0QXZhaWxhYmxlU3VyZmFjZV07CiAgICAgfQogI2VuZGlmCi0K LSAgICBfcHJlcGFyZWQgPSBZRVM7CisgICAgW3NlbGYgc2V0TmVlZHNEaXNwbGF5XTsKKyAgICBf cHJlcGFyZWRGb3JEaXNwbGF5ID0gWUVTOwogfQogCiAtICh2b2lkKWRpc3BsYXkKQEAgLTIxOCw3 ICsyMzQsNyBAQCBzdGF0aWMgdm9pZCBmcmVlRGF0YSh2b2lkICosIGNvbnN0IHZvaWQgKmRhdGEs IHNpemVfdCAvKiBzaXplICovKQogICAgIC8vIFRoaXMgYXZvaWRzIHJ1bm5pbmcgYW55IE9wZW5H TCBjb2RlIGluIHRoaXMgbWV0aG9kLgogCiAjaWYgVVNFKE9QRU5HTCkgfHwgVVNFKEFOR0xFKQot ICAgIGlmIChfY29udGVudHNCdWZmZXIgJiYgX3ByZXBhcmVkKSB7CisgICAgaWYgKF9jb250ZW50 c0J1ZmZlciAmJiBfcHJlcGFyZWRGb3JEaXNwbGF5KSB7CiAgICAgICAgIHNlbGYuY29udGVudHMg PSBfY29udGVudHNCdWZmZXItPmFzTGF5ZXJDb250ZW50cygpOwogICAgICAgICBbc2VsZiByZWxv YWRWYWx1ZUZvcktleVBhdGg6QCJjb250ZW50cyJdOwogICAgIH0KQEAgLTIzMSw3ICsyNDcsNyBA QCBzdGF0aWMgdm9pZCBmcmVlRGF0YSh2b2lkICosIGNvbnN0IHZvaWQgKmRhdGEsIHNpemVfdCAv KiBzaXplICovKQogICAgIGlmIChsYXllciAmJiBsYXllci0+b3duZXIoKSkKICAgICAgICAgbGF5 ZXItPm93bmVyKCktPnBsYXRmb3JtQ0FMYXllckxheWVyRGlkRGlzcGxheShsYXllci5nZXQoKSk7 CiAKLSAgICBfcHJlcGFyZWQgPSBOTzsKKyAgICBfcHJlcGFyZWRGb3JEaXNwbGF5ID0gTk87CiB9 CiAKICNpZiBVU0UoQU5HTEUpCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9D aGFuZ2VMb2cKaW5kZXggNWU5NWM5OGEyM2QyMTc1YmVlOTI4MzdlZjUxMTg3Zjk1OTkwZmE3My4u Nzc3MTc3MjNkNjEwZDhiNmMyOGI0MmM0MDYwMGM5Y2MxZjg4YjMxNCAxMDA2NDQKLS0tIGEvVG9v bHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDIw LTA2LTA0ICBEZWFuIEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAgICBSRUdSRVNT SU9OIChyMjYyMzY2KTogWyBNYWMgd2sxIF0gd2ViZ2wvd2ViZ2wtYmFja2luZy1zdG9yZS1zaXpl LXVwZGF0ZS5odG1sIGlzIGZhaWxpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIxMjY0NworICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjM4ODI5NjA+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgRHJpdmUt YnkgY29tbWVudCBmcm9tIFNpbW9uLiBSZW1vdmUgc29tZSB1c2VsZXNzIGJyYWNlcy4KKworICAg ICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0TGVnYWN5L2lvcy9XZWJHTFByZXBhcmVE aXNwbGF5T25XZWJUaHJlYWQubW06CisKIDIwMjAtMDYtMDQgIFRpbSBIb3J0b24gIDx0aW1vdGh5 X2hvcnRvbkBhcHBsZS5jb20+CiAKICAgICAgICAgV29yayBhcm91bmQgYnJva2VuIHN5c3RlbSB2 ZXJzaW9uIG1hY3JvCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dExlZ2FjeS9pb3MvV2ViR0xQcmVwYXJlRGlzcGxheU9uV2ViVGhyZWFkLm1tIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XZWJLaXRMZWdhY3kvaW9zL1dlYkdMUHJlcGFyZURpc3BsYXlPbldl YlRocmVhZC5tbQppbmRleCAxYzRkYWU2NmM2ZGQ1MjE4NjAwYTdmNDljYzhhNDYzMWI4Mzk4M2Q1 Li5iOGIwYzdiZWYyYWI1NWNiNDViMWU3NTRhZmQ3M2YxZGJiNzQ1N2M1IDEwMDY0NAotLS0gYS9U b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdExlZ2FjeS9pb3MvV2ViR0xQcmVwYXJlRGlz cGxheU9uV2ViVGhyZWFkLm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0 TGVnYWN5L2lvcy9XZWJHTFByZXBhcmVEaXNwbGF5T25XZWJUaHJlYWQubW0KQEAgLTM1LDE0ICsz NSwxMyBAQAogI2ltcG9ydCA8c3RkbGliLmg+CiAjaW1wb3J0IDx3dGYvUmV0YWluUHRyLmg+CiAK LUBpbnRlcmZhY2UgV2ViR0xQcmVwYXJlRGlzcGxheU9uV2ViVGhyZWFkRGVsZWdhdGUgOiBOU09i amVjdCA8VUlXZWJWaWV3RGVsZWdhdGU+IHsKLX0KLUBlbmQKLQogc3RhdGljIGJvb2wgZGlkRmlu aXNoTG9hZCA9IGZhbHNlOwogc3RhdGljIGJvb2wgZGlkRmluaXNoUGFpbnRpbmcgPSBmYWxzZTsK IHN0YXRpYyBib29sIGlzUmVhZHkgPSBmYWxzZTsKIAorQGludGVyZmFjZSBXZWJHTFByZXBhcmVE aXNwbGF5T25XZWJUaHJlYWREZWxlZ2F0ZSA6IE5TT2JqZWN0IDxVSVdlYlZpZXdEZWxlZ2F0ZT4K K0BlbmQKKwogQGltcGxlbWVudGF0aW9uIFdlYkdMUHJlcGFyZURpc3BsYXlPbldlYlRocmVhZERl bGVnYXRlCiAKIElHTk9SRV9XQVJOSU5HU19CRUdJTigiZGVwcmVjYXRlZC1pbXBsZW1lbnRhdGlv bnMiKQpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCmluZGV4IDFiMzUxMDg4NzE5OGI4NWRiNDdhNDE3NTk2NGYwNDgyODI0OTdjZDcuLjc0 MWJjNGIxZjM0MGEzMmZlODkyNzg4ZWU5ODcyZDVmYTFiYjU4ZjkgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx OSBAQAorMjAyMC0wNi0wNCAgRGVhbiBKYWNrc29uICA8ZGlub0BhcHBsZS5jb20+CisKKyAgICAg ICAgUkVHUkVTU0lPTiAocjI2MjM2Nik6IFsgTWFjIHdrMSBdIHdlYmdsL3dlYmdsLWJhY2tpbmct c3RvcmUtc2l6ZS11cGRhdGUuaHRtbCBpcyBmYWlsaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTI2NDcKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVt LzYzODgyOTYwPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgIE1ha2UgdGhpcyB0ZXN0IHdhaXQgYSBmcmFtZSBiZWZvcmUgY2FsbGluZyBub3RpZnlEb25l LiBUaGlzIGlzIHJlcXVpcmVkIGF0IHRoZQorICAgICAgICBtb21lbnQgYmVjYXVzZSBjYWxsaW5n IG5vdGlmeURvbmUgaW4gV2ViS2l0MSBzaWRlc3RlcHMgdGhlIG5vcm1hbCBwYWludGluZyBsb2dp YyBhbmQKKyAgICAgICAgZm9yY2VzIGNvbXBvc2l0aW5nIHRvIGhhcHBlbiwgYW5kIHRodXMgd2ls bCBwcm9kdWNlIGluY29ycmVjdCByZXN1bHRzIGZvciBXZWJHTCBpZgorICAgICAgICB3ZSdyZSBh bHJlYWR5IGluIHRoZSBtaWRkbGUgb2YgdGhlIHJlbmRlcmluZyBsb29wIChlLmcuIGluc2lkZSBh IHJlcXVlc3RBbmltYXRpb25GcmFtZQorICAgICAgICB0aGF0IGhhcyB0b3VjaGVkIHBpeGVscyku CisKKyAgICAgICAgKiB3ZWJnbC93ZWJnbC1iYWNraW5nLXN0b3JlLXNpemUtdXBkYXRlLmh0bWw6 CisKIDIwMjAtMDYtMDQgIEFudG9pbmUgUXVpbnQgIDxncmFvdXRzQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgWyBpT1Mgd2syIF0gYW5pbWF0aW9ucy9wbGF5LXN0YXRlLXBhdXNlZC5odG1sIGlzIGZs YWt5IGZhaWxpbmcuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy93ZWJnbC93ZWJnbC1iYWNraW5n LXN0b3JlLXNpemUtdXBkYXRlLmh0bWwgYi9MYXlvdXRUZXN0cy93ZWJnbC93ZWJnbC1iYWNraW5n LXN0b3JlLXNpemUtdXBkYXRlLmh0bWwKaW5kZXggZjE3OGE5YjY1MTlmYWFjNjNmZGUxMzg0OGQw NmUzODNkODJhMzk2Yy4uYjcwNjkzZGI4YTFjZGRlM2E5N2VhMjMxNzk1ZGQxNmQ3ZWQ0MDU5OSAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViZ2wvd2ViZ2wtYmFja2luZy1zdG9yZS1zaXplLXVw ZGF0ZS5odG1sCisrKyBiL0xheW91dFRlc3RzL3dlYmdsL3dlYmdsLWJhY2tpbmctc3RvcmUtc2l6 ZS11cGRhdGUuaHRtbApAQCAtMjcsOCArMjcsMTUgQEAKICAgICBjYW52YXMuc3R5bGUuaGVpZ2h0 ID0gIjUwcHgiOwogICAgIHdpbmRvdy5yZXF1ZXN0QW5pbWF0aW9uRnJhbWUoZnVuY3Rpb24oKSB7 CiAgICAgICAgIGRyYXcoKTsKLSAgICAgICAgaWYgKHdpbmRvdy50ZXN0UnVubmVyKQotICAgICAg ICAgICAgdGVzdFJ1bm5lci5ub3RpZnlEb25lKCk7CisgICAgICAgIGlmICh3aW5kb3cudGVzdFJ1 bm5lcikgeworICAgICAgICAgICAgLy8gTmVlZCB0byBnaXZlIHRoZSB0ZXN0IHN5c3RlbSBhdCBs ZWFzdCBhIGZyYW1lIHRvIHBhaW50CisgICAgICAgICAgICAvLyBhZnRlciB0aGUgZHJhdygpIGNv bW1hbmQsIGJlY2F1c2Ugbm90aWZ5RG9uZSBmb3JjZXMgYQorICAgICAgICAgICAgLy8gZHVtcCgp IGFuZCB3ZSdyZSBpbnNpZGUgYSByQUYgKHdoaWNoIG1lYW5zIGl0IHdvbid0CisgICAgICAgICAg ICAvLyBkbyBhbnkgb2YgdGhlIHBvc3QtbGF5b3V0L2RyYXdpbmcgd29yayBpbiBQYWdlOjpkb0Fm dGVyVXBkYXRlUmVuZGVyaW5nKQorICAgICAgICAgICAgd2luZG93LnJlcXVlc3RBbmltYXRpb25G cmFtZShmdW5jdGlvbigpIHsKKyAgICAgICAgICAgICAgICB0ZXN0UnVubmVyLm5vdGlmeURvbmUo KTsKKyAgICAgICAgICAgIH0pOworICAgICAgICB9CiAgICAgfSk7CiAKIDwvc2NyaXB0Pgo=