155434 2016-03-14 07:12:00 -0700 Set an upper limit for the size or number of pieces of stretchy operators 2016-06-28 11:17:53 -0700 1 1 1 Unclassified WebKit MathML WebKit Nightly Build All All RESOLVED FIXED P2 Normal --- 155018 130327 122490 130353 136227 155565 1 fred.wang fred.wang alex bfulgham darin mrobinson svillar oldest_to_newest 1174440 0 fred.wang 2016-03-14 07:12:00 -0700 mathml/very-large-stretchy-operators.html still has some random timeout. We can probably workaround that by setting an upper limit for the stretch size of operators or for the number of pieces/extenders to draw them. 1205537 1 282125 fred.wang 2016-06-27 06:43:33 -0700 Created attachment 282125 Patch 1205570 2 282125 bfulgham 2016-06-27 09:11:12 -0700 Comment on attachment 282125 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=282125&action=review I don't see anything obviously wrong here, but I'm holding off on a final r+ because of a few questions I had. > Source/WebCore/rendering/mathml/MathOperator.cpp:35 > +static const unsigned kMaximumExtensionCount = 128; How did you arrive at this count? Do we approach 128 for our existing test cases? I wonder if we could get away with a much smaller value based on actual MathML use cases. > Source/WebCore/rendering/mathml/MathOperator.cpp:495 > + for (unsigned extensionCount = 0; lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount; extensionCount++) { I wonder if this would be clearer remaining a while loop: Unsigned extensionCount = 0; while (lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount) { > Source/WebCore/rendering/mathml/MathOperator.cpp:497 > glyphOrigin.setY(glyphOrigin.y() + lastPaintedGlyphRect.height()); If we have nearly exhausted our extensionCount, but lastPaintedGlyphRect.maxY() is still < to.y(), do we need to do a final "fix-up" calculation to make sure we achieve the "to.y()" value we are trying to reach? > Source/WebCore/rendering/mathml/MathOperator.cpp:533 > + for (unsigned extensionCount = 0; lastPaintedGlyphRect.maxX() < to.x() && extensionCount < kMaximumExtensionCount; extensionCount++) { Ditto my above comments, but in the 'x' dimension. :-) 1205574 3 282125 fred.wang 2016-06-27 09:46:53 -0700 Comment on attachment 282125 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=282125&action=review >> Source/WebCore/rendering/mathml/MathOperator.cpp:35 >> +static const unsigned kMaximumExtensionCount = 128; > > How did you arrive at this count? Do we approach 128 for our existing test cases? > > I wonder if we could get away with a much smaller value based on actual MathML use cases. So for example for a parenthesis the reasoning is that the glyph for the base size (e.g. U+28) as well as for the pieces of the glyph assembly (U+239B, U+239C, U+239D) will more or less have the same size. So a limit of N extenders is essentially setting the maximum ratio of (assembly size)/(base size) to approximately N (times the number of calls to fillWith*ExtensionGlyph). That seems quite reasonable to say that in practice stretched operators never 128 times as large as their base size. I agree that it's probably still a very large upper bound, but that seems enough to avoid time out in very-large-stretchy-operators.html (at least in my local release build and the build bot in EWS). >> Source/WebCore/rendering/mathml/MathOperator.cpp:495 >> + for (unsigned extensionCount = 0; lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount; extensionCount++) { > > I wonder if this would be clearer remaining a while loop: > > Unsigned extensionCount = 0; > while (lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount) { for loops with the extensionCount counter generally looks more readable to me, but I can change that. >> Source/WebCore/rendering/mathml/MathOperator.cpp:497 >> glyphOrigin.setY(glyphOrigin.y() + lastPaintedGlyphRect.height()); > > If we have nearly exhausted our extensionCount, but lastPaintedGlyphRect.maxY() is still < to.y(), do we need to do a final "fix-up" calculation to make sure we achieve the "to.y()" value we are trying to reach? I'm not sure what would be the "fix-up". The only non-const parameters is PaintInfo so we don't need to worry about the local variable glyphOrigin or lastPaintedGlyphRect if that's the question. What will happen is that we will have one big gap at the bottom/left part of the extending part. We could fix it by distributing the gap and extenders equally & symmetrically, but I don't think we want to bother with that given these are really edge cases. 1205581 4 282125 bfulgham 2016-06-27 10:00:09 -0700 Comment on attachment 282125 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=282125&action=review I feel like that we should be able to satisfy our minimal performance requirements while dealing with these stretched operator edge cases, but perhaps that's a separate issue for us to deal with. r=me. >>> Source/WebCore/rendering/mathml/MathOperator.cpp:35 >>> +static const unsigned kMaximumExtensionCount = 128; >> >> How did you arrive at this count? Do we approach 128 for our existing test cases? >> >> I wonder if we could get away with a much smaller value based on actual MathML use cases. > > So for example for a parenthesis the reasoning is that the glyph for the base size (e.g. U+28) as well as for the pieces of the glyph assembly (U+239B, U+239C, U+239D) will more or less have the same size. So a limit of N extenders is essentially setting the maximum ratio of (assembly size)/(base size) to approximately N (times the number of calls to fillWith*ExtensionGlyph). That seems quite reasonable to say that in practice stretched operators never 128 times as large as their base size. I agree that it's probably still a very large upper bound, but that seems enough to avoid time out in very-large-stretchy-operators.html (at least in my local release build and the build bot in EWS). Sounds reasonable. >>> Source/WebCore/rendering/mathml/MathOperator.cpp:495 >>> + for (unsigned extensionCount = 0; lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount; extensionCount++) { >> >> I wonder if this would be clearer remaining a while loop: >> >> Unsigned extensionCount = 0; >> while (lastPaintedGlyphRect.maxY() < to.y() && extensionCount < kMaximumExtensionCount) { > > for loops with the extensionCount counter generally looks more readable to me, but I can change that. I think the 'for' construct makes it seem like there is some set number of extensions we plan on creating. The 'while' loops seems (to me) clearer that we only want to do as much as needed to satisfy the criteria. However, I don't feel strongly about this (it's a personal preference), so go ahead and leave it as-is. >>> Source/WebCore/rendering/mathml/MathOperator.cpp:497 >>> glyphOrigin.setY(glyphOrigin.y() + lastPaintedGlyphRect.height()); >> >> If we have nearly exhausted our extensionCount, but lastPaintedGlyphRect.maxY() is still < to.y(), do we need to do a final "fix-up" calculation to make sure we achieve the "to.y()" value we are trying to reach? > > I'm not sure what would be the "fix-up". The only non-const parameters is PaintInfo so we don't need to worry about the local variable glyphOrigin or lastPaintedGlyphRect if that's the question. What will happen is that we will have one big gap at the bottom/left part of the extending part. We could fix it by distributing the gap and extenders equally & symmetrically, but I don't think we want to bother with that given these are really edge cases. Yes -- that's what I meant by "fix-up". I wasn't sure if our "timeout" case was due to ever-decreasing "lastPaintedGlyphRect.height()" values, so that we approach (as a limit) the desired "to.y()" but never quite achieve it. It's seems surprising to me that we end up with a large gap at the end of the drawing operation if we are drawing "standard" glyph sizes, unless the stretch operation is covering many many pages of height and we are using relatively small glyphs. I agree that these are pathological cases, and maybe we just want to make sure we don't do something crazy (like spin the CPU endlessly trying to satisfy bad layout), but it seems like anything that it should be possible to drawn any "finite" math document without timing out. 1205586 5 fred.wang 2016-06-27 10:17:13 -0700 OK, I'm going to land it as it. BTW, I forgot to reply about our test LayoutTests/mathml/very-large-stretchy-operators.html. Basically, it involves several operators of increasing sizes 2500px, 5000px, 20000px, 40000px, 80000px, 160000px, ... 5120000px, 10240000px so that will definitely reach the upper limit. 1205587 6 bfulgham 2016-06-27 10:18:47 -0700 (In reply to comment #5) > OK, I'm going to land it as it. BTW, I forgot to reply about our test > LayoutTests/mathml/very-large-stretchy-operators.html. Basically, it > involves several operators of increasing sizes 2500px, 5000px, 20000px, > 40000px, 80000px, 160000px, ... 5120000px, 10240000px so that will > definitely reach the upper limit. Sounds good. Should we file a Bugzilla to track the concept of evenly distributing the gaps and extends across large stretch operations? We might not ever do it, but at least we would have a reminder that we should think about it. 1205596 7 fred.wang 2016-06-27 10:36:36 -0700 Committed r202489: <http://trac.webkit.org/changeset/202489> 282125 2016-06-27 06:43:33 -0700 2016-06-27 10:00:09 -0700 Patch 0001-Bug-155434-Set-an-upper-limit-for-the-size-or-number.patch text/plain 9128 fred.wang RnJvbSBlN2E0MDE5MGRkYzgyNDI0OTRkNTBjOWJkMjc1OWIwYTg0YWUyMDU1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBGcmVkZXJpYyBXYW5nIDxmcmVkLndhbmdAZnJlZS5mcj4KRGF0 ZTogTW9uLCAyNyBKdW4gMjAxNiAxNTo0MTo1OSArMDIwMApTdWJqZWN0OiBbUEFUQ0hdIEJ1ZyAx NTU0MzQgLSBTZXQgYW4gdXBwZXIgbGltaXQgZm9yIHRoZSBzaXplIG9yIG51bWJlciBvZgogcGll Y2VzIG9mIHN0cmV0Y2h5IG9wZXJhdG9ycwoKLS0tCiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNSArKysrKysrKysrKysrKysKIExheW91dFRl c3RzL3BsYXRmb3JtL2VmbC9UZXN0RXhwZWN0YXRpb25zICAgICAgICAgICB8ICAyIC0tCiBMYXlv dXRUZXN0cy9wbGF0Zm9ybS9ndGsvVGVzdEV4cGVjdGF0aW9ucyAgICAgICAgICAgfCAgMSAtCiBM YXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtc2ltdWxhdG9yL1Rlc3RFeHBlY3RhdGlvbnMgfCAgMiAt LQogTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL1Rlc3RFeHBlY3RhdGlvbnMgICAgICAgICAgIHwg IDUgLS0tLS0KIExheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9UZXN0RXhwZWN0YXRpb25zICAgICAg ICAgICB8ICAxIC0KIFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAg ICAgICAgICB8IDE4ICsrKysrKysrKysrKysrKysrKwogU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L21hdGhtbC9NYXRoT3BlcmF0b3IuY3BwICAgIHwgMTEgKysrKystLS0tLS0KIDggZmlsZXMgY2hh bmdlZCwgMzggaW5zZXJ0aW9ucygrKSwgMTcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDk5ZDRmNWYu LjFkNTJmOWEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKQEAgLTEsNSArMSwyMCBAQAogMjAxNi0wNi0yNyAgRnJlZGVyaWMgV2Fu ZyAgPGZ3YW5nQGlnYWxpYS5jb20+CiAKKyAgICAgICAgU2V0IGFuIHVwcGVyIGxpbWl0IGZvciB0 aGUgc2l6ZSBvciBudW1iZXIgb2YgcGllY2VzIG9mIHN0cmV0Y2h5IG9wZXJhdG9ycworICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU1NDM0CisKKyAgICAg ICAgVXBkYXRlIHRlc3QgZXhwZWN0YXRpb25zIGZvciB2ZXJ5LWxhcmdlLXN0cmV0Y2h5LW9wZXJh dG9ycy4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IHBsYXRmb3JtL2VmbC9UZXN0RXhwZWN0YXRpb25zOgorICAgICAgICAqIHBsYXRmb3JtL2d0ay9U ZXN0RXhwZWN0YXRpb25zOgorICAgICAgICAqIHBsYXRmb3JtL2lvcy1zaW11bGF0b3IvVGVzdEV4 cGVjdGF0aW9uczoKKyAgICAgICAgKiBwbGF0Zm9ybS9tYWMvVGVzdEV4cGVjdGF0aW9uczoKKyAg ICAgICAgKiBwbGF0Zm9ybS93aW4vVGVzdEV4cGVjdGF0aW9uczoKKworMjAxNi0wNi0yNyAgRnJl ZGVyaWMgV2FuZyAgPGZ3YW5nQGlnYWxpYS5jb20+CisKICAgICAgICAgVXBkYXRlIFRlc3RFeHBl Y3RhdGlvbnMgZm9yIHNvbWUgZHluYW1pYyBNYXRoTUwgdGVzdHMKICAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1OTE0MgogCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9lZmwvVGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRlc3RzL3BsYXRm b3JtL2VmbC9UZXN0RXhwZWN0YXRpb25zCmluZGV4IGQzYTU4MDIuLjE1NTY0M2YgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2VmbC9UZXN0RXhwZWN0YXRpb25zCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL2VmbC9UZXN0RXhwZWN0YXRpb25zCkBAIC03NjIsOCArNzYyLDYgQEAg d2Via2l0Lm9yZy9iLzEzNjA5OSBmYXN0L2V2ZW50cy9zaG93LW1vZGFsLWRpYWxvZy1vbmJsdXIt b25mb2N1cy5odG1sIFsgQ3Jhc2ggVGkKIHdlYmtpdC5vcmcvYi8xMzYwOTkgZmFzdC9ldmVudHMv c2Nyb2xsLWV2ZW50LWR1cmluZy1tb2RhbC1kaWFsb2cuaHRtbCBbIENyYXNoIFRpbWVvdXQgXQog d2Via2l0Lm9yZy9iLzEzNjA5OSBmYXN0L2hhcm5lc3Mvc2hvdy1tb2RhbC1kaWFsb2cuaHRtbCBb IENyYXNoIFRpbWVvdXQgXQogCi13ZWJraXQub3JnL2IvMTM2MjI3IG1hdGhtbC92ZXJ5LWxhcmdl LXN0cmV0Y2h5LW9wZXJhdG9ycy5odG1sIFsgQ3Jhc2ggVGltZW91dCBQYXNzIF0KLQogI3dlYmtp dC5vcmcvYi8xNDIxNTggaW5zcGVjdG9yL2RvbS9yZW1vdmUtbXVsdGlwbGUtbm9kZXMuaHRtbCBb IENyYXNoIFBhc3MgXQogI3dlYmtpdC5vcmcvYi8xNDcwMTggaW5zcGVjdG9yL2Nzcy9nZXQtc3lz dGVtLWZvbnRzLmh0bWwgWyBTa2lwIF0KIApkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vZ3RrL1Rlc3RFeHBlY3RhdGlvbnMgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9ndGsvVGVzdEV4 cGVjdGF0aW9ucwppbmRleCAwNGZmMjAxLi5hZTNiNjVkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9ndGsvVGVzdEV4cGVjdGF0aW9ucworKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9ndGsvVGVzdEV4cGVjdGF0aW9ucwpAQCAtMTYwNyw3ICsxNjA3LDYgQEAgd2Via2l0Lm9yZy9i LzE0NDY5MCBlZGl0aW5nL3NwZWxsaW5nL2RlbGV0ZS1pbnRvLW1pc3NwZWxsZWQtd29yZC5odG1s IFsgVGltZW91dAogd2Via2l0Lm9yZy9iLzE0MTgzNSBtZWRpYS92aWRlby1jb250cm9scy1uby1z Y3JpcHRpbmcuaHRtbCBbIEZhaWx1cmUgXQogCiAjIE1heSB0YWtlIHRvbyBsb25nIG9uIHRoZSBi b3RzLgotQnVnKEdUSykgbWF0aG1sL3ZlcnktbGFyZ2Utc3RyZXRjaHktb3BlcmF0b3JzLmh0bWwg WyBQYXNzIFRpbWVvdXQgXQogCiBCdWcoR1RLKSBmYXN0L2hpc3RvcnkvZ28tYmFjay10by1pZnJh bWUtd2l0aC1wbHVnaW4uaHRtbCBbIFRpbWVvdXQgUGFzcyBdCiAKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL3BsYXRmb3JtL2lvcy1zaW11bGF0b3IvVGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRl c3RzL3BsYXRmb3JtL2lvcy1zaW11bGF0b3IvVGVzdEV4cGVjdGF0aW9ucwppbmRleCBlYjBhZDVi Li5kMWI4NTU1IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9pb3Mtc2ltdWxhdG9y L1Rlc3RFeHBlY3RhdGlvbnMKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vaW9zLXNpbXVsYXRv ci9UZXN0RXhwZWN0YXRpb25zCkBAIC0yOTQ3LDggKzI5NDcsNiBAQCB3ZWJraXQub3JnL2IvMTU1 MzcyIFsgRGVidWcgXSBjc3MzL21hc2tpbmcvbWFzay1zdmctc2NyaXB0LW5vbmUtdG8tcG5nLmh0 bWwgWyBQYQogd2Via2l0Lm9yZy9iLzE1NTMzOSBbIERlYnVnIF0gaW1wb3J0ZWQvYmxpbmsvZmFz dC9tdWx0aWNvbC9keW5hbWljL211bHRpY29sLXdpdGgtYWJzcG9zLXN2Zy13aXRoLWZvcmVpZ25v YmplY3Qtd2l0aC1tdWx0aWNvbC1jcmFzaC5odG1sIFsgUGFzcyBDcmFzaCBdCiB3ZWJraXQub3Jn L2IvMTU1MzM5IFsgRGVidWcgXSBpbXBvcnRlZC9ibGluay9mYXN0L211bHRpY29sL2R5bmFtaWMv cmVsYXlvdXQtYWJzcG9zLWluLXJlbHBvcy1zcGFubmVyLmh0bWwgWyBQYXNzIENyYXNoIF0KIAot d2Via2l0Lm9yZy9iLzE1NTU2NSBbIERlYnVnIF0gbWF0aG1sL3ZlcnktbGFyZ2Utc3RyZXRjaHkt b3BlcmF0b3JzLmh0bWwgWyBTa2lwIF0KLQogIyBSVEwgU2Nyb2xsYmFycyBhcmUgbm90IGltcGxl bWVudGVkIG9uIGlPUy4KIGZhc3Qvc2Nyb2xsaW5nL3J0bC1zY3JvbGxiYXJzLXN0aWNreS1kb2N1 bWVudC0yLmh0bWwgWyBJbWFnZU9ubHlGYWlsdXJlIF0KIGZhc3Qvc2Nyb2xsaW5nL3J0bC1zY3Jv bGxiYXJzLXN0aWNreS1kb2N1bWVudC5odG1sIFsgSW1hZ2VPbmx5RmFpbHVyZSBdCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvVGVzdEV4cGVjdGF0aW9ucyBiL0xheW91dFRl c3RzL3BsYXRmb3JtL21hYy9UZXN0RXhwZWN0YXRpb25zCmluZGV4IDUzNzRiMDguLjY0N2FlN2Ig MTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9UZXN0RXhwZWN0YXRpb25zCisr KyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9UZXN0RXhwZWN0YXRpb25zCkBAIC03MjksMTEg KzcyOSw2IEBAIHdlYmtpdC5vcmcvYi8xMjIwMzEgZmFzdC9hbmltYXRpb24vcmVxdWVzdC1hbmlt YXRpb24tZnJhbWUtdGltZS11bml0Lmh0bWwgWyBQYXNzCiAKIHdlYmtpdC5vcmcvYi8xMjIwMzgg YW5pbWF0aW9ucy90cmFuc2Zvcm0tbm9uLWFjY2VsZXJhdGVkLmh0bWwgWyBQYXNzIEZhaWx1cmUg XQogCi13ZWJraXQub3JnL2IvMTIyNDkwIFsgRGVidWcgXSBtYXRobWwvdmVyeS1sYXJnZS1zdHJl dGNoeS1vcGVyYXRvcnMuaHRtbCBbIFNraXAgXQotCi0jIHJkYXI6Ly9wcm9ibGVtLzIxNDQzMDAy Ci1bIFJlbGVhc2UgRWxDYXBpdGFuKyBdIG1hdGhtbC92ZXJ5LWxhcmdlLXN0cmV0Y2h5LW9wZXJh dG9ycy5odG1sIFsgU2xvdyBdCi0KIHdlYmtpdC5vcmcvYi8xMjMyMjAgY29tcG9zaXRpbmcvcmVn aW9ucy9mbG9hdGVkLXJlZ2lvbi13aXRoLXRyYW5zZm9ybWVkLWNoaWxkLmh0bWwgWyBQYXNzIElt YWdlT25seUZhaWx1cmUgXQogd2Via2l0Lm9yZy9iLzEzODE3OSBjb21wb3NpdGluZy9yZWdpb25z L3Byb3BhZ2F0ZS1yZWdpb24tYm94LXNoYWRvdy1ib3JkZXItcGFkZGluZy1mb3ItdmlkZW8uaHRt bCBbIFNraXAgXQogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS93aW4vVGVzdEV4 cGVjdGF0aW9ucyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9UZXN0RXhwZWN0YXRpb25zCmlu ZGV4IGU1ZTliMzUuLjAzYmVlY2IgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3BsYXRmb3JtL3dp bi9UZXN0RXhwZWN0YXRpb25zCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL3dpbi9UZXN0RXhw ZWN0YXRpb25zCkBAIC0xOTY0LDcgKzE5NjQsNiBAQCB3ZWJraXQub3JnL2IvMTE5MDM4IG1hdGht bC9wcmVzZW50YXRpb24vcm9vdHMueGh0bWwgWyBGYWlsdXJlIF0KIG1hdGhtbC9vcGVudHlwZS9v cGVudHlwZS1zdHJldGNoeS1ob3Jpem9udGFsLmh0bWwgWyBTa2lwIF0gICMgQ3Jhc2hpbmcKIG1h dGhtbC9wcmVzZW50YXRpb24vc3R5bGUtY2hhbmdlZC5odG1sIFsgQ3Jhc2ggUGFzcyBdCiB3ZWJr aXQub3JnL2IvMTQwNTIyIG1hdGhtbC9vcGVudHlwZS9tdW5kZXJvdmVyLWxheW91dC1yZXNpemUu aHRtbCBbIFNraXAgXSAgIyBDcmFzaGluZwotbWF0aG1sL3ZlcnktbGFyZ2Utc3RyZXRjaHktb3Bl cmF0b3JzLmh0bWwgWyBTa2lwIF0KICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCiAjIyMjIyMjIyMj IyMjIyMjIyAgICAgICAgICBFbmQgTWF0aE1MIElzc3VlcyAgICAgICAgICAgICAgICAjIyMjIyMj IyMjIyMjIyMjIyMjIwogIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMj IyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwMzc0 YmQ0Li4yMWY5ZDc1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTYtMDYtMjcgIEZy ZWRlcmljIFdhbmcgIDxmd2FuZ0BpZ2FsaWEuY29tPgorCisgICAgICAgIFNldCBhbiB1cHBlciBs aW1pdCBmb3IgdGhlIHNpemUgb3IgbnVtYmVyIG9mIHBpZWNlcyBvZiBzdHJldGNoeSBvcGVyYXRv cnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE1NTQz NAorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFN0cmV0 Y2h5IE1hdGhNTCBvcGVyYXRvcnMgY2FuIGN1cnJlbnRseSB1c2UgYW4gYXJiaXRyYXJ5IG51bWJl ciBvZiBleHRlbnNpb24gZ2x5cGhzIHRvIGNvdmVyCisgICAgICAgIGEgdGFyZ2V0IHNpemUuIFRo aXMgbWF5IHJlc3VsdCBpbiBoYW5ncyBpZiBsYXJnZSBzdHJldGNoIHNpemVzIGFyZSByZXF1ZXN0 ZWQuIFRoaXMgY2hhbmdlCisgICAgICAgIG9ubHkgYWxsb3cgYXQgbW9zdCB0aGUgMTI4IGZpcnN0 IGV4dGVuc2lvbnMgdG8gYmUgcGFpbnRlZCBieSB0aGUgTWF0aE9wZXJhdG9yIGNsYXNzLCB3aGlj aAorICAgICAgICBzaG91bGQgcmVhbGx5IGJlIGVub3VnaCBmb3IgbWF0aGVtYXRpY2FsIGZvcm11 bGFzIHVzZWQgaW4gcHJhY3RpY2UuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLCBhbHJlYWR5IHRl c3RlZCBieSB2ZXJ5LWxhcmdlLXN0cmV0Y2h5LW9wZXJhdG9ycy4KKworICAgICAgICAqIHJlbmRl cmluZy9tYXRobWwvTWF0aE9wZXJhdG9yLmNwcDogQWRkIGEgbmV3IGtNYXhpbXVtRXh0ZW5zaW9u Q291bnQgY29uc3RhbnQuCisgICAgICAgIChXZWJDb3JlOjpNYXRoT3BlcmF0b3I6OmZpbGxXaXRo VmVydGljYWxFeHRlbnNpb25HbHlwaCk6IExpbWl0IHRoZSBudW1iZXIgb2Ygc3RlcCBpbiB0aGlz IGxvb3AgdG8ga01heGltdW1FeHRlbnNpb25Db3VudC4KKyAgICAgICAgKFdlYkNvcmU6Ok1hdGhP cGVyYXRvcjo6ZmlsbFdpdGhIb3Jpem9udGFsRXh0ZW5zaW9uR2x5cGgpOiBEaXR0by4KKwogMjAx Ni0wNi0yNyAgTWlndWVsIEdvbWV6ICA8bWFnb21lekBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtH VEtdW0VGTF0gQnVpbGQgd2l0aCB0aHJlYWRlZCBjb21wb3NpdG9yIGVuYWJsZWQgaXMgYnJva2Vu CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL01hdGhPcGVyYXRv ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL01hdGhPcGVyYXRvci5jcHAK aW5kZXggNzQ2YTk2Ni4uODE1NTI1NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL21hdGhtbC9NYXRoT3BlcmF0b3IuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9tYXRobWwvTWF0aE9wZXJhdG9yLmNwcApAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIlN0 eWxlSW5oZXJpdGVkRGF0YS5oIgogCiBzdGF0aWMgY29uc3QgdW5zaWduZWQga1JhZGljYWxPcGVy YXRvciA9IDB4MjIxQTsKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBrTWF4aW11bUV4dGVuc2lvbkNv dW50ID0gMTI4OwogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTQ5MCw5ICs0OTEsOCBAQCB2 b2lkIE1hdGhPcGVyYXRvcjo6ZmlsbFdpdGhWZXJ0aWNhbEV4dGVuc2lvbkdseXBoKGNvbnN0IFJl bmRlclN0eWxlJiBzdHlsZSwgUGFpbgogICAgIExheW91dFBvaW50IGdseXBoT3JpZ2luID0gTGF5 b3V0UG9pbnQoZnJvbS54KCksIGZyb20ueSgpIC0gb2Zmc2V0VG9HbHlwaFRvcCk7CiAgICAgRmxv YXRSZWN0IGxhc3RQYWludGVkR2x5cGhSZWN0KGZyb20sIEZsb2F0U2l6ZSgpKTsKIAotICAgIC8v IEZJWE1FOiBJbiBwcmFjdGljZSwgb25seSBzbWFsbCBzdHJldGNoIHNpemVzIGFyZSByZXF1ZXN0 ZWQgYnV0IHdlIG1heSBuZWVkIHRvIGxpbWl0IHRoZSBudW1iZXIKLSAgICAvLyBvZiBwaWVjZXMg dGhhdCBjYW4gYmUgcmVwZWF0ZWQgdG8gYXZvaWQgaGFuZ3MuIFNlZSBodHRwOi8vd2Via2l0Lm9y Zy9iLzE1NTQzNAotICAgIHdoaWxlIChsYXN0UGFpbnRlZEdseXBoUmVjdC5tYXhZKCkgPCB0by55 KCkpIHsKKyAgICAvLyBJbiBwcmFjdGljZSwgb25seSBzbWFsbCBzdHJldGNoIHNpemVzIGFyZSBy ZXF1ZXN0ZWQgYnV0IHdlIGxpbWl0IHRoZSBudW1iZXIgb2YgZ2x5cGhzIHRvIGF2b2lkIGhhbmdz LgorICAgIGZvciAodW5zaWduZWQgZXh0ZW5zaW9uQ291bnQgPSAwOyBsYXN0UGFpbnRlZEdseXBo UmVjdC5tYXhZKCkgPCB0by55KCkgJiYgZXh0ZW5zaW9uQ291bnQgPCBrTWF4aW11bUV4dGVuc2lv bkNvdW50OyBleHRlbnNpb25Db3VudCsrKSB7CiAgICAgICAgIGxhc3RQYWludGVkR2x5cGhSZWN0 ID0gcGFpbnRHbHlwaChzdHlsZSwgaW5mbywgbV9hc3NlbWJseS5leHRlbnNpb24sIGdseXBoT3Jp Z2luLCBUcmltVG9wQW5kQm90dG9tKTsKICAgICAgICAgZ2x5cGhPcmlnaW4uc2V0WShnbHlwaE9y aWdpbi55KCkgKyBsYXN0UGFpbnRlZEdseXBoUmVjdC5oZWlnaHQoKSk7CiAKQEAgLTUyOSw5ICs1 MjksOCBAQCB2b2lkIE1hdGhPcGVyYXRvcjo6ZmlsbFdpdGhIb3Jpem9udGFsRXh0ZW5zaW9uR2x5 cGgoY29uc3QgUmVuZGVyU3R5bGUmIHN0eWxlLCBQYQogICAgIExheW91dFBvaW50IGdseXBoT3Jp Z2luID0gTGF5b3V0UG9pbnQoZnJvbS54KCkgKyBvZmZzZXRUb0dseXBoTGVmdCwgZnJvbS55KCkp OwogICAgIEZsb2F0UmVjdCBsYXN0UGFpbnRlZEdseXBoUmVjdChmcm9tLCBGbG9hdFNpemUoKSk7 CiAKLSAgICAvLyBGSVhNRTogSW4gcHJhY3RpY2UsIG9ubHkgc21hbGwgc3RyZXRjaCBzaXplcyBh cmUgcmVxdWVzdGVkIGJ1dCB3ZSBtYXkgbmVlZCB0byBsaW1pdCB0aGUgbnVtYmVyCi0gICAgLy8g b2YgcGllY2VzIHRoYXQgY2FuIGJlIHJlcGVhdGVkIHRvIGF2b2lkIGhhbmdzLiBTZWUgaHR0cDov L3dlYmtpdC5vcmcvYi8xNTU0MzQKLSAgICB3aGlsZSAobGFzdFBhaW50ZWRHbHlwaFJlY3QubWF4 WCgpIDwgdG8ueCgpKSB7CisgICAgLy8gSW4gcHJhY3RpY2UsIG9ubHkgc21hbGwgc3RyZXRjaCBz aXplcyBhcmUgcmVxdWVzdGVkIGJ1dCB3ZSBsaW1pdCB0aGUgbnVtYmVyIG9mIGdseXBocyB0byBh dm9pZCBoYW5ncy4KKyAgICBmb3IgKHVuc2lnbmVkIGV4dGVuc2lvbkNvdW50ID0gMDsgbGFzdFBh aW50ZWRHbHlwaFJlY3QubWF4WCgpIDwgdG8ueCgpICYmIGV4dGVuc2lvbkNvdW50IDwga01heGlt dW1FeHRlbnNpb25Db3VudDsgZXh0ZW5zaW9uQ291bnQrKykgewogICAgICAgICBsYXN0UGFpbnRl ZEdseXBoUmVjdCA9IHBhaW50R2x5cGgoc3R5bGUsIGluZm8sIG1fYXNzZW1ibHkuZXh0ZW5zaW9u LCBnbHlwaE9yaWdpbiwgVHJpbUxlZnRBbmRSaWdodCk7CiAgICAgICAgIGdseXBoT3JpZ2luLnNl dFgoZ2x5cGhPcmlnaW4ueCgpICsgbGFzdFBhaW50ZWRHbHlwaFJlY3Qud2lkdGgoKSk7CiAKLS0g CjIuOC4xCgo=