24763 2009-03-23 13:18:53 -0700 Position should support neighbor-anchored positions 2011-05-17 10:49:37 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) Mac OS X 10.5 RESOLVED FIXED P2 Normal --- 24966 1 eric eric darin justin.garcia rniwa oldest_to_newest 114835 0 eric 2009-03-23 13:18:53 -0700 Position should support neighbor-anchored positions I'm using this as a tracking bug, for the introduction of neighbor anchored positions. I have some patches in my tree I could upload here for examples as to what I mean. Right now we have Position which can hold [node, offset], but sometimes [node, 0] means "first offset in node" and sometimes it means "last offset before node", based on whether or not editingIgnoresContent(node) returns true or not. I plan to change this so that neighbor-anchoring or container-anchoring is explicit in the Position object. Then we can have a position [table, 0] which means "first offset in the table" (which we can't currently express using a Position object since tables are ignored content for editing). 116595 1 eric 2009-04-06 02:11:07 -0700 This will take a few patches to make this work. Two are attached to bug 24966 and bug 25056 (the big one). I'll attach the last 3 (smaller) pieces here. 116596 2 29274 eric 2009-04-06 02:11:43 -0700 Created attachment 29274 Add containerNode(), computeOffsetInContainerNode(), nodeBeforePosition(), nodeAfterPosition() WebCore/ChangeLog | 21 +++++++++++ WebCore/dom/Position.cpp | 85 ++++++++++++++++++++++++++++++++++++++++++++++ WebCore/dom/Position.h | 17 +++++++++ 3 files changed, 123 insertions(+), 0 deletions(-) 116597 3 29275 eric 2009-04-06 02:12:08 -0700 Created attachment 29275 Pre-computed and store AnchorType and isLegacyEditingPosition on Position during construction WebCore/ChangeLog | 29 +++++++++++++++++++++ WebCore/WebCore.base.exp | 1 + WebCore/dom/Position.cpp | 63 ++++++++++++++++++++++++++++++++++++--------- WebCore/dom/Position.h | 50 ++++++++++++++++++++---------------- 4 files changed, 108 insertions(+), 35 deletions(-) 116598 4 29276 eric 2009-04-06 02:12:14 -0700 Created attachment 29276 Fix Position == operator to match our new fancy positions LayoutTests/ChangeLog | 21 ++++++++++++ LayoutTests/editing/execCommand/19089-expected.txt | 2 +- .../insert-paragraph-04-expected.checksum | 2 +- .../inserting/insert-paragraph-04-expected.png | Bin 29882 -> 29883 bytes .../inserting/insert-paragraph-04-expected.txt | 3 +- WebCore/ChangeLog | 20 ++++++++++++ WebCore/dom/Position.h | 33 ++++++++++++++++++-- 7 files changed, 74 insertions(+), 7 deletions(-) 116601 5 eric 2009-04-06 02:25:15 -0700 The next step will be to remove rangeCompliantEquivalent https://bugs.webkit.org/show_bug.cgi?id=25057. Next step after that will be to make Range methods (including JSRange stuff) create non-legacy Parent-anchored positions. This means that positions passed into the engine through range methods will support specifying offsets inside ignored editing content. We'll have to fix the resulting fallout in the editing code as a result. :) 116617 6 29274 darin 2009-04-06 09:09:30 -0700 Comment on attachment 29274 Add containerNode(), computeOffsetInContainerNode(), nodeBeforePosition(), nodeAfterPosition() > + switch (anchorType()) { > + case PositionIsOffsetInAnchor: > + return m_anchorNode.get(); I prefer indenting the cases inside the switch statements. > + case PositionIsOffsetInAnchor: > + { Opening brace should be on same line as case. > +// FIXME: Position should store an AnchorType up-front, instead of lazily > +// determining it via editingIgnoresContent(anchorNode()) > +// That would require fixing moveToOffset to know how to recompute the AnchorType > +// for positions which need historical editing-compatible behavior > +// (and for explicitly anchored positions to ASSERT_NOT_REACHED()) Or maybe you could just compute the anchor type at construction time for now. > + // These are always DOM compliant values. Editing positions like [img, 0] (aka [img, before]) > + // will return img->parentNode() and img->nodeIndex() from these functions. > + Node* containerNode() const; > + int computeOffsetInContainerNode() const; > + > + // These are convenience methods which are smart about whether the position is neighbor anchored or parent anchored > + Node* nodeBeforePosition() const; > + Node* nodeAfterPosition() const; I'm not sure I understand the rule for when you use "compute" and when you don't. It seems that nodeBeforePosition and nodeAfterPosition can both be expensive operations that involve calling childNode, so it seems they should have compute in their names unless and until you change the class's design. r=me, but I am concerned about the "compute" rule. 116621 7 29275 darin 2009-04-06 09:29:43 -0700 Comment on attachment 29275 Pre-computed and store AnchorType and isLegacyEditingPosition on Position during construction > -Element *Position::element() const > +Element* Position::element() const It seems to me that both element() and node() need to eventually be private unless it's clearer whether they should be named anchorNode or what. > + Position() > + : m_offset(0) > + , m_anchorType(PositionIsOffsetInAnchor) > + , m_isLegacyEditingPosition(true) // FIXME: Switch the null position to not be in legacy mode > {} Braces should be on separate lines. > void clear() { m_anchorNode.clear(); m_offset = 0; } This should set m_anchorType to PositionIsOffsetInAnchor and set m_isLegacyEditingPosition to true. > + // These should only be used for PositionIsOffsetInAnchor positions, unless > + // the position is a legacy editing position. > + void moveToPosition(PassRefPtr<Node> anchorNode, int offset); > + void moveToOffset(int offset); Do the implementations have an assertion to this effect? Also, I think that moveToPosition seems like a full assignment that could entirely wipe out the old value of Position. I don't think a Position should necessarily have a persistent mode that outlasts it value. Obviously, moveToOffset is different in this respect since it's not a full assignment. r=me 116756 8 eric 2009-04-07 06:15:20 -0700 (In reply to comment #6) > (From update of attachment 29274 [review]) > > + switch (anchorType()) { > > + case PositionIsOffsetInAnchor: > > + return m_anchorNode.get(); > > I prefer indenting the cases inside the switch statements. Me too. :) But that's a violation of the style guide: http://webkit.org/coding/coding-style.html r=me to change the style guide to require indenting case: statements. > > + case PositionIsOffsetInAnchor: > > + { > > Opening brace should be on same line as case. This wasn't covered in the style guide, so I made a guess. :) > > +// FIXME: Position should store an AnchorType up-front, instead of lazily > > +// determining it via editingIgnoresContent(anchorNode()) > > +// That would require fixing moveToOffset to know how to recompute the AnchorType > > +// for positions which need historical editing-compatible behavior > > +// (and for explicitly anchored positions to ASSERT_NOT_REACHED()) > > Or maybe you could just compute the anchor type at construction time for now. Yeah, done in a separate patch. I tried to keep these small-as-possible. This rewrite has been a huge pain, mostly due to my initial attempts trying to change too much at once. > > + // These are always DOM compliant values. Editing positions like [img, 0] (aka [img, before]) > > + // will return img->parentNode() and img->nodeIndex() from these functions. > > + Node* containerNode() const; > > + int computeOffsetInContainerNode() const; > > + > > + // These are convenience methods which are smart about whether the position is neighbor anchored or parent anchored > > + Node* nodeBeforePosition() const; > > + Node* nodeAfterPosition() const; > > I'm not sure I understand the rule for when you use "compute" and when you > don't. It seems that nodeBeforePosition and nodeAfterPosition can both be > expensive operations that involve calling childNode, so it seems they should > have compute in their names unless and until you change the class's design. Agreed! Yes, these should definitely be named "compute" since they call childNode() in the parent-anchor case. I'm not sure I like computeOffsetInContainer() anymore. I might change callers to use a toParentAnchoredPosition() or makeParentAnchored() call instead. Not sure yet. 116758 9 29275 eric 2009-04-07 06:44:50 -0700 Comment on attachment 29275 Pre-computed and store AnchorType and isLegacyEditingPosition on Position during construction Waiting to land this one until bug 25056 is resolved. Will address your comments of course! 116766 10 29274 eric 2009-04-07 07:26:35 -0700 Comment on attachment 29274 Add containerNode(), computeOffsetInContainerNode(), nodeBeforePosition(), nodeAfterPosition() I made Darin's suggested modifications and committed this patch as: Committing to http://svn.webkit.org/repository/webkit/trunk ... M WebCore/ChangeLog M WebCore/dom/Position.cpp M WebCore/dom/Position.h Committed r42263 Removing review flag and marking obsolete so as to not to cause confusion with the other 2 remaining patches (one which needs review, and the other which needs landing). 116784 11 29276 darin 2009-04-07 12:14:02 -0700 Comment on attachment 29276 Fix Position == operator to match our new fancy positions I'm not sure that we want == to behave this way. We might instead want a named comparison that works this way, perhaps named equivalent() or something like that. I think reasonable to overload the built-in operators when the operation is a truly primitive low-level operation, but when two Position objects are == even though some of their accessors will return different values, I think we are creating a design problem. 119504 12 29275 eric 2009-04-30 12:40:59 -0700 Comment on attachment 29275 Pre-computed and store AnchorType and isLegacyEditingPosition on Position during construction Committed this patch as: Committing to http://svn.webkit.org/repository/webkit/trunk ... M WebCore/ChangeLog M WebCore/WebCore.base.exp M WebCore/dom/Position.cpp M WebCore/dom/Position.h Committed r43075 I made corrections per your review comments. 122613 13 29276 mjs 2009-05-22 01:42:55 -0700 Comment on attachment 29276 Fix Position == operator to match our new fancy positions Marking as r- per Darin's comment above. 405155 14 eric 2011-05-17 10:49:37 -0700 I believe we have neighbor anchored positions these days, so I'm closing this. CC'd ryosuke on the off chance he finds the old patch on this bug useful. 29274 2009-04-06 02:11:43 -0700 2009-04-07 07:26:35 -0700 Add containerNode(), computeOffsetInContainerNode(), nodeBeforePosition(), nodeAfterPosition() Add-containerNode-computeOffsetInContainerNode-nodeBeforePosition-nodeAfterPosition-.patch text/plain 4982 eric ZmYxN2Y0Zjg0YzBjZmJiNDdiYzhkMmU5MzA4YjkwN2Q2MDFlYWZkNQpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwMWZlN2ZjLi42ODRhNjJl IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDI0IEBACisyMDA5LTAzLTI3ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQg Y29udGFpbmVyTm9kZSgpLCBjb21wdXRlT2Zmc2V0SW5Db250YWluZXJOb2RlKCksCisgICAgICAg IG5vZGVCZWZvcmVQb3NpdGlvbigpIGFuZCBub2RlQWZ0ZXJQb3NpdGlvbigpLgorICAgICAgICAK KyAgICAgICAgVGhlc2UgZnVuY3Rpb25zIHdpbGwgcmVwbGFjZSB1c2VzIG9mIHJhbmdlQ29tcGxp YW50UG9zaXRpb24oKQorICAgICAgICBpbiBmdXR1cmUgcGF0Y2hlcy4KKworICAgICAgICBObyBj aGFuZ2VzIGluIGJlaGF2aW9yLCB0aHVzIG5vIHRlc3RzLgorCisgICAgICAgICogZG9tL1Bvc2l0 aW9uLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjpjb250YWluZXJOb2RlKToKKyAg ICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjpjb21wdXRlT2Zmc2V0SW5Db250YWluZXJOb2RlKToK KyAgICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjpub2RlQmVmb3JlUG9zaXRpb24pOgorICAgICAg ICAoV2ViQ29yZTo6UG9zaXRpb246Om5vZGVBZnRlclBvc2l0aW9uKToKKyAgICAgICAgKFdlYkNv cmU6OlBvc2l0aW9uOjphbmNob3JUeXBlKToKKyAgICAgICAgKiBkb20vUG9zaXRpb24uaDoKKyAg ICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjopOgorCiAyMDA5LTAzLTMxICBBbHBoYSBMYW0gIDxo Y2xhbUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCmRp ZmYgLS1naXQgYS9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5jcHAgYi9XZWJDb3JlL2RvbS9Qb3NpdGlv bi5jcHAKaW5kZXggYTI1OTFiYS4uNGY3NzUxZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9kb20vUG9z aXRpb24uY3BwCisrKyBiL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmNwcApAQCAtNzMsNiArNzMsOTEg QEAgc3RhdGljIE5vZGUqIHByZXZpb3VzUmVuZGVyZWRFZGl0YWJsZShOb2RlKiBub2RlKQogICAg IHJldHVybiAwOwogfQogCitOb2RlKiBQb3NpdGlvbjo6Y29udGFpbmVyTm9kZSgpIGNvbnN0Cit7 CisgICAgaWYgKCFtX2FuY2hvck5vZGUpCisgICAgICAgIHJldHVybiAwOworCisgICAgc3dpdGNo IChhbmNob3JUeXBlKCkpIHsKKyAgICBjYXNlIFBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcjoKKyAg ICAgICAgcmV0dXJuIG1fYW5jaG9yTm9kZS5nZXQoKTsKKyAgICBjYXNlIFBvc2l0aW9uSXNCZWZv cmVBbmNob3I6CisgICAgY2FzZSBQb3NpdGlvbklzQWZ0ZXJBbmNob3I6CisgICAgICAgIHJldHVy biBtX2FuY2hvck5vZGUtPnBhcmVudE5vZGUoKTsKKyAgICB9CisgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7CisgICAgcmV0dXJuIDA7Cit9CisKK2ludCBQb3NpdGlvbjo6Y29tcHV0ZU9mZnNldElu Q29udGFpbmVyTm9kZSgpIGNvbnN0Cit7CisgICAgaWYgKCFtX2FuY2hvck5vZGUpCisgICAgICAg IHJldHVybiAwOworCisgICAgc3dpdGNoIChhbmNob3JUeXBlKCkpIHsKKyAgICBjYXNlIFBvc2l0 aW9uSXNPZmZzZXRJbkFuY2hvcjoKKyAgICB7CisgICAgICAgIGludCBtYXhpbXVtVmFsaWRPZmZz ZXQgPSBtX2FuY2hvck5vZGUtPm9mZnNldEluQ2hhcmFjdGVycygpID8gbV9hbmNob3JOb2RlLT5t YXhDaGFyYWN0ZXJPZmZzZXQoKSA6IG1fYW5jaG9yTm9kZS0+Y2hpbGROb2RlQ291bnQoKTsKKyAg ICAgICAgcmV0dXJuIHN0ZDo6bWluKG1heGltdW1WYWxpZE9mZnNldCwgbV9vZmZzZXQpOworICAg IH0KKyAgICBjYXNlIFBvc2l0aW9uSXNCZWZvcmVBbmNob3I6CisgICAgICAgIHJldHVybiBtX2Fu Y2hvck5vZGUtPm5vZGVJbmRleCgpOworICAgIGNhc2UgUG9zaXRpb25Jc0FmdGVyQW5jaG9yOgor ICAgICAgICByZXR1cm4gbV9hbmNob3JOb2RlLT5ub2RlSW5kZXgoKSArIDE7CisgICAgfQorICAg IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIHJldHVybiAwOworfQorCitOb2RlKiBQb3NpdGlv bjo6bm9kZUJlZm9yZVBvc2l0aW9uKCkgY29uc3QKK3sKKyAgICBpZiAoIW1fYW5jaG9yTm9kZSkK KyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBzd2l0Y2ggKGFuY2hvclR5cGUoKSkgeworICAgIGNh c2UgUG9zaXRpb25Jc09mZnNldEluQW5jaG9yOgorICAgICAgICByZXR1cm4gbV9hbmNob3JOb2Rl LT5jaGlsZE5vZGUobV9vZmZzZXQgLSAxKTsgLy8gLTEgY29udmVydHMgdG8gY2hpbGROb2RlKCh1 bnNpZ25lZCktMSkgYW5kIHJldHVybnMgbnVsbC4KKyAgICBjYXNlIFBvc2l0aW9uSXNCZWZvcmVB bmNob3I6CisgICAgICAgIHJldHVybiBtX2FuY2hvck5vZGUtPnByZXZpb3VzU2libGluZygpOwor ICAgIGNhc2UgUG9zaXRpb25Jc0FmdGVyQW5jaG9yOgorICAgICAgICByZXR1cm4gbV9hbmNob3JO b2RlLmdldCgpOworICAgIH0KKyAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICByZXR1cm4g MDsKK30KKworTm9kZSogUG9zaXRpb246Om5vZGVBZnRlclBvc2l0aW9uKCkgY29uc3QKK3sKKyAg ICBpZiAoIW1fYW5jaG9yTm9kZSkKKyAgICAgICAgcmV0dXJuIDA7CisKKyAgICBzd2l0Y2ggKGFu Y2hvclR5cGUoKSkgeworICAgIGNhc2UgUG9zaXRpb25Jc09mZnNldEluQW5jaG9yOgorICAgICAg ICByZXR1cm4gbV9hbmNob3JOb2RlLT5jaGlsZE5vZGUobV9vZmZzZXQpOworICAgIGNhc2UgUG9z aXRpb25Jc0JlZm9yZUFuY2hvcjoKKyAgICAgICAgcmV0dXJuIG1fYW5jaG9yTm9kZS5nZXQoKTsK KyAgICBjYXNlIFBvc2l0aW9uSXNBZnRlckFuY2hvcjoKKyAgICAgICAgcmV0dXJuIG1fYW5jaG9y Tm9kZS0+bmV4dFNpYmxpbmcoKTsKKyAgICB9CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Cisg ICAgcmV0dXJuIDA7Cit9CisKKy8vIEZJWE1FOiBQb3NpdGlvbiBzaG91bGQgc3RvcmUgYW4gQW5j aG9yVHlwZSB1cC1mcm9udCwgaW5zdGVhZCBvZiBsYXppbHkKKy8vIGRldGVybWluaW5nIGl0IHZp YSBlZGl0aW5nSWdub3Jlc0NvbnRlbnQoYW5jaG9yTm9kZSgpKQorLy8gVGhhdCB3b3VsZCByZXF1 aXJlIGZpeGluZyBtb3ZlVG9PZmZzZXQgdG8ga25vdyBob3cgdG8gcmVjb21wdXRlIHRoZSBBbmNo b3JUeXBlCisvLyBmb3IgcG9zaXRpb25zIHdoaWNoIG5lZWQgaGlzdG9yaWNhbCBlZGl0aW5nLWNv bXBhdGlibGUgYmVoYXZpb3IKKy8vIChhbmQgZm9yIGV4cGxpY2l0bHkgYW5jaG9yZWQgcG9zaXRp b25zIHRvIEFTU0VSVF9OT1RfUkVBQ0hFRCgpKQorUG9zaXRpb246OkFuY2hvclR5cGUgUG9zaXRp b246OmFuY2hvclR5cGUoKSBjb25zdAoreworICAgIGlmIChtX2FuY2hvck5vZGUgJiYgZWRpdGlu Z0lnbm9yZXNDb250ZW50KG1fYW5jaG9yTm9kZS5nZXQoKSkpIHsKKyAgICAgICAgaWYgKG1fb2Zm c2V0ID09IDApCisgICAgICAgICAgICByZXR1cm4gUG9zaXRpb25Jc0JlZm9yZUFuY2hvcjsKKyAg ICAgICAgcmV0dXJuIFBvc2l0aW9uSXNBZnRlckFuY2hvcjsKKyAgICB9CisgICAgcmV0dXJuIFBv c2l0aW9uSXNPZmZzZXRJbkFuY2hvcjsKK30KKwogRWxlbWVudCogUG9zaXRpb246OmRvY3VtZW50 RWxlbWVudCgpIGNvbnN0CiB7CiAgICAgaWYgKE5vZGUqIG4gPSBub2RlKCkpCmRpZmYgLS1naXQg YS9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oIGIvV2ViQ29yZS9kb20vUG9zaXRpb24uaAppbmRleCA4 ZWZiMTBmLi5jM2RmMmVkIDEwMDY0NAotLS0gYS9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oCisrKyBi L1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmgKQEAgLTYyLDYgKzYyLDE1IEBAIHB1YmxpYzoKIAogICAg IHZvaWQgY2xlYXIoKSB7IG1fYW5jaG9yTm9kZS5jbGVhcigpOyBtX29mZnNldCA9IDA7IH0KIAor ICAgIC8vIFRoZXNlIGFyZSBhbHdheXMgRE9NIGNvbXBsaWFudCB2YWx1ZXMuICBFZGl0aW5nIHBv c2l0aW9ucyBsaWtlIFtpbWcsIDBdIChha2EgW2ltZywgYmVmb3JlXSkKKyAgICAvLyB3aWxsIHJl dHVybiBpbWctPnBhcmVudE5vZGUoKSBhbmQgaW1nLT5ub2RlSW5kZXgoKSBmcm9tIHRoZXNlIGZ1 bmN0aW9ucy4KKyAgICBOb2RlKiBjb250YWluZXJOb2RlKCkgY29uc3Q7CisgICAgaW50IGNvbXB1 dGVPZmZzZXRJbkNvbnRhaW5lck5vZGUoKSBjb25zdDsKKworICAgIC8vIFRoZXNlIGFyZSBjb252 ZW5pZW5jZSBtZXRob2RzIHdoaWNoIGFyZSBzbWFydCBhYm91dCB3aGV0aGVyIHRoZSBwb3NpdGlv biBpcyBuZWlnaGJvciBhbmNob3JlZCBvciBwYXJlbnQgYW5jaG9yZWQKKyAgICBOb2RlKiBub2Rl QmVmb3JlUG9zaXRpb24oKSBjb25zdDsKKyAgICBOb2RlKiBub2RlQWZ0ZXJQb3NpdGlvbigpIGNv bnN0OworCiAgICAgTm9kZSogYW5jaG9yTm9kZSgpIGNvbnN0IHsgcmV0dXJuIG1fYW5jaG9yTm9k ZS5nZXQoKTsgfQogCiAgICAgLy8gRklYTUU6IENhbGxlcnMgc2hvdWxkIGJlIG1vdmVkIG9mZiBv ZiBub2RlKCksIG5vZGUoKSBpcyBub3QgYWx3YXlzIHRoZSBjb250YWluZXIgZm9yIHRoaXMgcG9z aXRpb24uCkBAIC0xMzMsNiArMTQyLDE0IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgaW50IHJl bmRlcmVkT2Zmc2V0KCkgY29uc3Q7CiAKKyAgICBlbnVtIEFuY2hvclR5cGUgeworICAgICAgICBQ b3NpdGlvbklzT2Zmc2V0SW5BbmNob3IsCisgICAgICAgIFBvc2l0aW9uSXNBZnRlckFuY2hvciwK KyAgICAgICAgUG9zaXRpb25Jc0JlZm9yZUFuY2hvcgorICAgIH07CisKKyAgICBBbmNob3JUeXBl IGFuY2hvclR5cGUoKSBjb25zdDsKKwogICAgIFBvc2l0aW9uIHByZXZpb3VzQ2hhcmFjdGVyUG9z aXRpb24oRUFmZmluaXR5KSBjb25zdDsKICAgICBQb3NpdGlvbiBuZXh0Q2hhcmFjdGVyUG9zaXRp b24oRUFmZmluaXR5KSBjb25zdDsKIAo= 29275 2009-04-06 02:12:08 -0700 2009-04-30 12:40:59 -0700 Pre-computed and store AnchorType and isLegacyEditingPosition on Position during construction Pre-computed-and-store-AnchorType-and-isLegacyEditingPosition-on-Position-during-construction.patch text/plain 8057 eric ZDgxMDhjYjliMjZmODA1NzNiZjlhMDEzODcxYWFhNTFiOTA0NDE4NwpkaWZmIC0tZ2l0IGEvV2Vi Q29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2NDZiYTRiLi42OTc5NWI3 IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpA QCAtMSwzICsxLDMyIEBACisyMDA5LTA0LTAyICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9y Zz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBDaGFu Z2UgUG9zaXRpb24gdG8gcHJlLWNvbXB1dGUgdGhlIEFuY2hvclR5cGUgYW5kIHN0b3JlIGl0Lgor ICAgICAgICBBbHNvIHN0b3JlIGEgImxlZ2FjeSBlZGl0aW5nIG1vZGUiIGJpdCBvbiB0aGUgUG9z aXRpb24uCisKKyAgICAgICAgVGhlIG9sZCBQb3N0aW9uKG5vZGUsIG9mZnNldCkgY29uc3RydWN0 b3IgY3JlYXRlcyBsZWdhY3kgcG9zaXRpb25zCisgICAgICAgIGJ1dCB0aGVyZSBhcmUgbmV3IGNv bnN0cnVjdG9ycyB0byBjcmVhdGUgZXhwbGljaXRseSBhbmNob3JlZCBwb3NpdGlvbnMKKyAgICAg ICAgd2hpY2ggdGhlIG5leHQgcGF0Y2ggd2lsbCB1c2UuCisKKyAgICAgICAgT25jZSB3ZSBmaXgg YWxsIHRoZSAicG9zaXRpb24tZml4dXAiIGZ1bmN0aW9ucyAobGlrZSByYW5nZUNvbXBsaWFudEVx dWl2YWxlbnQpIHRvCisgICAgICAgIG9ubHkgYWZmZWN0IGxlZ2FjeSBwb3NpdGlvbnMsIHdlIHdp bGwgYmUgYWJsZSB0byBkaXN0aW5ndWlzaAorICAgICAgICBiZXR3ZWVuIFt0YWJsZSwgMV0gYW5k IFt0YWJsZSwgYWZ0ZXJdIGluIHRoZSBjb2RlIGNvcnJlY3RseSEKKworICAgICAgICAqIFdlYkNv cmUuYmFzZS5leHA6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIGRvbS9Qb3NpdGlvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQb3NpdGlv bjo6UG9zaXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246Om1vdmVUb1Bvc2l0aW9u KToKKyAgICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjptb3ZlVG9PZmZzZXQpOgorICAgICAgICAo V2ViQ29yZTo6UG9zaXRpb246OmFuY2hvclR5cGVGb3JMZWdhY3lFZGl0aW5nUG9zaXRpb24pOgor ICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246OmVsZW1lbnQpOgorICAgICAgICAqIGRvbS9Qb3Np dGlvbi5oOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246Oik6CisgICAgICAgIChXZWJDb3Jl OjpQb3NpdGlvbjo6UG9zaXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246OmFuY2hv clR5cGUpOgorICAgICAgICAoV2ViQ29yZTo6UG9zaXRpb246OmRlcHJlY2F0ZWRFZGl0aW5nT2Zm c2V0KToKKwogMjAwOS0wMy0zMSAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCmRpZmYgLS1naXQgYS9XZWJDb3JlL1dl YkNvcmUuYmFzZS5leHAgYi9XZWJDb3JlL1dlYkNvcmUuYmFzZS5leHAKaW5kZXggZmU2ZjQxZi4u YmQ0OTg1NCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9XZWJDb3JlLmJhc2UuZXhwCisrKyBiL1dlYkNv cmUvV2ViQ29yZS5iYXNlLmV4cApAQCAtNTgyLDYgKzU4Miw3IEBAIF9fWk43V2ViQ29yZThEb2N1 bWVudDRoZWFkRXYKIF9fWk43V2ViQ29yZThEcmFnRGF0YUMxRVAxMW9iamNfb2JqZWN0UktOU184 SW50UG9pbnRFUzVfTlNfMTNEcmFnT3BlcmF0aW9uRVBOU18xNlBhc3RlYm9hcmRIZWxwZXJFCiBf X1pON1dlYkNvcmU4Rm9ybURhdGFEMUV2CiBfX1pON1dlYkNvcmU4SW50UG9pbnRDMUVSSzhfTlNQ b2ludAorX19aTjdXZWJDb3JlOFBvc2l0aW9uQzFFTjNXVEYxMFBhc3NSZWZQdHJJTlNfNE5vZGVF RUVpCiBfX1pON1dlYkNvcmU4U2V0dGluZ3MxNHNldEphdmFFbmFibGVkRWIKIF9fWk43V2ViQ29y ZThTZXR0aW5nczE2c2V0VXNlc1BhZ2VDYWNoZUViCiBfX1pON1dlYkNvcmU4U2V0dGluZ3MxNnNl dFpvb21zVGV4dE9ubHlFYgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUG9zaXRpb24uY3BwIGIv V2ViQ29yZS9kb20vUG9zaXRpb24uY3BwCmluZGV4IDRmNzc1MWUuLjI4ZTRlNzIgMTAwNjQ0Ci0t LSBhL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmNwcAorKysgYi9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5j cHAKQEAgLTczLDYgKzczLDQ4IEBAIHN0YXRpYyBOb2RlKiBwcmV2aW91c1JlbmRlcmVkRWRpdGFi bGUoTm9kZSogbm9kZSkKICAgICByZXR1cm4gMDsKIH0KIAorUG9zaXRpb246OlBvc2l0aW9uKFBh c3NSZWZQdHI8Tm9kZT4gYW5jaG9yTm9kZSwgaW50IG9mZnNldCkKKyAgICA6IG1fYW5jaG9yTm9k ZShhbmNob3JOb2RlKQorICAgICwgbV9vZmZzZXQob2Zmc2V0KQorICAgICwgbV9hbmNob3JUeXBl KGFuY2hvclR5cGVGb3JMZWdhY3lFZGl0aW5nUG9zaXRpb24obV9hbmNob3JOb2RlLmdldCgpLCBt X29mZnNldCkpCisgICAgLCBtX2lzTGVnYWN5RWRpdGluZ1Bvc2l0aW9uKHRydWUpCit7Cit9CisK K1Bvc2l0aW9uOjpQb3NpdGlvbihQYXNzUmVmUHRyPE5vZGU+IGFuY2hvck5vZGUsIEFuY2hvclR5 cGUgYW5jaG9yVHlwZSkKKyAgICA6IG1fYW5jaG9yTm9kZShhbmNob3JOb2RlKQorICAgICwgbV9v ZmZzZXQoMCkKKyAgICAsIG1fYW5jaG9yVHlwZShhbmNob3JUeXBlKQorICAgICwgbV9pc0xlZ2Fj eUVkaXRpbmdQb3NpdGlvbihmYWxzZSkKK3sKKyAgICBBU1NFUlQoYW5jaG9yVHlwZSAhPSBQb3Np dGlvbklzT2Zmc2V0SW5BbmNob3IpOworfQorCitQb3NpdGlvbjo6UG9zaXRpb24oUGFzc1JlZlB0 cjxOb2RlPiBhbmNob3JOb2RlLCBpbnQgb2Zmc2V0LCBBbmNob3JUeXBlIGFuY2hvclR5cGUpCisg ICAgOiBtX2FuY2hvck5vZGUoYW5jaG9yTm9kZSkKKyAgICAsIG1fb2Zmc2V0KG9mZnNldCkKKyAg ICAsIG1fYW5jaG9yVHlwZShhbmNob3JUeXBlKQorICAgICwgbV9pc0xlZ2FjeUVkaXRpbmdQb3Np dGlvbihmYWxzZSkKK3sKKyAgICBBU1NFUlQoYW5jaG9yVHlwZSA9PSBQb3NpdGlvbklzT2Zmc2V0 SW5BbmNob3IpOworfQorCit2b2lkIFBvc2l0aW9uOjptb3ZlVG9Qb3NpdGlvbihQYXNzUmVmUHRy PE5vZGU+IG5vZGUsIGludCBvZmZzZXQpCit7CisgICAgQVNTRVJUKGFuY2hvclR5cGUoKSA9PSBQ b3NpdGlvbklzT2Zmc2V0SW5BbmNob3IgfHwgbV9pc0xlZ2FjeUVkaXRpbmdQb3NpdGlvbik7Cisg ICAgbV9hbmNob3JOb2RlID0gbm9kZTsKKyAgICBtX29mZnNldCA9IG9mZnNldDsKKyAgICBpZiAo bV9pc0xlZ2FjeUVkaXRpbmdQb3NpdGlvbikKKyAgICAgICAgbV9hbmNob3JUeXBlID0gYW5jaG9y VHlwZUZvckxlZ2FjeUVkaXRpbmdQb3NpdGlvbihtX2FuY2hvck5vZGUuZ2V0KCksIG1fb2Zmc2V0 KTsKK30KK3ZvaWQgUG9zaXRpb246Om1vdmVUb09mZnNldChpbnQgb2Zmc2V0KQoreworICAgIEFT U0VSVChhbmNob3JUeXBlKCkgPT0gUG9zaXRpb25Jc09mZnNldEluQW5jaG9yIHx8IG1faXNMZWdh Y3lFZGl0aW5nUG9zaXRpb24pOworICAgIG1fb2Zmc2V0ID0gb2Zmc2V0OworICAgIGlmIChtX2lz TGVnYWN5RWRpdGluZ1Bvc2l0aW9uKQorICAgICAgICBtX2FuY2hvclR5cGUgPSBhbmNob3JUeXBl Rm9yTGVnYWN5RWRpdGluZ1Bvc2l0aW9uKG1fYW5jaG9yTm9kZS5nZXQoKSwgbV9vZmZzZXQpOwor fQorCiBOb2RlKiBQb3NpdGlvbjo6Y29udGFpbmVyTm9kZSgpIGNvbnN0CiB7CiAgICAgaWYgKCFt X2FuY2hvck5vZGUpCkBAIC0xNDMsMTkgKzE4NSwxNCBAQCBOb2RlKiBQb3NpdGlvbjo6bm9kZUFm dGVyUG9zaXRpb24oKSBjb25zdAogICAgIHJldHVybiAwOwogfQogCi0vLyBGSVhNRTogUG9zaXRp b24gc2hvdWxkIHN0b3JlIGFuIEFuY2hvclR5cGUgdXAtZnJvbnQsIGluc3RlYWQgb2YgbGF6aWx5 Ci0vLyBkZXRlcm1pbmluZyBpdCB2aWEgZWRpdGluZ0lnbm9yZXNDb250ZW50KGFuY2hvck5vZGUo KSkKLS8vIFRoYXQgd291bGQgcmVxdWlyZSBmaXhpbmcgbW92ZVRvT2Zmc2V0IHRvIGtub3cgaG93 IHRvIHJlY29tcHV0ZSB0aGUgQW5jaG9yVHlwZQotLy8gZm9yIHBvc2l0aW9ucyB3aGljaCBuZWVk IGhpc3RvcmljYWwgZWRpdGluZy1jb21wYXRpYmxlIGJlaGF2aW9yCi0vLyAoYW5kIGZvciBleHBs aWNpdGx5IGFuY2hvcmVkIHBvc2l0aW9ucyB0byBBU1NFUlRfTk9UX1JFQUNIRUQoKSkKLVBvc2l0 aW9uOjpBbmNob3JUeXBlIFBvc2l0aW9uOjphbmNob3JUeXBlKCkgY29uc3QKK1Bvc2l0aW9uOjpB bmNob3JUeXBlIFBvc2l0aW9uOjphbmNob3JUeXBlRm9yTGVnYWN5RWRpdGluZ1Bvc2l0aW9uKE5v ZGUqIGFuY2hvck5vZGUsIGludCBvZmZzZXQpCiB7Ci0gICAgaWYgKG1fYW5jaG9yTm9kZSAmJiBl ZGl0aW5nSWdub3Jlc0NvbnRlbnQobV9hbmNob3JOb2RlLmdldCgpKSkgewotICAgICAgICBpZiAo bV9vZmZzZXQgPT0gMCkKLSAgICAgICAgICAgIHJldHVybiBQb3NpdGlvbklzQmVmb3JlQW5jaG9y OwotICAgICAgICByZXR1cm4gUG9zaXRpb25Jc0FmdGVyQW5jaG9yOworICAgIGlmIChhbmNob3JO b2RlICYmIGVkaXRpbmdJZ25vcmVzQ29udGVudChhbmNob3JOb2RlKSkgeworICAgICAgICBpZiAo b2Zmc2V0ID09IDApCisgICAgICAgICAgICByZXR1cm4gUG9zaXRpb246OlBvc2l0aW9uSXNCZWZv cmVBbmNob3I7CisgICAgICAgIHJldHVybiBQb3NpdGlvbjo6UG9zaXRpb25Jc0FmdGVyQW5jaG9y OwogICAgIH0KLSAgICByZXR1cm4gUG9zaXRpb25Jc09mZnNldEluQW5jaG9yOworICAgIHJldHVy biBQb3NpdGlvbjo6UG9zaXRpb25Jc09mZnNldEluQW5jaG9yOwogfQogCiBFbGVtZW50KiBQb3Np dGlvbjo6ZG9jdW1lbnRFbGVtZW50KCkgY29uc3QKQEAgLTE2Niw5ICsyMDMsOSBAQCBFbGVtZW50 KiBQb3NpdGlvbjo6ZG9jdW1lbnRFbGVtZW50KCkgY29uc3QKICAgICByZXR1cm4gMDsKIH0KIAot RWxlbWVudCAqUG9zaXRpb246OmVsZW1lbnQoKSBjb25zdAorRWxlbWVudCogUG9zaXRpb246OmVs ZW1lbnQoKSBjb25zdAogewotICAgIE5vZGUgKm47CisgICAgTm9kZSogbjsKICAgICBmb3IgKG4g PSBub2RlKCk7IG4gJiYgIW4tPmlzRWxlbWVudE5vZGUoKTsgbiA9IG4tPnBhcmVudE5vZGUoKSkK ICAgICAgICAgOyAvLyBlbXB0eSBsb29wIGJvZHkKICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8RWxl bWVudCAqPihuKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmggYi9XZWJDb3Jl L2RvbS9Qb3NpdGlvbi5oCmluZGV4IDFhMTkzNjUuLjQ3ZDNmYjcgMTAwNjQ0Ci0tLSBhL1dlYkNv cmUvZG9tL1Bvc2l0aW9uLmgKKysrIGIvV2ViQ29yZS9kb20vUG9zaXRpb24uaApAQCAtNDksMTQg KzQ5LDI4IEBAIGVudW0gUG9zaXRpb25Nb3ZlVHlwZSB7CiAKIGNsYXNzIFBvc2l0aW9uIHsKIHB1 YmxpYzoKLSAgICBQb3NpdGlvbigpIDogbV9vZmZzZXQoMCkgeyB9CisgICAgZW51bSBBbmNob3JU eXBlIHsKKyAgICAgICAgUG9zaXRpb25Jc09mZnNldEluQW5jaG9yLAorICAgICAgICBQb3NpdGlv bklzQWZ0ZXJBbmNob3IsCisgICAgICAgIFBvc2l0aW9uSXNCZWZvcmVBbmNob3IKKyAgICB9Owog Ci0gICAgLy8gVGhpcyBjb25zdHJ1Y3RvciBzaG91bGQgYmUgcHJpdmF0ZQotICAgIFBvc2l0aW9u KFBhc3NSZWZQdHI8Tm9kZT4gYW5jaG9yTm9kZSwgaW50IG9mZnNldCkKLSAgICAgICAgOiBtX2Fu Y2hvck5vZGUoYW5jaG9yTm9kZSkKLSAgICAgICAgLCBtX29mZnNldChvZmZzZXQpCisgICAgUG9z aXRpb24oKQorICAgICAgICA6IG1fb2Zmc2V0KDApCisgICAgICAgICwgbV9hbmNob3JUeXBlKFBv c2l0aW9uSXNPZmZzZXRJbkFuY2hvcikKKyAgICAgICAgLCBtX2lzTGVnYWN5RWRpdGluZ1Bvc2l0 aW9uKHRydWUpIC8vIEZJWE1FOiBTd2l0Y2ggdGhlIG51bGwgcG9zaXRpb24gdG8gbm90IGJlIGlu IGxlZ2FjeSBtb2RlCiAgICAge30KIAorICAgIC8vIEZvciBjcmVhdGluZyBsZWdhY3kgZWRpdGlu ZyBwb3NpdGlvbnM6IChBbmNob3IgdHlwZSB3aWxsIGJlIGRldGVybWluZWQgZnJvbSBlZGl0aW5n SWdub3Jlc0NvbnRlbnQobm9kZSkpCisgICAgUG9zaXRpb24oUGFzc1JlZlB0cjxOb2RlPiBhbmNo b3JOb2RlLCBpbnQgb2Zmc2V0KTsKKworICAgIC8vIEZvciBjcmVhdGluZyBiZWZvcmUvYWZ0ZXIg cG9zaXRpb25zOgorICAgIFBvc2l0aW9uKFBhc3NSZWZQdHI8Tm9kZT4gYW5jaG9yTm9kZSwgQW5j aG9yVHlwZSk7CisgICAgLy8gRm9yIGNyZWF0aW5nIG9mZnNldCBwb3NpdGlvbnM6CisgICAgUG9z aXRpb24oUGFzc1JlZlB0cjxOb2RlPiBhbmNob3JOb2RlLCBpbnQgb2Zmc2V0LCBBbmNob3JUeXBl KTsKKworICAgIEFuY2hvclR5cGUgYW5jaG9yVHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fYW5jaG9y VHlwZTsgfQorCiAgICAgdm9pZCBjbGVhcigpIHsgbV9hbmNob3JOb2RlLmNsZWFyKCk7IG1fb2Zm c2V0ID0gMDsgfQogCiAgICAgLy8gVGhlc2UgYXJlIGFsd2F5cyBET00gY29tcGxpYW50IHZhbHVl cy4gIEVkaXRpbmcgcG9zaXRpb25zIGxpa2UgW2ltZywgMF0gKGFrYSBbaW1nLCBiZWZvcmVdKQpA QCAtNzQsNiArODgsNyBAQCBwdWJsaWM6CiAgICAgLy8gRklYTUU6IENhbGxlcnMgc2hvdWxkIGJl IG1vdmVkIG9mZiBvZiB0aGlzIG1ldGhvZCBhbmQgdGhpcyBkZWNsYXJhdGlvbiByZW1vdmVkLgog ICAgIGludCBkZXByZWNhdGVkRWRpdGluZ09mZnNldCgpIGNvbnN0CiAgICAgeworICAgICAgICBB U1NFUlQobV9pc0xlZ2FjeUVkaXRpbmdQb3NpdGlvbik7CiAgICAgICAgIHJldHVybiBtX29mZnNl dDsKICAgICB9CiAKQEAgLTkwLDE1ICsxMDUsMTAgQEAgcHVibGljOgogICAgIE5vZGUqIG5vZGUo KSBjb25zdCB7IHJldHVybiBtX2FuY2hvck5vZGUuZ2V0KCk7IH0KICAgICBFbGVtZW50KiBkb2N1 bWVudEVsZW1lbnQoKSBjb25zdDsKIAotICAgIHZvaWQgbW92ZVRvUG9zaXRpb24oUGFzc1JlZlB0 cjxOb2RlPiBub2RlLCBpbnQgb2Zmc2V0KQotICAgIHsKLSAgICAgICAgbV9hbmNob3JOb2RlID0g bm9kZTsKLSAgICAgICAgbV9vZmZzZXQgPSBvZmZzZXQ7Ci0gICAgfQotICAgIHZvaWQgbW92ZVRv T2Zmc2V0KGludCBvZmZzZXQpCi0gICAgewotICAgICAgICBtX29mZnNldCA9IG9mZnNldDsKLSAg ICB9CisgICAgLy8gVGhlc2Ugc2hvdWxkIG9ubHkgYmUgdXNlZCBmb3IgUG9zaXRpb25Jc09mZnNl dEluQW5jaG9yIHBvc2l0aW9ucywgdW5sZXNzCisgICAgLy8gdGhlIHBvc2l0aW9uIGlzIGEgbGVn YWN5IGVkaXRpbmcgcG9zaXRpb24uCisgICAgdm9pZCBtb3ZlVG9Qb3NpdGlvbihQYXNzUmVmUHRy PE5vZGU+IGFuY2hvck5vZGUsIGludCBvZmZzZXQpOworICAgIHZvaWQgbW92ZVRvT2Zmc2V0KGlu dCBvZmZzZXQpOwogCiAgICAgYm9vbCBpc051bGwoKSBjb25zdCB7IHJldHVybiAhbV9hbmNob3JO b2RlOyB9CiAgICAgYm9vbCBpc05vdE51bGwoKSBjb25zdCB7IHJldHVybiBtX2FuY2hvck5vZGU7 IH0KQEAgLTE1MywxOSArMTYzLDE1IEBAIHB1YmxpYzoKIHByaXZhdGU6CiAgICAgaW50IHJlbmRl cmVkT2Zmc2V0KCkgY29uc3Q7CiAKLSAgICBlbnVtIEFuY2hvclR5cGUgewotICAgICAgICBQb3Np dGlvbklzT2Zmc2V0SW5BbmNob3IsCi0gICAgICAgIFBvc2l0aW9uSXNBZnRlckFuY2hvciwKLSAg ICAgICAgUG9zaXRpb25Jc0JlZm9yZUFuY2hvcgotICAgIH07Ci0KLSAgICBBbmNob3JUeXBlIGFu Y2hvclR5cGUoKSBjb25zdDsKLQogICAgIFBvc2l0aW9uIHByZXZpb3VzQ2hhcmFjdGVyUG9zaXRp b24oRUFmZmluaXR5KSBjb25zdDsKICAgICBQb3NpdGlvbiBuZXh0Q2hhcmFjdGVyUG9zaXRpb24o RUFmZmluaXR5KSBjb25zdDsKIAorICAgIHN0YXRpYyBBbmNob3JUeXBlIGFuY2hvclR5cGVGb3JM ZWdhY3lFZGl0aW5nUG9zaXRpb24oTm9kZSogYW5jaG9yTm9kZSwgaW50IG9mZnNldCk7CisKICAg ICBSZWZQdHI8Tm9kZT4gbV9hbmNob3JOb2RlOwogICAgIGludCBtX29mZnNldDsKKyAgICBBbmNo b3JUeXBlIG1fYW5jaG9yVHlwZSA6IDI7CisgICAgYm9vbCBtX2lzTGVnYWN5RWRpdGluZ1Bvc2l0 aW9uIDogMTsKIH07CiAKIGlubGluZSBib29sIG9wZXJhdG9yPT0oY29uc3QgUG9zaXRpb24mIGEs IGNvbnN0IFBvc2l0aW9uJiBiKQo= 29276 2009-04-06 02:12:14 -0700 2010-06-10 17:19:27 -0700 Fix Position == operator to match our new fancy positions Fix-Position-operator-to-match-our-new-fancy-positions.patch text/plain 8105 eric OGY0NGFiNGExZjE2NWZkZmM3MGRiNDk5MGNhODI4NmEwYjNjNGE1ZApkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IGU0N2ExNGYu Ljg2NDljNGYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAwOS0wNC0wMiAgRXJpYyBTZWlkZWwg IDxlcmljQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISku CisKKyAgICAgICAgRml4IFBvc2l0aW9uID09IG9wZXJhdG9yIHRvIG1hdGNoIG91ciBuZXcgZmFu Y3kgcG9zaXRpb25zCisgICAgICAgIAorICAgICAgICBlZGl0aW5nL2V4ZWNDb21tYW5kLzE5MDg5 Lmh0bWwgaXMgY2xlYXJseSBhIHByb2dyZXNzaW9uLiAgV2UncmUganVzdCBub3cKKyAgICAgICAg Y29ycmVjdGx5IHJlcG9ydGluZyB0aGUgUmFuZ2Ugd2l0aCByYW5nZS1jb21wbGlhbnQgcG9zaXRp b25zLgorICAgICAgICAKKyAgICAgICAgZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LXBhcmFncmFw aC0wNC5odG1sIGxvb2tzIHRvIGJlIGEgcHJvZ3Jlc3Npb24uCisgICAgICAgIEkgc3VzcGVjdCB0 aGF0IHRoZSAid2hhdCBzdHlsZSBpcyBhdCB0aGlzIGVuZHBvaW50IiBjb2RlIGlzIHVzaW5nCisg ICAgICAgIFBvc2l0aW9uOjpjb250YWluZXJOb2RlKCkgd2hlbiBpdCBwb3NzaWJseSBtZWFudCB0 byB1c2UgUG9zaXRpb246OmFuY2hvck5vZGUoKQorICAgICAgICBPUiAobW9yZSBsaWtlbHkpIHRo YXQgdGhpcyB0ZXN0IHdhcyBkZXBlbmRpbmcgb24gdGhlIHByZXZpb3VzIGxhenktY2Fub25pY2Fs aXphdGlvbiBiZWhhdmlvciBvZiBwb3NpdGlvbnMuCisgICAgICAgIEVpdGhlciB3YXksIHRoZSBy ZXN1bHRzIGxvb2sgYmV0dGVyLiAgQ2FuJ3QgdGVzdCBpbiBGRiwgc2luY2UgRkYgZG9lcyBub3QK KyAgICAgICAgYmVoYXZlIGNvcnJlY3RseSB3aXRoIDxocj5zIGFuZCBibG9jayBmb3JtYXRpbmcg KGl0IGlnbm9yZXMgdGhlbSwgeW91IGNhbid0IHNlZW0gdG8gc2VsZWN0IHRoZW0gYXQgYWxsKS4K KworICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvMTkwODktZXhwZWN0ZWQudHh0OgorICAg ICAgICAqIHBsYXRmb3JtL21hYy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtcGFyYWdyYXBoLTA0 LWV4cGVjdGVkLmNoZWNrc3VtOgorICAgICAgICAqIHBsYXRmb3JtL21hYy9lZGl0aW5nL2luc2Vy dGluZy9pbnNlcnQtcGFyYWdyYXBoLTA0LWV4cGVjdGVkLnBuZzoKKyAgICAgICAgKiBwbGF0Zm9y bS9tYWMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LXBhcmFncmFwaC0wNC1leHBlY3RlZC50eHQ6 CisKIDIwMDktMDMtMzEgIEVyaWMgU2VpZGVsICA8ZXJpY0B3ZWJraXQub3JnPgogCiAgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRp dGluZy9leGVjQ29tbWFuZC8xOTA4OS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9lZGl0aW5n L2V4ZWNDb21tYW5kLzE5MDg5LWV4cGVjdGVkLnR4dAppbmRleCBmOTIxNWFlLi43M2Q4ZGEyIDEw MDY0NAotLS0gYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kLzE5MDg5LWV4cGVjdGVk LnR4dAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kLzE5MDg5LWV4cGVjdGVk LnR4dApAQCAtMSwyICsxLDIgQEAKIFRoaXMgdGVzdHMgdG8gbWFrZSBzdXJlIGFuIEFTU0VSVCBk b2Vzbid0IGZpcmUgd2hlbiBwZXJmb3JtaW5nIGEgRm9ybWF0QmxvY2sgb3BlcmF0aW9uIG9uIGEg c2VsZWN0aW9uIHRoYXQgZW5kcyBqdXN0IGFmdGVyIGEgaG9yaXpvbnRhbCBydWxlIHRoYXQgaXMg dGhlIGxhc3QgZWxlbWVudCBpbiB0aGUgZG9jdW1lbnQuIFRoZSB0ZXN0IHNob3VsZCBub3QgYXNz ZXJ0LgotPHByZT48c3BhbiBjbGFzcz0iQXBwbGUtc3R5bGUtc3BhbiIgc3R5bGU9ImZvbnQtZmFt aWx5OiBUaW1lczsgZm9udC1zaXplOiAxNnB4OyB3aGl0ZS1zcGFjZTogbm9ybWFsOyAiPjxocj48 L3NwYW4+PC9wcmU+Cis8cHJlPjxocj48L3ByZT4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtcGFyYWdyYXBoLTA0LWV4cGVjdGVk LmNoZWNrc3VtIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1wYXJhZ3JhcGgtMDQtZXhwZWN0ZWQuY2hlY2tzdW0KaW5kZXggNDkyYTFhOS4uZjZjYjdm MSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvaW5zZXJ0aW5n L2luc2VydC1wYXJhZ3JhcGgtMDQtZXhwZWN0ZWQuY2hlY2tzdW0KKysrIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vbWFjL2VkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1wYXJhZ3JhcGgtMDQtZXhwZWN0 ZWQuY2hlY2tzdW0KQEAgLTEgKzEgQEAKLWY1MmVlZjI4OGVlYjA3NTE0ODU2Yzc0YTcwNWRhOGY0 ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQorY2Q1NTI5OTQ3MTAyZGM0MGViYTM5Y2RiYTBj ODY5NzIKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0 cy9wbGF0Zm9ybS9tYWMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LXBhcmFncmFwaC0wNC1leHBl Y3RlZC5wbmcgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9tYWMvZWRpdGluZy9pbnNlcnRpbmcvaW5z ZXJ0LXBhcmFncmFwaC0wNC1leHBlY3RlZC5wbmcKaW5kZXggZjcyMDk1OC4uMTI2M2U1ZSAxMDA2 NDQKQmluYXJ5IGZpbGVzIGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvaW5zZXJ0 aW5nL2luc2VydC1wYXJhZ3JhcGgtMDQtZXhwZWN0ZWQucG5nIGFuZCBiL0xheW91dFRlc3RzL3Bs YXRmb3JtL21hYy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtcGFyYWdyYXBoLTA0LWV4cGVjdGVk LnBuZyBkaWZmZXIKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL21hYy9lZGl0aW5n L2luc2VydGluZy9pbnNlcnQtcGFyYWdyYXBoLTA0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3Rz L3BsYXRmb3JtL21hYy9lZGl0aW5nL2luc2VydGluZy9pbnNlcnQtcGFyYWdyYXBoLTA0LWV4cGVj dGVkLnR4dAppbmRleCA1OTRhYjkwLi4yZmZmNGJhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9w bGF0Zm9ybS9tYWMvZWRpdGluZy9pbnNlcnRpbmcvaW5zZXJ0LXBhcmFncmFwaC0wNC1leHBlY3Rl ZC50eHQKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vbWFjL2VkaXRpbmcvaW5zZXJ0aW5nL2lu c2VydC1wYXJhZ3JhcGgtMDQtZXhwZWN0ZWQudHh0CkBAIC00LDcgKzQsNiBAQCBFRElUSU5HIERF TEVHQVRFOiB3ZWJWaWV3RGlkQ2hhbmdlU2VsZWN0aW9uOldlYlZpZXdEaWRDaGFuZ2VTZWxlY3Rp b25Ob3RpZmljYXRpbwogRURJVElORyBERUxFR0FURTogd2ViVmlld0RpZENoYW5nZVNlbGVjdGlv bjpXZWJWaWV3RGlkQ2hhbmdlU2VsZWN0aW9uTm90aWZpY2F0aW9uCiBFRElUSU5HIERFTEVHQVRF OiB3ZWJWaWV3RGlkQ2hhbmdlU2VsZWN0aW9uOldlYlZpZXdEaWRDaGFuZ2VTZWxlY3Rpb25Ob3Rp ZmljYXRpb24KIEVESVRJTkcgREVMRUdBVEU6IHdlYlZpZXdEaWRDaGFuZ2VTZWxlY3Rpb246V2Vi Vmlld0RpZENoYW5nZVNlbGVjdGlvbk5vdGlmaWNhdGlvbgotRURJVElORyBERUxFR0FURTogc2hv dWxkQ2hhbmdlU2VsZWN0ZWRET01SYW5nZTpyYW5nZSBmcm9tIDIgb2YgRElWID4gQiA+IEJPRFkg PiBIVE1MID4gI2RvY3VtZW50IHRvIDIgb2YgRElWID4gQiA+IEJPRFkgPiBIVE1MID4gI2RvY3Vt ZW50IHRvRE9NUmFuZ2U6cmFuZ2UgZnJvbSAyIG9mIERJViA+IEIgPiBCT0RZID4gSFRNTCA+ICNk b2N1bWVudCB0byAyIG9mIERJViA+IEIgPiBCT0RZID4gSFRNTCA+ICNkb2N1bWVudCBhZmZpbml0 eTpOU1NlbGVjdGlvbkFmZmluaXR5RG93bnN0cmVhbSBzdGlsbFNlbGVjdGluZzpGQUxTRQogRURJ VElORyBERUxFR0FURTogd2ViVmlld0RpZENoYW5nZVNlbGVjdGlvbjpXZWJWaWV3RGlkQ2hhbmdl U2VsZWN0aW9uTm90aWZpY2F0aW9uCiBFRElUSU5HIERFTEVHQVRFOiB3ZWJWaWV3RGlkQ2hhbmdl OldlYlZpZXdEaWRDaGFuZ2VOb3RpZmljYXRpb24KIGxheWVyIGF0ICgwLDApIHNpemUgODAweDYw MApAQCAtMzcsNCArMzYsNCBAQCBsYXllciBhdCAoMCwwKSBzaXplIDgwMHg2MDAKICAgICAgICAg ICAgICAgdGV4dCBydW4gYXQgKDAsMTgpIHdpZHRoIDI0OiAiYmFyIgogICAgICAgUmVuZGVyQmxv Y2sgKGFub255bW91cykgYXQgKDAsMTQyKSBzaXplIDc4NHgwCiAgICAgICAgIFJlbmRlcklubGlu ZSB7Qn0gYXQgKDAsMCkgc2l6ZSAweDAKLWNhcmV0OiBwb3NpdGlvbiAwIG9mIGNoaWxkIDIge0JS fSBvZiBjaGlsZCAxIHtESVZ9IG9mIGNoaWxkIDEge0J9IG9mIGNoaWxkIDEge0JPRFl9IG9mIGNo aWxkIDAge0hUTUx9IG9mIGRvY3VtZW50CitjYXJldDogcG9zaXRpb24gMSBvZiBjaGlsZCAxIHtI Un0gb2YgY2hpbGQgMSB7RElWfSBvZiBjaGlsZCAxIHtCfSBvZiBjaGlsZCAxIHtCT0RZfSBvZiBj aGlsZCAwIHtIVE1MfSBvZiBkb2N1bWVudApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cg Yi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2OTc5NWI3Li5jZjAwN2NiIDEwMDY0NAotLS0gYS9X ZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMiw2ICsyLDI2IEBA CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCiAKKyAgICAgICAgV3JpdGUg YSBuZXcgbW9yZSBpbnR1aXRpdmUgUG9zaXRpb24gPT0gb3BlcmF0b3Igd2hpY2ggd29ya3MgY29y cmVjdGx5CisgICAgICAgIHdpdGggb3VyIG5ldyBCZWZvcmUvQWZ0ZXIgcG9zaXRpb24gc3VwcG9y dC4KKworICAgICAgICBJbiA8ZGl2PjxpbWc+PC9kaXY+LCBoaXN0b3JpY2FsbHkgW2RpdiwgMF0g IT0gW2ltZywgMF0gZXZlbiB0aG91Z2gKKyAgICAgICAgcmFuZ2VDb21wbGlhbnRQb3NpdGlvbiB3 b3VsZCB0cmVhdCBbaW1nLCAwXSBhcyBbaW1nLCBiZWZvcmVdIGFuZCBub3JtYWxpemUgdG8gW2Rp diwgMF0KKyAgICAgICAgVGh1cyBtb3N0IG9mIHRoZSBlZGl0aW5nIGNvZGUgdHJlYXRlZCBbaW1n LCAwXSBhbmQgW2RpdiwgMF0gYXMgZXF1YWwgZXZlbiB0aG91Z2ggPT0gZGlkIG5vdC4KKyAgICAg ICAgTm93IFtkaXYsIDBdID09IFtpbWcsIGJlZm9yZV0gYXMgeW91IHdvdWxkIGV4cGVjdC4KKyAg ICAgICAgCisgICAgICAgIFRlc3RzOgorICAgICAgICAtIGVkaXRpbmcvZXhlY0NvbW1hbmQvMTkw ODkuaHRtbAorICAgICAgICAtIGVkaXRpbmcvaW5zZXJ0aW5nL2luc2VydC1wYXJhZ3JhcGgtMDQu aHRtbAorICAgICAgICBjb3JyZWN0bHkgbm90aWNlZCBhIGJlaGF2aW9yIGNoYW5nZS4gIEJvdGgg YXBwZWFyIHRvIGJlIHByb2dyZXNzaW9ucy4KKworICAgICAgICAqIGRvbS9Qb3NpdGlvbi5oOgor ICAgICAgICAoV2ViQ29yZTo6b3BlcmF0b3I9PSk6CisKKzIwMDktMDQtMDIgIEVyaWMgU2VpZGVs ICA8ZXJpY0B3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCiAgICAgICAgIENoYW5nZSBQb3NpdGlvbiB0byBwcmUtY29tcHV0ZSB0aGUgQW5jaG9yVHlw ZSBhbmQgc3RvcmUgaXQuCiAgICAgICAgIEFsc28gc3RvcmUgYSAibGVnYWN5IGVkaXRpbmcgbW9k ZSIgYml0IG9uIHRoZSBQb3NpdGlvbi4KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9kb20vUG9zaXRp b24uaCBiL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmgKaW5kZXggNDdkM2ZiNy4uYzI5MzFmZiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9kb20vUG9zaXRpb24uaAorKysgYi9XZWJDb3JlL2RvbS9Qb3NpdGlv bi5oCkBAIC0xNzYsOSArMTc2LDM2IEBAIHByaXZhdGU6CiAKIGlubGluZSBib29sIG9wZXJhdG9y PT0oY29uc3QgUG9zaXRpb24mIGEsIGNvbnN0IFBvc2l0aW9uJiBiKQogewotICAgIC8vIEZJWE1F OiBJbiA8ZGl2PjxpbWc+PC9kaXY+IFtkaXYsIDBdICE9IFtpbWcsIDBdIGV2ZW4gdGhvdWdoIG1v c3Qgb2YgdGhlCi0gICAgLy8gZWRpdGluZyBjb2RlIHdpbGwgdHJlYXQgdGhlbSBhcyBpZGVudGlj YWwuCi0gICAgcmV0dXJuIGEuYW5jaG9yTm9kZSgpID09IGIuYW5jaG9yTm9kZSgpICYmIGEuZGVw cmVjYXRlZEVkaXRpbmdPZmZzZXQoKSA9PSBiLmRlcHJlY2F0ZWRFZGl0aW5nT2Zmc2V0KCk7Cisg ICAgLy8gTm90ZTogdGhlIHNpbXBsZSBlcXVhbHMgY2hlY2sgd291bGQgYmU6CisgICAgLy8gcmV0 dXJuIGEuY29udGFpbmVyTm9kZSgpID09IGIuY29udGFpbmVyTm9kZSgpICYmIGEubm9kZUJlZm9y ZVBvc2l0aW9uKCkgPT0gYi5ub2RlQmVmb3JlUG9zaXRpb24oKSAmJiBhLm5vZGVBZnRlclBvc2l0 aW9uKCkgPT0gYi5ub2RlQWZ0ZXJQb3NpdGlvbigpOworICAgIC8vIEJ1dCBub2RlQmVmb3JlUG9z aXRpb24vbm9kZUFmdGVyUG9zaXRpb24gYXJlIE8obikgZm9yIHBhcmVudC1hbmNob3JlZCBub2Rl cworICAgIC8vIEJlbG93IGlzIGEgbW9yZSB2ZXJib3NlIChhbmQgaG9wZWZ1bGx5IGZhc3RlciBp biB0aGUgY29tbW9uIGNhc2UpIGNvbXBhcmlzaW9uIG9wZXJhdG9yOgorCisgICAgaWYgKGEuY29u dGFpbmVyTm9kZSgpICE9IGIuY29udGFpbmVyTm9kZSgpKSAvLyBPKDEpCisgICAgICAgIHJldHVy biBmYWxzZTsKKworICAgIGlmIChhLmFuY2hvclR5cGUoKSA9PSBiLmFuY2hvclR5cGUoKSkgeyAv LyBPKDEpCisgICAgICAgIC8vIElmIHRoZSB0eXBlcyBtYXRjaCwgdHdvIHBvc2l0aW9ucyBjYW4g b25seSBiZSBlcXVhbCBpZiB0aGVpciBhbmNob3Igbm9kZXMgYXJlIHRoZSBzYW1lLgorICAgICAg ICBpZiAoYS5hbmNob3JOb2RlKCkgIT0gYi5hbmNob3JOb2RlKCkpCisgICAgICAgICAgICByZXR1 cm4gZmFsc2U7CisKKyAgICAgICAgLy8gQmVmb3JlL0FmdGVyIHBvc2l0aW9ucyB3aXRoIHRoZSBz YW1lIGFuY2hvciwgYXJlIHRoZSBzYW1lLCBidXQgbGVnYWN5IHBvc2l0aW9ucworICAgICAgICAv LyBtYXkgaGF2ZSBub24tMCBvZmZzZXRzIGZvciBiZWZvcmUvYWZ0ZXIgYW5jaG9ycywgc28gZXhw bGljaXRseSBpZ25vcmUgdGhlIG9mZnNldAorICAgICAgICAvLyBpbnN0ZWFkIG9mIGZhbGxpbmcg dGhyb3VnaCB0byB0aGUgb2Zmc2V0IGNvbXBhcmlzaW9uLgorICAgICAgICBpZiAoYS5hbmNob3JU eXBlKCkgIT0gUG9zaXRpb246OlBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvcikKKyAgICAgICAgICAg IHJldHVybiB0cnVlOworICAgICAgICAvLyBPdGhlcndpc2UsIHRoZXNlIGFyZSBib3RoIHBhcmVu dC1vZmZzZXQgcG9zaXRpb25zLCBzbyBtYWtlIHN1cmUgdGhlIG9mZnNldHMgbWF0Y2g6CisgICAg ICAgIHJldHVybiBhLm9mZnNldEluQ29udGFpbmVyTm9kZSgpID09IGIub2Zmc2V0SW5Db250YWlu ZXJOb2RlKCk7CisgICAgfQorCisgICAgLy8gTm8gbmVlZCB0byBjaGVjayBub2RlQWZ0ZXJQb3Np dGlvbigpIGVxdWFsaXR5LgorICAgIC8vIGEuIElmIHRoZXNlIGFyZSBib3RoIG5vbi1udWxsIHRo ZSBiZWxvdyBjaGVjayBpcyBvYnZpb3VzbHkgc3VmZmljaWVudC4KKyAgICAvLyBiLiBub2RlQmVm b3JlUG9zaXRpb24gaXMgb25seSBudWxsIGluIDIgY2FzZXM6CisgICAgLy8gIDEuIEZpcnN0IHBv c2l0aW9uIGluIGEgbm9kZSBmb3IgYW55IGFuY2hvciB0eXBlICh0aGF0J3MgT0ssIHRoaXMgd2ls bCBjb3JyZWN0bHkgcmV0dXJuIGVxdWFsKQorICAgIC8vICAyLiBQb3NpdGlvbiBpcyBhbiBvZmZz ZXQgaW4gYSB0ZXh0IG5vZGUuIChhbmNob3JUeXBlcyBhcmUga25vd24KKyAgICAvLyAgICAgdG8g YmUgZGlmZmVyZW50LCBhbmQgdGhlIGNvbnRhaW5lck5vZGVzIHRoZSBzYW1lLCBzbyBuZWl0aGVy IGNhbiBiZSBhbiBvZmZzZXQKKyAgICAvLyAgICAgaW4gYSB0ZXh0IG5vZGUuICBjb250YWluZXJO b2RlKCkgPT0gdGV4dCBpZiBhbmQgb25seSBpZiBhbmNob3JUeXBlKCkgPT0gT2Zmc2V0KQorICAg IHJldHVybiBhLm5vZGVCZWZvcmVQb3NpdGlvbigpID09IGIubm9kZUJlZm9yZVBvc2l0aW9uKCk7 CiB9CiAKIGlubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgUG9zaXRpb24mIGEsIGNvbnN0IFBv c2l0aW9uJiBiKQo=