143609 2015-04-10 09:09:54 -0700 Consider implementing Document.scrollingElement 2018-01-30 08:40:09 -0800 1 1 1 Unclassified WebKit DOM 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED InRadar, WebExposed P2 Normal --- 5991 182053 182241 1 rbyers sam benjamin fred.wang mathias sam simon.fraser webkit-bug-importer zcorpan oldest_to_newest 1084316 0 rbyers 2015-04-10 09:09:54 -0700 Document.scrollingElement would always return 'body' in WebKit's (non-spec-compliant) implementation, until bug 106133 is fixed. Today some frameworks are forced to rely on a UA check to try to predict this behavior. Document.scrollingElement is designed to be a trivial API for the engine to tell JS exactly which element (body or documentElement) it considers to be the one that scrolls the viewport. See http://dev.w3.org/csswg/cssom-view/#dom-document-scrollingelement And https://lists.w3.org/Archives/Public/www-style/2015Apr/0108.html We're planning on shipping this API in blink ASAP to help ease the transition to spec-compliant scrollTop/scrollLeft behavior (https://groups.google.com/a/chromium.org/forum/#!topic/blink-dev/mJ5SlCj3CHc). However we'd like some feedback from other vendors before we do so. 1084503 1 mathias 2015-04-11 03:50:45 -0700 Polyfill: https://github.com/mathiasbynens/document.scrollingElement 1084616 2 benjamin 2015-04-12 00:45:28 -0700 I saw your email on www-style. Thanks for filing a bug report here. I'd rather not have scrollingElement and just fix the damn bug :) 1084774 3 zcorpan 2015-04-13 06:06:10 -0700 Even when the bug is fixed in WebKit and Blink, scrollingElement still makes sense to use for libraries that want to support being used in quirks mode. 1084912 4 benjamin 2015-04-13 12:37:46 -0700 (In reply to comment #3) > Even when the bug is fixed in WebKit and Blink, scrollingElement still makes > sense to use for libraries that want to support being used in quirks mode. Tell me more. How would you use scrollingElement in a way that can't be covered by existing APIs? 1084913 5 rbyers 2015-04-13 12:39:27 -0700 I'd rather just fix the damn bug too. The problem is that we're finding lots of sites that have been forced to guess at the scrollingElement using a UA check (here's an example: https://github.com/google/closure-library/blob/32365aba43acb36c5d693256ef5d4dbe3bddddfe/closure/goog/dom/dom.js#L632, and Facebook had something similar). I need some good/simple/reliable guidance for those sites to migrate to the spec-compatible behavior. After a number of failed attempts, I don't see any path for switching blink to the correct behavior without first adding such an API. Thoughts? 1084919 6 benjamin 2015-04-13 12:50:44 -0700 (In reply to comment #5) > I'd rather just fix the damn bug too. The problem is that we're finding > lots of sites that have been forced to guess at the scrollingElement using a > UA check (here's an example: > https://github.com/google/closure-library/blob/ > 32365aba43acb36c5d693256ef5d4dbe3bddddfe/closure/goog/dom/dom.js#L632, and > Facebook had something similar). I need some good/simple/reliable guidance > for those sites to migrate to the spec-compatible behavior. After a number > of failed attempts, I don't see any path for switching blink to the correct > behavior without first adding such an API. Thoughts? The problem here is the UA check for detecting behavior. If it is just a matter of feature detection, one could change scrollTop/Left on body, observe which viewport has been modified, then restore the scroll position. What I do not like about "scrollingElement" is that it looks like a temporary hack. It goes against keeping the platform simple. 1084949 7 rbyers 2015-04-13 13:35:52 -0700 (In reply to comment #6) > (In reply to comment #5) > > I'd rather just fix the damn bug too. The problem is that we're finding > > lots of sites that have been forced to guess at the scrollingElement using a > > UA check (here's an example: > > https://github.com/google/closure-library/blob/ > > 32365aba43acb36c5d693256ef5d4dbe3bddddfe/closure/goog/dom/dom.js#L632, and > > Facebook had something similar). I need some good/simple/reliable guidance > > for those sites to migrate to the spec-compatible behavior. After a number > > of failed attempts, I don't see any path for switching blink to the correct > > behavior without first adding such an API. Thoughts? > > The problem here is the UA check for detecting behavior. > > If it is just a matter of feature detection, one could change scrollTop/Left > on body, observe which viewport has been modified, then restore the scroll > position. That might result in a noticeable visible artifact (especially for code that's invoking such 'find me the scrolling element' logic regularly). If you plan to cache the result then you need to also force the page to be scrollable somehow during the test. The polyfill referenced above addresses all these issues by creating a temporary iframe to run the test, and as a result is starting to get a little complex (hard to argue that it's a good drop in replacement for the simple UA check folks are doing). But I can see the argument saying that's a better path forward. > What I do not like about "scrollingElement" is that it looks like a > temporary hack. It goes against keeping the platform simple. I agree it would be nicer if we could correct our mistakes only through simplifying the platform API surface area. But breaking changes (even bug fixes) are really hard to do. Personally I'm willing to add simple, well-defined APIs when it simplifies the platform mental model even while adding more surface area. FWIW I expect the presence of this API to simplify the spec text around all this dramatically, as it has simplified our implementation in blink - crrev.com/1075393002 (both of course could have been done by introducing the concept without exposing it). Anyway, pragmatically it feels to me like our choices are to add an API like this to answer the exact question developers are attempting (and failing) to guess or to stick with the status quo where browsers that pretend to be WebKit in their UA (now including MS EdgeHTML) have to have a different implementation than those that don't. I'm happy to be proven wrong if someone else wants to pick up the torch of trying to get this platform wart fixed a different way - it looks like bug 106133 hasn't had any love in awhile :-( Also there is the minor argument Simon alluded to which says it's simpler and more reliably for library developers to use scrollingElement than to figure out they need to determine whether or not they're in quirks mode. But I agree that's a pretty minor simplicity benefit, not enough to justify this API on it's own. 1084963 8 benjamin 2015-04-13 14:17:45 -0700 What is Mozilla's take on this? 1084964 9 rbyers 2015-04-13 14:23:48 -0700 (In reply to comment #8) > What is Mozilla's take on this? Looks like they plan to implement it: https://bugzilla.mozilla.org/show_bug.cgi?id=1153322 1084968 10 benjamin 2015-04-13 14:33:26 -0700 (In reply to comment #9) > (In reply to comment #8) > > What is Mozilla's take on this? > > Looks like they plan to implement it: > https://bugzilla.mozilla.org/show_bug.cgi?id=1153322 I am never a fan of adding something that can easily be implemented in JavaScript. But if both Mozilla and Chrome want the added complexity...let's do it. 1092352 11 webkit-bug-importer 2015-05-06 15:20:57 -0700 <rdar://problem/20845213> 1092893 12 252661 sam 2015-05-07 17:30:24 -0700 Created attachment 252661 Patch 1092894 13 252661 simon.fraser 2015-05-07 17:31:58 -0700 Comment on attachment 252661 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=252661&action=review > Source/WebCore/ChangeLog:3 > + Consider implementing Document.scrollingElement No longer considering! 1092918 14 sam 2015-05-07 18:00:21 -0700 Committed r183967: <http://trac.webkit.org/changeset/183967> 252661 2015-05-07 17:30:24 -0700 2015-05-07 17:31:58 -0700 Patch bug-143609-20150507172906.patch text/plain 8610 sam SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE4Mzk2MCkKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDI0IEBACisyMDE1LTA1LTA3ICBTYW0gV2Vp bmlnICA8c2FtQHdlYmtpdC5vcmc+CisKKyAgICAgICAgQ29uc2lkZXIgaW1wbGVtZW50aW5nIERv Y3VtZW50LnNjcm9sbGluZ0VsZW1lbnQKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzIwODQ1MjEz PgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQzNjA5 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHRo ZSBub24tY29tcGxpYW50IGltcGxlbWVudGF0aW9uIG9mIERvY3VtZW50LnNjcm9sbGluZ0VsZW1l bnQgdGhhdCB0aGUgc3BlYywKKyAgICAgICAgZm91bmQgYXQgaHR0cDovL2Rldi53My5vcmcvY3Nz d2cvY3Nzb20tdmlldy8jZG9tLWRvY3VtZW50LXNjcm9sbGluZ2VsZW1lbnQsIAorICAgICAgICBz YXlzIHdlIHNob3VsZCBoYXZlIHdoaWxlIHdlIGhhdmUgbm9uLWNvbXBsaWFudCBpbXBsZW1lbnRh dGlvbnMgb2YgRWxlbWVudC5zY3JvbGxUb3AKKyAgICAgICAgYW5kIEVsZW1lbnQuc2Nyb2xsTGVm dCAoZml4aW5nIHRoYXQgaXMgdHJhY2tlZCBieSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTA2MTMzKS4KKworICAgICAgICBUZXN0czogZmFzdC9kb20vRG9jdW1lbnQv c2Nyb2xsaW5nRWxlbWVudC1xdWlya3MtbW9kZS5odG1sCisgICAgICAgICAgICAgICBmYXN0L2Rv bS9Eb2N1bWVudC9zY3JvbGxpbmdFbGVtZW50LXN0YW5kYXJkcy1tb2RlLmh0bWwKKworICAgICAg ICAqIGRvbS9Eb2N1bWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpEb2N1bWVudDo6c2Nyb2xs aW5nRWxlbWVudCk6CisgICAgICAgICogZG9tL0RvY3VtZW50Lmg6CisgICAgICAgICogZG9tL0Rv Y3VtZW50LmlkbDoKKwogMjAxNS0wNS0wNyAgU2FpZCBBYm91LUhhbGxhd2EgIDxzYWJvdWhhbGxh d2FAYXBwbGUuY29tPgogCiAgICAgICAgIEFwcGx5aW5nIGEgZmlsdGVyIG9uIGFuIFNWRyBlbGVt ZW50LCB3aGljaCBpcyBsYXJnZXIgdGhhbiA0MDk2IHBpeGVscywgY2F1c2VzIHRoaXMgZWxlbWVu dCB0byBiZSByZW5kZXJlZCBzaGlmdGVkIHRvIHRoZSBsZWZ0CkluZGV4OiBTb3VyY2UvV2ViQ29y ZS9kb20vRG9jdW1lbnQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1 bWVudC5jcHAJKHJldmlzaW9uIDE4Mzk0OCkKKysrIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVu dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTE0MjksNiArMTQyOSwxNCBAQCBSZWZQdHI8UmFuZ2U+ IERvY3VtZW50OjpjYXJldFJhbmdlRnJvbVBvCiAgICAgcmV0dXJuIFJhbmdlOjpjcmVhdGUoKnRo aXMsIHJhbmdlQ29tcGxpYW50UG9zaXRpb24sIHJhbmdlQ29tcGxpYW50UG9zaXRpb24pOwogfQog CitFbGVtZW50KiBEb2N1bWVudDo6c2Nyb2xsaW5nRWxlbWVudCgpCit7CisgICAgLy8gRklYTUU6 IFdoZW4gd2UgZml4IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDYx MzMsIHRoaXMgc2hvdWxkIGJlIHJlcGxhY2VkIHdpdGggdGhlIGZ1bGwgaW1wbGVtZW50YXRpb24K KyAgICAvLyBvZiBEb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50KCkgYXMgc3BlY2lmaWVkIGF0IGh0 dHA6Ly9kZXYudzMub3JnL2Nzc3dnL2Nzc29tLXZpZXcvI2RvbS1kb2N1bWVudC1zY3JvbGxpbmdl bGVtZW50LgorCisgICAgcmV0dXJuIGJvZHkoKTsKK30KKwogLyoKICAqIFBlcmZvcm1zIHRocmVl IG9wZXJhdGlvbnM6CiAgKiAgMS4gQ29udmVydCBjb250cm9sIGNoYXJhY3RlcnMgdG8gc3BhY2Vz CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3Vy Y2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaAkocmV2aXNpb24gMTgzOTQ4KQorKysgU291cmNlL1dl YkNvcmUvZG9tL0RvY3VtZW50LmgJKHdvcmtpbmcgY29weSkKQEAgLTM4MSw2ICszODEsOCBAQCBw dWJsaWM6CiAgICAgUmVmUHRyPFJhbmdlPiBjYXJldFJhbmdlRnJvbVBvaW50KGludCB4LCBpbnQg eSk7CiAgICAgUmVmUHRyPFJhbmdlPiBjYXJldFJhbmdlRnJvbVBvaW50KGNvbnN0IExheW91dFBv aW50JiBjbGllbnRQb2ludCk7CiAKKyAgICBFbGVtZW50KiBzY3JvbGxpbmdFbGVtZW50KCk7CisK ICAgICBTdHJpbmcgcmVhZHlTdGF0ZSgpIGNvbnN0OwogCiAgICAgU3RyaW5nIGRlZmF1bHRDaGFy c2V0KCkgY29uc3Q7CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaWRsCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5pZGwJKHJldmlzaW9uIDE4Mzk0 OCkKKysrIFNvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5pZGwJKHdvcmtpbmcgY29weSkKQEAg LTM0MSw1ICszNDEsNyBAQAogCiAgICAgLy8gaHR0cDovL3d3dy53My5vcmcvVFIvMjAxNC9XRC1k b20tMjAxNDAyMDQvI2RvbS1kb2N1bWVudC1vcmlnaW4KICAgICByZWFkb25seSBhdHRyaWJ1dGUg RE9NU3RyaW5nIG9yaWdpbjsKKworICAgIHJlYWRvbmx5IGF0dHJpYnV0ZSBFbGVtZW50IHNjcm9s bGluZ0VsZW1lbnQ7CiB9OwogCkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiAxODM5NjApCisrKyBMYXlvdXRU ZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAxNS0wNS0w NyAgU2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgorCisgICAgICAgIENvbnNpZGVyIGltcGxl bWVudGluZyBEb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50CisgICAgICAgIDxyZGFyOi8vcHJvYmxl bS8yMDg0NTIxMz4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTE0MzYwOQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAg ICAgICogZmFzdC9kb20vRG9jdW1lbnQvc2Nyb2xsaW5nRWxlbWVudC1xdWlya3MtbW9kZS1leHBl Y3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZG9tL0RvY3VtZW50L3Njcm9sbGluZ0Vs ZW1lbnQtcXVpcmtzLW1vZGUuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9kb20vRG9jdW1l bnQvc2Nyb2xsaW5nRWxlbWVudC1zdGFuZGFyZHMtbW9kZS1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGZhc3QvZG9tL0RvY3VtZW50L3Njcm9sbGluZ0VsZW1lbnQtc3RhbmRhcmRzLW1v ZGUuaHRtbDogQWRkZWQuCisKIDIwMTUtMDUtMDcgIFNhaWQgQWJvdS1IYWxsYXdhICA8c2Fib3Vo YWxsYXdhQGFwcGxlLmNvbT4KIAogICAgICAgICBBcHBseWluZyBhIGZpbHRlciBvbiBhbiBTVkcg ZWxlbWVudCwgd2hpY2ggaXMgbGFyZ2VyIHRoYW4gNDA5NiBwaXhlbHMsIGNhdXNlcyB0aGlzIGVs ZW1lbnQgdG8gYmUgcmVuZGVyZWQgc2hpZnRlZCB0byB0aGUgbGVmdApJbmRleDogTGF5b3V0VGVz dHMvZmFzdC9kb20vRG9jdW1lbnQvc2Nyb2xsaW5nRWxlbWVudC1xdWlya3MtbW9kZS1leHBlY3Rl ZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZmFzdC9kb20vRG9jdW1lbnQvc2Nyb2xs aW5nRWxlbWVudC1xdWlya3MtbW9kZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlv dXRUZXN0cy9mYXN0L2RvbS9Eb2N1bWVudC9zY3JvbGxpbmdFbGVtZW50LXF1aXJrcy1tb2RlLWV4 cGVjdGVkLnR4dAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDE4IEBACitUZXN0cyB0aGUgYmVo YXZpb3Igb2YgZG9jdW1lbnQuc2Nyb2xsaW5nRWxlbWVudCBpbiBxdWlya3MgbW9kZS4KKworT24g c3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93 ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK0luIHF1aXJrcyBtb2RlIHRoZSBzY3JvbGxpbmcg ZWxlbWVudCBpcyBgQk9EWWAKK1BBU1MgZG9jdW1lbnQuc2Nyb2xsaW5nRWxlbWVudCBpcyBkb2N1 bWVudC5ib2R5CitQQVNTIGRvY3VtZW50LnNjcm9sbGluZ0VsZW1lbnQgaXMgZG9jdW1lbnQuYm9k eQorUEFTUyBkb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50IGlzIGRvY3VtZW50LmJvZHkKK0luIHF1 aXJrcyBtb2RlLCBpZiB0aGUgYEJPRFlgIGlzIHNjcm9sbGFibGUsIHRoZSBzY3JvbGxpbmcgZWxl bWVudCBpcyBgbnVsbGAKK0lOVEVOVElPTkFMIEZBSUxVUkUuIFRoaXMgY2FuIGJlIGZpeGVkIG9u Y2UgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNjEzMyBpcyBmaXhl ZC4KK0ZBSUwgZG9jdW1lbnQuc2Nyb2xsaW5nRWxlbWVudC5zY3JvbGxpbmdFbGVtZW50IHNob3Vs ZCBiZSBudWxsIChvZiB0eXBlIG9iamVjdCkuIFdhcyB1bmRlZmluZWQgKG9mIHR5cGUgdW5kZWZp bmVkKS4KK0luIHF1aXJrcyBtb2RlLCBpZiB0aGUgYEJPRFlgIGlzIGBkaXNwbGF5OiBub25lYCwg dGhlIHNjcm9sbGluZyBlbGVtZW50IGlzIGBCT0RZYAorUEFTUyBkb2N1bWVudC5zY3JvbGxpbmdF bGVtZW50IGlzIGRvY3VtZW50LmJvZHkKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUK KworVEVTVCBDT01QTEVURQorCkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0L2RvbS9Eb2N1bWVudC9z Y3JvbGxpbmdFbGVtZW50LXF1aXJrcy1tb2RlLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZmFzdC9kb20vRG9jdW1lbnQvc2Nyb2xsaW5nRWxlbWVudC1xdWlya3MtbW9kZS5odG1sCShy ZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZmFzdC9kb20vRG9jdW1lbnQvc2Nyb2xsaW5nRWxl bWVudC1xdWlya3MtbW9kZS5odG1sCSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsMzggQEAKKzxo dG1sPgorPGhlYWQ+Cis8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+Cis8c2NyaXB0IHNyYz0iLi4vLi4v Li4vcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5Pgor PHNjcmlwdD4KKworZGVzY3JpcHRpb24oIlRlc3RzIHRoZSBiZWhhdmlvciBvZiBkb2N1bWVudC5z Y3JvbGxpbmdFbGVtZW50IGluIHF1aXJrcyBtb2RlLiIpOworCitkZWJ1ZygiSW4gcXVpcmtzIG1v ZGUgdGhlIHNjcm9sbGluZyBlbGVtZW50IGlzIGBCT0RZYCIpOworc2hvdWxkQmUoImRvY3VtZW50 LnNjcm9sbGluZ0VsZW1lbnQiLCAiZG9jdW1lbnQuYm9keSIpOworCitkb2N1bWVudC5kb2N1bWVu dEVsZW1lbnQuc2V0QXR0cmlidXRlKCdzdHlsZScsICdvdmVyZmxvdzogc2Nyb2xsJyk7Citkb2N1 bWVudC5ib2R5LnNldEF0dHJpYnV0ZSgnc3R5bGUnLCAnb3ZlcmZsb3c6IHZpc2libGUnKTsKK3No b3VsZEJlKCJkb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50IiwgImRvY3VtZW50LmJvZHkiKTsKKwor ZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LnNldEF0dHJpYnV0ZSgnc3R5bGUnLCAnb3ZlcmZsb3c6 IHZpc2libGUnKTsKK2RvY3VtZW50LmJvZHkuc2V0QXR0cmlidXRlKCdzdHlsZScsICdvdmVyZmxv dzogc2Nyb2xsJyk7CitzaG91bGRCZSgiZG9jdW1lbnQuc2Nyb2xsaW5nRWxlbWVudCIsICJkb2N1 bWVudC5ib2R5Iik7CisKK2RlYnVnKCJJbiBxdWlya3MgbW9kZSwgaWYgdGhlIGBCT0RZYCBpcyBz Y3JvbGxhYmxlLCB0aGUgc2Nyb2xsaW5nIGVsZW1lbnQgaXMgYG51bGxgIik7CitkZWJ1ZygiSU5U RU5USU9OQUwgRkFJTFVSRS4gVGhpcyBjYW4gYmUgZml4ZWQgb25jZSBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTA2MTMzIGlzIGZpeGVkLiIpOworZG9jdW1lbnQuZG9j dW1lbnRFbGVtZW50LnNldEF0dHJpYnV0ZSgnc3R5bGUnLCAnb3ZlcmZsb3c6IHNjcm9sbCcpOwor ZG9jdW1lbnQuYm9keS5zZXRBdHRyaWJ1dGUoJ3N0eWxlJywgJ292ZXJmbG93OiBzY3JvbGwnKTsK K3Nob3VsZEJlTnVsbCgiZG9jdW1lbnQuc2Nyb2xsaW5nRWxlbWVudC5zY3JvbGxpbmdFbGVtZW50 Iik7CisKK2RlYnVnKCJJbiBxdWlya3MgbW9kZSwgaWYgdGhlIGBCT0RZYCBpcyBgZGlzcGxheTog bm9uZWAsIHRoZSBzY3JvbGxpbmcgZWxlbWVudCBpcyBgQk9EWWAiKTsKK2RvY3VtZW50LmRvY3Vt ZW50RWxlbWVudC5zZXRBdHRyaWJ1dGUoJ3N0eWxlJywgJ292ZXJmbG93OiBzY3JvbGwnKTsKK2Rv Y3VtZW50LmJvZHkuc2V0QXR0cmlidXRlKCdzdHlsZScsICdvdmVyZmxvdzogc2Nyb2xsOyBkaXNw bGF5OiBub25lJyk7CitzaG91bGRCZSgiZG9jdW1lbnQuc2Nyb2xsaW5nRWxlbWVudCIsICJkb2N1 bWVudC5ib2R5Iik7CisKK2RvY3VtZW50LmJvZHkuc2V0QXR0cmlidXRlKCdzdHlsZScsICcnKTsK KworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vcmVzb3VyY2VzL2pzLXRlc3QtcG9z dC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CkluZGV4OiBMYXlvdXRUZXN0cy9mYXN0 L2RvbS9Eb2N1bWVudC9zY3JvbGxpbmdFbGVtZW50LXN0YW5kYXJkcy1tb2RlLWV4cGVjdGVkLnR4 dAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9mYXN0L2RvbS9Eb2N1bWVudC9zY3JvbGxpbmdF bGVtZW50LXN0YW5kYXJkcy1tb2RlLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91 dFRlc3RzL2Zhc3QvZG9tL0RvY3VtZW50L3Njcm9sbGluZ0VsZW1lbnQtc3RhbmRhcmRzLW1vZGUt ZXhwZWN0ZWQudHh0CSh3b3JraW5nIGNvcHkpCkBAIC0wLDAgKzEsMTIgQEAKK1Rlc3RzIHRoZSBi ZWhhdmlvciBvZiBkb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50IGluIHN0YW5kYXJkcyBtb2RlLgor CitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBm b2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworSW4gc3RhbmRhcmRzIG1vZGUgdGhlIHNj cm9sbGluZyBlbGVtZW50IGlzIHN1cHBvc2VkIHRvIGJlIGBIVE1MYAorSU5URU5USU9OQUwgRkFJ TFVSRS4gVGhpcyBjYW4gYmUgZml4ZWQgb25jZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MTA2MTMzIGlzIGZpeGVkLgorRkFJTCBkb2N1bWVudC5zY3JvbGxpbmdFbGVt ZW50IHNob3VsZCBiZSBbb2JqZWN0IEhUTUxIdG1sRWxlbWVudF0uIFdhcyBbb2JqZWN0IEhUTUxC b2R5RWxlbWVudF0uCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09N UExFVEUKKwpJbmRleDogTGF5b3V0VGVzdHMvZmFzdC9kb20vRG9jdW1lbnQvc2Nyb2xsaW5nRWxl bWVudC1zdGFuZGFyZHMtbW9kZS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2Zhc3Qv ZG9tL0RvY3VtZW50L3Njcm9sbGluZ0VsZW1lbnQtc3RhbmRhcmRzLW1vZGUuaHRtbAkocmV2aXNp b24gMCkKKysrIExheW91dFRlc3RzL2Zhc3QvZG9tL0RvY3VtZW50L3Njcm9sbGluZ0VsZW1lbnQt c3RhbmRhcmRzLW1vZGUuaHRtbAkod29ya2luZyBjb3B5KQpAQCAtMCwwICsxLDE5IEBACis8IURP Q1RZUEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+Cis8c2Ny aXB0IHNyYz0iLi4vLi4vLi4vcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwv aGVhZD4KKzxib2R5PgorPHNjcmlwdD4KKworZGVzY3JpcHRpb24oIlRlc3RzIHRoZSBiZWhhdmlv ciBvZiBkb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50IGluIHN0YW5kYXJkcyBtb2RlLiIpOworCitk ZWJ1ZygiSW4gc3RhbmRhcmRzIG1vZGUgdGhlIHNjcm9sbGluZyBlbGVtZW50IGlzIHN1cHBvc2Vk IHRvIGJlIGBIVE1MYCIpOworZGVidWcoIklOVEVOVElPTkFMIEZBSUxVUkUuIFRoaXMgY2FuIGJl IGZpeGVkIG9uY2UgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNjEz MyBpcyBmaXhlZC4iKTsKK3Nob3VsZEJlKCJkb2N1bWVudC5zY3JvbGxpbmdFbGVtZW50IiwgImRv Y3VtZW50LmRvY3VtZW50RWxlbWVudCIpOworCis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8u Li8uLi9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRt bD4K