225072 2021-04-26 13:29:36 -0700 [iOS] Web content process occasionally crashes under VisibleSelection::adjustPositionForEnd 2021-04-28 17:25:43 -0700 1 1 1 Unclassified WebKit HTML Editing WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 wenson_hsieh wenson_hsieh bdakin cdumez darin esprehn+autocc ews-watchlist hi kangil.han megan_gardner rniwa thorton webkit-bug-importer wenson_hsieh oldest_to_newest 1754341 0 wenson_hsieh 2021-04-26 13:29:36 -0700 rdar://77159489 1754407 1 427097 wenson_hsieh 2021-04-26 15:32:25 -0700 Created attachment 427097 Patch 1754743 2 thorton 2021-04-27 12:38:51 -0700 Please also get review from rniwa or darin :) 1754830 3 427097 darin 2021-04-27 16:15:45 -0700 Comment on attachment 427097 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=427097&action=review > Source/WebCore/dom/Position.h:126 > - TreeScope* treeScope() const { return m_anchorNode ? &m_anchorNode->treeScope() : nullptr; } > + TreeScope* treeScope() const > + { > + if (!m_anchorNode || !m_anchorNode->isInTreeScope()) > + return nullptr; > + > + return &m_anchorNode->treeScope(); > + } I don’t think this change should be made. Position::document returns the document a position’s node is associated with. It doesn’t return nullptr if the node happens to not be in the document at the time. The same behavior would make sense for Position::treeScope. Callers can check isInTreeScope if they have reason to; having this return nullptr does not seem right. > Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm:1527 > - else if (targetNode && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) > + else if (auto treeScope = selectionStart.deepEquivalent().treeScope(); treeScope && targetNode && targetNode->isInTreeScope() && treeScope != &targetNode->treeScope()) I suggest we add an isInTreeScope for Position and use it here rather than changing the behavior of Position::treeScope. We could also consider writing a "both in same tree scope" function to make the logic easier to read. 1754832 4 wenson_hsieh 2021-04-27 16:19:07 -0700 (In reply to Darin Adler from comment #3) > Comment on attachment 427097 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=427097&action=review > > > Source/WebCore/dom/Position.h:126 > > - TreeScope* treeScope() const { return m_anchorNode ? &m_anchorNode->treeScope() : nullptr; } > > + TreeScope* treeScope() const > > + { > > + if (!m_anchorNode || !m_anchorNode->isInTreeScope()) > > + return nullptr; > > + > > + return &m_anchorNode->treeScope(); > > + } > > I don’t think this change should be made. Position::document returns the > document a position’s node is associated with. It doesn’t return nullptr if > the node happens to not be in the document at the time. The same behavior > would make sense for Position::treeScope. > > Callers can check isInTreeScope if they have reason to; having this return > nullptr does not seem right. > > > Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm:1527 > > - else if (targetNode && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) > > + else if (auto treeScope = selectionStart.deepEquivalent().treeScope(); treeScope && targetNode && targetNode->isInTreeScope() && treeScope != &targetNode->treeScope()) > > I suggest we add an isInTreeScope for Position and use it here rather than > changing the behavior of Position::treeScope. > > We could also consider writing a "both in same tree scope" function to make > the logic easier to read. Sounds good! I think I'll add a helper on Position that's something like: bool isInSameTreeScope(Node&); 1754853 5 wenson_hsieh 2021-04-27 16:59:14 -0700 (In reply to Wenson Hsieh from comment #4) > (In reply to Darin Adler from comment #3) > > Comment on attachment 427097 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=427097&action=review > > > > > Source/WebCore/dom/Position.h:126 > > > - TreeScope* treeScope() const { return m_anchorNode ? &m_anchorNode->treeScope() : nullptr; } > > > + TreeScope* treeScope() const > > > + { > > > + if (!m_anchorNode || !m_anchorNode->isInTreeScope()) > > > + return nullptr; > > > + > > > + return &m_anchorNode->treeScope(); > > > + } > > > > I don’t think this change should be made. Position::document returns the > > document a position’s node is associated with. It doesn’t return nullptr if > > the node happens to not be in the document at the time. The same behavior > > would make sense for Position::treeScope. > > > > Callers can check isInTreeScope if they have reason to; having this return > > nullptr does not seem right. > > > > > Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm:1527 > > > - else if (targetNode && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) > > > + else if (auto treeScope = selectionStart.deepEquivalent().treeScope(); treeScope && targetNode && targetNode->isInTreeScope() && treeScope != &targetNode->treeScope()) > > > > I suggest we add an isInTreeScope for Position and use it here rather than > > changing the behavior of Position::treeScope. > > > > We could also consider writing a "both in same tree scope" function to make > > the logic easier to read. > > Sounds good! I think I'll add a helper on Position that's something like: > > bool isInSameTreeScope(Node&); ..on second thought, this'll need to be `bool isInDifferentTreeScope(Node&) const` since the call site cares about whether the position and Node both exist in different tree scopes. 1754855 6 rniwa 2021-04-27 17:03:09 -0700 (In reply to Wenson Hsieh from comment #5) > (In reply to Wenson Hsieh from comment #4) > > Sounds good! I think I'll add a helper on Position that's something like: > > > > bool isInSameTreeScope(Node&); > > ..on second thought, this'll need to be `bool isInDifferentTreeScope(Node&) > const` since the call site cares about whether the position and Node both > exist in different tree scopes. But doesn't isInSameTreeScope returning false would mean that they're in different tree scopes?? 1754857 7 wenson_hsieh 2021-04-27 17:04:25 -0700 (In reply to Ryosuke Niwa from comment #6) > (In reply to Wenson Hsieh from comment #5) > > (In reply to Wenson Hsieh from comment #4) > > > Sounds good! I think I'll add a helper on Position that's something like: > > > > > > bool isInSameTreeScope(Node&); > > > > ..on second thought, this'll need to be `bool isInDifferentTreeScope(Node&) > > const` since the call site cares about whether the position and Node both > > exist in different tree scopes. > > But doesn't isInSameTreeScope returning false would mean that they're in > different tree scopes?? So that would change behavior in the case where either the node or position is not in a tree scope, but I suppose I could roll the isInTreeScope check into the call site... 1754869 8 427222 wenson_hsieh 2021-04-27 17:56:03 -0700 Created attachment 427222 Patch 1754870 9 wenson_hsieh 2021-04-27 17:58:29 -0700 (In reply to Wenson Hsieh from comment #8) > Created attachment 427222 [details] > Patch (I ended up just adding `Position::isInTreeScope()`, since it's kind of ambiguous how `isInSameTreeScope()` (and `isInDifferentTreeScope()`) should behave in the case where either is not in a TreeScope) 1754872 10 427222 darin 2021-04-27 18:00:10 -0700 Comment on attachment 427222 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=427222&action=review > Source/WebCore/dom/Position.h:127 > + bool isInTreeScope() const { return m_anchorNode && m_anchorNode->isInTreeScope(); } Note that this is just a convenience. Clients could call anchorNode() and do this. I’m OK with having this convenience function, though. 1754888 11 427222 wenson_hsieh 2021-04-27 19:41:20 -0700 Comment on attachment 427222 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=427222&action=review >> Source/WebCore/dom/Position.h:127 >> + bool isInTreeScope() const { return m_anchorNode && m_anchorNode->isInTreeScope(); } > > Note that this is just a convenience. Clients could call anchorNode() and do this. I’m OK with having this convenience function, though. Thanks for the review! While purely for convenience, I do think it fits in well with the extant helper functions such as `treeScope()` and `document()`. 1754891 12 ews-feeder 2021-04-27 19:54:48 -0700 Committed r276688 (237102@main): <https://commits.webkit.org/237102@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 427222. 1754933 13 427222 rniwa 2021-04-27 23:49:39 -0700 Comment on attachment 427222 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=427222&action=review > Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm:1527 > - else if (targetNode && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) > + else if (targetNode && targetNode->isInTreeScope() && selectionStart.deepEquivalent().isInTreeScope() && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) I don't think this is quite right for when targetNode and selectionStart belong to two different documents but one of them is disconnected from the document. 1755035 14 427222 wenson_hsieh 2021-04-28 08:42:31 -0700 Comment on attachment 427222 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=427222&action=review >> Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm:1527 >> + else if (targetNode && targetNode->isInTreeScope() && selectionStart.deepEquivalent().isInTreeScope() && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) > > I don't think this is quite right for when targetNode and selectionStart belong to two different documents but one of them is disconnected from the document. Is that because you would expect us to enter this `else if` statement in that scenario? If so, then as `adjustPositionForEnd` and `adjustPositionForStart` currently are, I think that would trigger a crash when trying to access `startContainerNode->treeScope()` or `currentPosition.containerNode()->treeScope()`... Or are you suggesting we should add some kind of check like this at the end of the function? ``` range = makeSimpleRange(result, selectionEnd); } + if (!range || !range->startContainer().isConnected() || !range->endContainer().isConnected()) + return WTF::nullopt; + return range; } ``` 1755101 15 rniwa 2021-04-28 11:53:06 -0700 (In reply to Wenson Hsieh from comment #14) > Comment on attachment 427222 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=427222&action=review > > >> Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm:1527 > >> + else if (targetNode && targetNode->isInTreeScope() && selectionStart.deepEquivalent().isInTreeScope() && selectionStart.deepEquivalent().treeScope() != &targetNode->treeScope()) > > > > I don't think this is quite right for when targetNode and selectionStart belong to two different documents but one of them is disconnected from the document. > > Is that because you would expect us to enter this `else if` statement in > that scenario? Yes. > If so, then as `adjustPositionForEnd` and > `adjustPositionForStart` currently are, I think that would trigger a crash > when trying to access `startContainerNode->treeScope()` or > `currentPosition.containerNode()->treeScope()`... Why? treeScope() of a Node is never null. In the case a Node is disconnected from the document, it is Document. 1755104 16 rniwa 2021-04-28 11:53:43 -0700 As confusing as it is, !node.isInTreeScope() doesn't mean node.treeScope() is null. This is why it returns a reference instead of a pointer. 1755116 17 darin 2021-04-28 12:14:47 -0700 The abstraction "tree scope" makes this more confusing than it should be. If you put the word "document" in, then it makes more sense if you are familiar with DOM history: Nodes are associated with a document. But at any given time, they might be in the document’s tree, or might not be. Being in the document’s tree is referred to as being "connected" and can be checked with Node::isConnected efficiently without following parent pointers up to the root to see if it’s the document. When we abstracted document to "tree scope", we kept those same concepts, but with different names. The node is always associated with a "tree scope". But at any given time it might be in the tree scope’s tree, or might not be. Being in the tree scope’s tree is referred to as being "in the tree scope" and can be checked with isInTreeScope efficiently without following parent pointers up to the root to see if it’s the shadow tree root or the document. 1755118 18 rniwa 2021-04-28 12:23:13 -0700 (In reply to Darin Adler from comment #17) > The abstraction "tree scope" makes this more confusing than it should be. If > you put the word "document" in, then it makes more sense if you are familiar > with DOM history: Yes. > When we abstracted document to "tree scope", we kept those same concepts, > but with different names. The node is always associated with a "tree scope". > But at any given time it might be in the tree scope’s tree, or might not be. > Being in the tree scope’s tree is referred to as being "in the tree scope" > and can be checked with isInTreeScope efficiently without following parent > pointers up to the root to see if it’s the shadow tree root or the document. I think we need to change "in the tree scope" to something like isInDocumentOrShadowTree. Separately, we probably want to rename TreeScope. It's not really a scope. It's really about the root node. Maybe DocumentOrShadowRootBase? 1755119 19 wenson_hsieh 2021-04-28 12:24:12 -0700 Okay — I understand now. Thanks for the explanation! It sounds like instead of checking for whether or not we are in a tree scope (i.e. connected), we should just be null checking the `containerNode` before passing it into `adjustPositionForEnd` and `adjustPositionForStart`. Or alternately, if the `containerNode` is null, just bail with nullopt.. Is that accurate? 1755123 20 rniwa 2021-04-28 12:29:25 -0700 (In reply to Wenson Hsieh from comment #19) > Okay — I understand now. Thanks for the explanation! > > It sounds like instead of checking for whether or not we are in a tree scope > (i.e. connected), we should just be null checking the `containerNode` before > passing it into `adjustPositionForEnd` and `adjustPositionForStart`. Or > alternately, if the `containerNode` is null, just bail with nullopt.. That is containerNode being nullptr anything to do with this bug?? 1755139 21 wenson_hsieh 2021-04-28 13:21:06 -0700 (In reply to Ryosuke Niwa from comment #20) > (In reply to Wenson Hsieh from comment #19) > > Okay — I understand now. Thanks for the explanation! > > > > It sounds like instead of checking for whether or not we are in a tree scope > > (i.e. connected), we should just be null checking the `containerNode` before > > passing it into `adjustPositionForEnd` and `adjustPositionForStart`. Or > > alternately, if the `containerNode` is null, just bail with nullopt.. > > That is containerNode being nullptr anything to do with this bug?? Ryosuke and I discussed this over Slack; in summary, the crash is really due to the fact that we pass in a null container node into either `adjustPositionForEnd` or `adjustPositionForStart`, which we immediately proceed to dereference. We should be checking the nullity of the container beforehand instead. 1755140 22 wenson_hsieh 2021-04-28 13:22:21 -0700 Reopening to attach new patch. 1755141 23 427290 wenson_hsieh 2021-04-28 13:22:23 -0700 Created attachment 427290 Patch 1755143 24 darin 2021-04-28 13:28:35 -0700 (Not wanting to distract from this bug, these comments are focusing on the name TreeScope and related naming confusion.) If it was up to me I would suggest that isConnected be renamed to isInDocumentTree and isOrphaned be renamed to !isInDocumentTree. We would still have that "is connected" name if it’s used in web-exposed API, and maybe we need the "is orphaned" name for some reason (not really sure about that). On the other hand, I really like it when our code uses the same terminology that the web standards documents do. So that’s a consideration too, if some of these terms are used there. Seems that TreeScope should be named DocumentOrShadowRoot. No need to have the word "base" in there. But not sure how to name all the different predicates. 1755151 25 rniwa 2021-04-28 13:49:28 -0700 (In reply to Darin Adler from comment #24) > (Not wanting to distract from this bug, these comments are focusing on the > name TreeScope and related naming confusion.) If it was up to me I would > suggest that isConnected be renamed to isInDocumentTree isInDocumentTree has a specific meaning in the DOM spec which is that it's a Document tree without consideration to any consideration to shadow roots / shadow trees. https://dom.spec.whatwg.org/#concept-document-tree isConnected means it's either in a Document tree (i.e. without consideration to any of shadow trees), or in a ShadowRoot tree which is also connected: https://dom.spec.whatwg.org/#connected What you're suggesting doesn't agree with these definitions > and isOrphaned be renamed to !isInDocumentTree. We would still have that "is connected" name > if it’s used in web-exposed API, and maybe we need the "is orphaned" name > for some reason (not really sure about that). Orphaned is really a term we used to have some version of DOM spec, which is !isConnected() so we should probably match the terminology here and use isDisconnected() or something. 1755154 26 darin 2021-04-28 13:50:17 -0700 (In reply to Wenson Hsieh from comment #21) > We should be checking the nullity of the container beforehand instead. Fits with one of my rules of thumb. I suggest always thinking about crashes "mechanically" first. If it’s a null dereference, consider adding the check for null. Then think through whether that’s right or not, but start there. 1755158 27 darin 2021-04-28 13:58:55 -0700 I’m happy to use those terms from web specifications, if they are carefully chosen. That can sometimes make our code clearer. When the terms are super-strange they can make our code hard to understand. I’m having a hard time figuring that out one way or another about the shadow tree related ones. Can definitely say that "is in tree" better always mean mean "if you walk up to the root, you'd get to the root of the tree". But sadly there is more than one kind of parent pointer and more than one kind of "walk up" in the shadow-haunted DOM. 1755160 28 rniwa 2021-04-28 14:05:04 -0700 (In reply to Darin Adler from comment #27) > I’m happy to use those terms from web specifications, if they are carefully > chosen. That can sometimes make our code clearer. When the terms are > super-strange they can make our code hard to understand. I’m having a hard > time figuring that out one way or another about the shadow tree related > ones. Can definitely say that "is in tree" better always mean mean "if you > walk up to the root, you'd get to the root of the tree". But sadly there is > more than one kind of parent pointer and more than one kind of "walk up" in > the shadow-haunted DOM. DOM spec almost never crosses shadow boundaries. When they need to do, they explicitly say "shadow-including" e.g. shadow-including inclusive-ancestor. 1755253 29 ews-feeder 2021-04-28 17:25:40 -0700 Committed r276742 (237142@main): <https://commits.webkit.org/237142@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 427290. 427097 2021-04-26 15:32:25 -0700 2021-04-27 16:19:16 -0700 Patch bug-225072-20210426153224.patch text/plain 8387 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2NjAyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjVmOGIwOWZhMTdjM2Fl YzhhYTE2NWRkZDNkZWJlMGQ5NTI0MTQ2Yy4uNzc4YWZlMTBlNjJiMjlkNTZjODlkNTU0MTY0OTU1 ZWNlMTA2YjY1NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDIxLTA0LTI2ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFdlYiBj b250ZW50IHByb2Nlc3Mgb2NjYXNpb25hbGx5IGNyYXNoZXMgdW5kZXIgVmlzaWJsZVNlbGVjdGlv bjo6YWRqdXN0UG9zaXRpb25Gb3JFbmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyNTA3MgorICAgICAgICByZGFyOi8vNzcxNTk0ODkKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBNYWtlIGl0IHNhZmUgdG8g Y2FsbCBgUG9zaXRpb246OnRyZWVTY29wZSgpYCB3aXRoIGFuIG9ycGhhbmVkIHBvc2l0aW9uIChp LmUuLCB3aG9zZSBhbmNob3Igbm9kZSBpcyBub3QgaW5zaWRlIGEKKyAgICAgICAgdHJlZSBzY29w ZSkuIFNlZSBXZWJLaXQvQ2hhbmdlTG9nIGZvciBtb3JlIGRldGFpbHMuCisKKyAgICAgICAgVGVz dDogZWRpdGluZy9zZWxlY3Rpb24vaW9zL2NsZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmctc2Vs ZWN0aW9uLWhhbmRsZXMuaHRtbAorCisgICAgICAgICogZG9tL1Bvc2l0aW9uLmg6CisgICAgICAg IChXZWJDb3JlOjpQb3NpdGlvbjo6dHJlZVNjb3BlIGNvbnN0KToKKwogMjAyMS0wNC0yNiAgQWxl eGV5IFNodmF5a2EgIDxzaHZhaWthbGVzaEBnbWFpbC5jb20+CiAKICAgICAgICAgW1dlYklETF0g UmVtb3ZlIFtDYWxsTmFtZWRTZXR0ZXJPbmx5Rm9yU3VwcG9ydGVkUHJvcGVydGllc10gZXh0ZW5k ZWQgYXR0cmlidXRlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDkxZWQ5Y2Y1NGMzZWMyY2ExMTVhN2FlODExYWJmN2Yx OGY4YmYyNTQuLmNlZWY4YmI4OWRhYWY5MWRkNjAwYjRjOGUyYjNmMTI0MzhjMjU2MWQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdl TG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMjEtMDQtMjYgIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9o c2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgW2lPU10gV2ViIGNvbnRlbnQgcHJvY2VzcyBvY2Nh c2lvbmFsbHkgY3Jhc2hlcyB1bmRlciBWaXNpYmxlU2VsZWN0aW9uOjphZGp1c3RQb3NpdGlvbkZv ckVuZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI1 MDcyCisgICAgICAgIHJkYXI6Ly83NzE1OTQ4OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIE1ha2UgYHJhbmdlRm9yUG9pbnRJblJvb3RWaWV3Q29vcmRp bmF0ZXNgIHJvYnVzdCBpbiB0aGUgY2FzZSB3aGVyZSB0aGUgb3JpZ2luYWwgc2VsZWN0aW9uIG1h eSBoYXZlIGJlY29tZQorICAgICAgICBvcnBoYW5lZCBvciBudWxsLCBieSBjaGVja2luZyB0aGF0 IHRoZSBgdGFyZ2V0Tm9kZWAgYW5kIGV4aXN0aW5nIGBzZWxlY3Rpb25TdGFydGAgb3IgYHNlbGVj dGlvbkVuZGAgYXJlIGluIGEKKyAgICAgICAgdHJlZSBzY29wZSBiZWZvcmUgYWNjZXNzaW5nIGB0 cmVlU2NvcGUoKWAuCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJ T1MubW06CisgICAgICAgIChXZWJLaXQ6OnJhbmdlRm9yUG9pbnRJblJvb3RWaWV3Q29vcmRpbmF0 ZXMpOgorCiAyMDIxLTA0LTI2ICBBZGl0eWEgS2VlcnRoaSAgPGFrZWVydGhpQGFwcGxlLmNvbT4K IAogICAgICAgICBSRUdSRVNTSU9OIChyMjcxODYxKTogW2lPU10gQWNjZXNzb3J5IGJhciBuYXZp Z2F0aW9uIHRvIGVsZW1lbnRzIG91dHNpZGUgdGhlIHZpZXdwb3J0IGZhaWxzCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9kb20vUG9zaXRpb24uaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Qb3Np dGlvbi5oCmluZGV4IGM3NDkwOWRmOGVjZGRhYzI3OGI2N2ZhNzU3MWVlYzE5NWYxYmI4NTguLjk4 YWQ3MGMyZTUxODk5YjYyZWU4MmI2NzU0MjM3Y2IzYzEyZTY3NTggMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Qb3NpdGlv bi5oCkBAIC0xMTcsNyArMTE3LDE0IEBAIHB1YmxpYzoKICAgICBOb2RlKiBkZXByZWNhdGVkTm9k ZSgpIGNvbnN0IHsgcmV0dXJuIG1fYW5jaG9yTm9kZS5nZXQoKTsgfQogCiAgICAgRG9jdW1lbnQq IGRvY3VtZW50KCkgY29uc3QgeyByZXR1cm4gbV9hbmNob3JOb2RlID8gJm1fYW5jaG9yTm9kZS0+ ZG9jdW1lbnQoKSA6IG51bGxwdHI7IH0KLSAgICBUcmVlU2NvcGUqIHRyZWVTY29wZSgpIGNvbnN0 IHsgcmV0dXJuIG1fYW5jaG9yTm9kZSA/ICZtX2FuY2hvck5vZGUtPnRyZWVTY29wZSgpIDogbnVs bHB0cjsgfQorICAgIFRyZWVTY29wZSogdHJlZVNjb3BlKCkgY29uc3QKKyAgICB7CisgICAgICAg IGlmICghbV9hbmNob3JOb2RlIHx8ICFtX2FuY2hvck5vZGUtPmlzSW5UcmVlU2NvcGUoKSkKKyAg ICAgICAgICAgIHJldHVybiBudWxscHRyOworCisgICAgICAgIHJldHVybiAmbV9hbmNob3JOb2Rl LT50cmVlU2NvcGUoKTsKKyAgICB9CisKICAgICBFbGVtZW50KiByb290RWRpdGFibGVFbGVtZW50 KCkgY29uc3QKICAgICB7CiAgICAgICAgIE5vZGUqIGNvbnRhaW5lciA9IGNvbnRhaW5lck5vZGUo KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL2lvcy9XZWJQ YWdlSU9TLm1tIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJ T1MubW0KaW5kZXggZTExZmVlNzYzNTNiNDMyZWE4ZjRkZTA0NTE0YjNiYTQzYTE3ZmE0Ny4uY2Fm NzRmZWIxYzU4NWIxNDY2NTY5MzY5N2NkMTdlYWUyZjVjYjAwNiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW0KKysrIGIvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW0KQEAgLTE1MjQsMTQg KzE1MjQsMTQgQEAgc3RhdGljIE9wdGlvbmFsPFNpbXBsZVJhbmdlPiByYW5nZUZvclBvaW50SW5S b290Vmlld0Nvb3JkaW5hdGVzKEZyYW1lJiBmcmFtZSwgY28KICAgICBpZiAoYmFzZUlzU3RhcnQp IHsKICAgICAgICAgaWYgKHJlc3VsdCA8PSBzZWxlY3Rpb25TdGFydCkKICAgICAgICAgICAgIHJl c3VsdCA9IHNlbGVjdGlvblN0YXJ0Lm5leHQoKTsKLSAgICAgICAgZWxzZSBpZiAodGFyZ2V0Tm9k ZSAmJiBzZWxlY3Rpb25TdGFydC5kZWVwRXF1aXZhbGVudCgpLnRyZWVTY29wZSgpICE9ICZ0YXJn ZXROb2RlLT50cmVlU2NvcGUoKSkKKyAgICAgICAgZWxzZSBpZiAoYXV0byB0cmVlU2NvcGUgPSBz ZWxlY3Rpb25TdGFydC5kZWVwRXF1aXZhbGVudCgpLnRyZWVTY29wZSgpOyB0cmVlU2NvcGUgJiYg dGFyZ2V0Tm9kZSAmJiB0YXJnZXROb2RlLT5pc0luVHJlZVNjb3BlKCkgJiYgdHJlZVNjb3BlICE9 ICZ0YXJnZXROb2RlLT50cmVlU2NvcGUoKSkKICAgICAgICAgICAgIHJlc3VsdCA9IFZpc2libGVT ZWxlY3Rpb246OmFkanVzdFBvc2l0aW9uRm9yRW5kKHJlc3VsdC5kZWVwRXF1aXZhbGVudCgpLCBz ZWxlY3Rpb25TdGFydC5kZWVwRXF1aXZhbGVudCgpLmNvbnRhaW5lck5vZGUoKSk7CiAKICAgICAg ICAgcmFuZ2UgPSBtYWtlU2ltcGxlUmFuZ2Uoc2VsZWN0aW9uU3RhcnQsIHJlc3VsdCk7CiAgICAg fSBlbHNlIHsKICAgICAgICAgaWYgKHNlbGVjdGlvbkVuZCA8PSByZXN1bHQpCiAgICAgICAgICAg ICByZXN1bHQgPSBzZWxlY3Rpb25FbmQucHJldmlvdXMoKTsKLSAgICAgICAgZWxzZSBpZiAodGFy Z2V0Tm9kZSAmJiBzZWxlY3Rpb25FbmQuZGVlcEVxdWl2YWxlbnQoKS50cmVlU2NvcGUoKSAhPSAm dGFyZ2V0Tm9kZS0+dHJlZVNjb3BlKCkpCisgICAgICAgIGVsc2UgaWYgKGF1dG8gdHJlZVNjb3Bl ID0gc2VsZWN0aW9uRW5kLmRlZXBFcXVpdmFsZW50KCkudHJlZVNjb3BlKCk7IHRyZWVTY29wZSAm JiB0YXJnZXROb2RlICYmIHRhcmdldE5vZGUtPmlzSW5UcmVlU2NvcGUoKSAmJiB0cmVlU2NvcGUg IT0gJnRhcmdldE5vZGUtPnRyZWVTY29wZSgpKQogICAgICAgICAgICAgcmVzdWx0ID0gVmlzaWJs ZVNlbGVjdGlvbjo6YWRqdXN0UG9zaXRpb25Gb3JTdGFydChyZXN1bHQuZGVlcEVxdWl2YWxlbnQo KSwgc2VsZWN0aW9uRW5kLmRlZXBFcXVpdmFsZW50KCkuY29udGFpbmVyTm9kZSgpKTsKIAogICAg ICAgICByYW5nZSA9IG1ha2VTaW1wbGVSYW5nZShyZXN1bHQsIHNlbGVjdGlvbkVuZCk7CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5k ZXggYTNmMTg4NGY0ODc1NWMwYmZmMWI3MGNmZWZiOGM4OWUzNzJlN2IwMy4uYmExYWI2OTM0ZjM3 OTE4YTgzYWMyYzdiOGZhOWM1M2I2MDkzODBlYyAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIx LTA0LTI2ICBXZW5zb24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAg IFtpT1NdIFdlYiBjb250ZW50IHByb2Nlc3Mgb2NjYXNpb25hbGx5IGNyYXNoZXMgdW5kZXIgVmlz aWJsZVNlbGVjdGlvbjo6YWRqdXN0UG9zaXRpb25Gb3JFbmQKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyNTA3MgorICAgICAgICByZGFyOi8vNzcxNTk0 ODkKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQg YSBsYXlvdXQgdGVzdCB0aGF0IHByb2dyYW1tYXRpY2FsbHkgY2xlYXJzIHRoZSBzZWxlY3Rpb24g aW4gdGhlIG1pZGRsZSBvZiBjaGFuZ2luZyBpdCBieSBtb3Zpbmcgc2VsZWN0aW9uCisgICAgICAg IGhhbmRsZXMuCisKKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9pb3MvY2xlYXItc2VsZWN0 aW9uLXdoaWxlLW1vdmluZy1zZWxlY3Rpb24taGFuZGxlcy1leHBlY3RlZC50eHQ6IEFkZGVkLgor ICAgICAgICAqIGVkaXRpbmcvc2VsZWN0aW9uL2lvcy9jbGVhci1zZWxlY3Rpb24td2hpbGUtbW92 aW5nLXNlbGVjdGlvbi1oYW5kbGVzLmh0bWw6IEFkZGVkLgorCiAyMDIxLTA0LTI2ICBDaHJpcyBH YW1icmVsbCAgPGNnYW1icmVsbEBhcHBsZS5jb20+CiAKICAgICAgICAgW0xheW91dFRlc3RzXSBD b252ZXJ0IGh0dHAvdGVzdHMvcmVzb3VyY2VzIGNvbnZlcnQgUEhQIHRvIFB5dGhvbgpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vaW9zL2NsZWFyLXNlbGVjdGlvbi13 aGlsZS1tb3Zpbmctc2VsZWN0aW9uLWhhbmRsZXMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZWRpdGluZy9zZWxlY3Rpb24vaW9zL2NsZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmctc2VsZWN0 aW9uLWhhbmRsZXMtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmYzZWM0MzEyMTU0ZDM2MDMwN2Qz M2IwOGU1ZWNlZjFmZmU0NGI3ZGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0 aW5nL3NlbGVjdGlvbi9pb3MvY2xlYXItc2VsZWN0aW9uLXdoaWxlLW1vdmluZy1zZWxlY3Rpb24t aGFuZGxlcy1leHBlY3RlZC50eHQKQEAgLTAsMCArMSw2IEBACitQQVNTIERpZCBub3QgY3Jhc2gK K1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorTG9yZW0g aXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNldGV0dXIgc2FkaXBzY2luZyBlbGl0ciwgc2VkIGRp YW0gbm9udW15ZWlybW9kdGVtcG9yIGludmlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEg YWxpcXV5YW0gZXJhdCwgc2VkIGRpYW0gdm9sdXB0dWEuCitUaGlzIHRlc3QgdmVyaWZpZXMgdGhh dCBwcm9ncmFtbWF0aWNhbGx5IGNsZWFyaW5nIHRoZSB0ZXh0IHNlbGVjdGlvbiB3aGlsZSBpbnRl cmFjdGluZyB3aXRoIHNlbGVjdGlvbiBoYW5kbGVzIGRvZXMgbm90IGNhdXNlIGEgY3Jhc2guCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NlbGVjdGlvbi9pb3MvY2xlYXItc2VsZWN0 aW9uLXdoaWxlLW1vdmluZy1zZWxlY3Rpb24taGFuZGxlcy5odG1sIGIvTGF5b3V0VGVzdHMvZWRp dGluZy9zZWxlY3Rpb24vaW9zL2NsZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmctc2VsZWN0aW9u LWhhbmRsZXMuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi43ODEyOTAxOTc5NjRkZTU5YzA2NjU4Mjg4MWZiYmQ1 MmVhNjEyNmQzCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rp b24vaW9zL2NsZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmctc2VsZWN0aW9uLWhhbmRsZXMuaHRt bApAQCAtMCwwICsxLDQ4IEBACis8IURPQ1RZUEUgaHRtbD4gPCEtLSB3ZWJraXQtdGVzdC1ydW5u ZXIgWyB1c2VGbGV4aWJsZVZpZXdwb3J0PXRydWUgXSAtLT4KKzxodG1sPgorPG1ldGEgbmFtZT0i dmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xIj4K KzxoZWFkPgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uL3Jlc291cmNlcy9qcy10ZXN0LmpzIj48L3Nj cmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi9yZXNvdXJjZXMvdWktaGVscGVyLmpzIj48L3Nj cmlwdD4KKzxzdHlsZT4KK2JvZHkgeworICAgIG1hcmdpbjogMDsKKyAgICBmb250LXNpemU6IDE4 cHg7Cit9Cis8L3N0eWxlPgorPHNjcmlwdD4KK2pzVGVzdElzQXN5bmMgPSB0cnVlOworCithZGRF dmVudExpc3RlbmVyKCJsb2FkIiwgYXN5bmMgKCkgPT4geworICAgIGxldCB0YXJnZXQgPSBkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgidGFyZ2V0Iik7CisgICAgYXdhaXQgVUlIZWxwZXIubG9uZ1By ZXNzRWxlbWVudCh0YXJnZXQpOworICAgIGF3YWl0IFVJSGVscGVyLndhaXRGb3JTZWxlY3Rpb25U b0FwcGVhcigpOworICAgIGxldCBncmFiYmVyUmVjdCA9IGF3YWl0IFVJSGVscGVyLmdldFNlbGVj dGlvbkVuZEdyYWJiZXJWaWV3UmVjdCgpOworICAgIGxldCBncmFiYmVyTG9jYXRpb25YID0gZ3Jh YmJlclJlY3QubGVmdCArIChncmFiYmVyUmVjdC53aWR0aCAvIDIpOworICAgIGxldCBncmFiYmVy TG9jYXRpb25ZID0gZ3JhYmJlclJlY3QudG9wICsgKGdyYWJiZXJSZWN0LmhlaWdodCAvIDIpOwor CisgICAgc2VsZWN0aW9uQ2hhbmdlQ291bnQgPSAwOworICAgIGRvY3VtZW50LmFkZEV2ZW50TGlz dGVuZXIoInNlbGVjdGlvbmNoYW5nZSIsICgpID0+IHsKKyAgICAgICAgKytzZWxlY3Rpb25DaGFu Z2VDb3VudDsKKyAgICAgICAgaWYgKHNlbGVjdGlvbkNoYW5nZUNvdW50ID4gNSAmJiBnZXRTZWxl Y3Rpb24oKS5yYW5nZUNvdW50KQorICAgICAgICAgICAgZ2V0U2VsZWN0aW9uKCkucmVtb3ZlQWxs UmFuZ2VzKCk7CisgICAgfSk7CisKKyAgICBhd2FpdCBVSUhlbHBlci5zZW5kRXZlbnRTdHJlYW0o bmV3IFVJSGVscGVyLkV2ZW50U3RyZWFtQnVpbGRlcigpCisgICAgICAgIC5iZWdpbihncmFiYmVy TG9jYXRpb25YLCBncmFiYmVyTG9jYXRpb25ZKQorICAgICAgICAubW92ZSgxMCwgZ3JhYmJlckxv Y2F0aW9uWSwgMSkKKyAgICAgICAgLmVuZCgxMCwgZ3JhYmJlckxvY2F0aW9uWSkKKyAgICAgICAg LnRha2VSZXN1bHQoKSk7CisKKyAgICB0ZXN0UGFzc2VkKCJEaWQgbm90IGNyYXNoIik7CisgICAg ZmluaXNoSlNUZXN0KCk7Cit9KTsKKzwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+CisgICAgTG9y ZW0gaXBzdW0gZG9sb3Igc2l0IGFtZXQsIGNvbnNldGV0dXIgc2FkaXBzY2luZyBlbGl0ciwgc2Vk IGRpYW0KKyAgICA8c3BhbiBpZD0idGFyZ2V0Ij5ub251bXllaXJtb2R0ZW1wb3I8L3NwYW4+IGlu dmlkdW50IHV0IGxhYm9yZSBldCBkb2xvcmUgbWFnbmEgYWxpcXV5YW0gZXJhdCwKKyAgICBzZWQg ZGlhbSB2b2x1cHR1YS4KKyAgICA8cD5UaGlzIHRlc3QgdmVyaWZpZXMgdGhhdCBwcm9ncmFtbWF0 aWNhbGx5IGNsZWFyaW5nIHRoZSB0ZXh0IHNlbGVjdGlvbiB3aGlsZSBpbnRlcmFjdGluZyB3aXRo IHNlbGVjdGlvbiBoYW5kbGVzIGRvZXMgbm90IGNhdXNlIGEgY3Jhc2guPC9wPgorPC9ib2R5Pgor PC9odG1sPgo= 427222 2021-04-27 17:56:03 -0700 2021-04-28 13:22:18 -0700 Patch bug-225072-20210427175602.patch text/plain 8169 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2NjI2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWRiMzY3YWFlOWQzNzlm ZjlkMjcyMjJjNTlkYTZmYWY2OWJiMzQyMS4uZjUwZGUwODA4ODI3ODQ1NjAyYTJmNGZkMzQxZGFm YTE3MGI1ZjVjYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDIxLTA0LTI3ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFdlYiBj b250ZW50IHByb2Nlc3Mgb2NjYXNpb25hbGx5IGNyYXNoZXMgdW5kZXIgVmlzaWJsZVNlbGVjdGlv bjo6YWRqdXN0UG9zaXRpb25Gb3JFbmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyNTA3MgorICAgICAgICByZGFyOi8vNzcxNTk0ODkKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGQgYSBoZWxwZXIgbWV0 aG9kIHRvIGNoZWNrIHdoZXRoZXIgb3Igbm90IHRoZSBnaXZlbiBgUG9zaXRpb25gIGlzIGluIGEg dHJlZSBzY29wZS4gU2VlIFdlYktpdC9DaGFuZ2VMb2cgZm9yCisgICAgICAgIG1vcmUgZGV0YWls cy4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL3NlbGVjdGlvbi9pb3MvY2xlYXItc2VsZWN0aW9u LXdoaWxlLW1vdmluZy1zZWxlY3Rpb24taGFuZGxlcy5odG1sCisKKyAgICAgICAgKiBkb20vUG9z aXRpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6OlBvc2l0aW9uOjppc0luVHJlZVNjb3BlIGNvbnN0 KToKKwogMjAyMS0wNC0yNiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4K IAogICAgICAgICBTdWJkaXZpZGUgaW1hZ2Ugb3ZlcmxheSB0ZXh0IGludG8gb25lIG9yIG1vcmUg ZWxlbWVudHMgcGVyIGxpbmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggOGRiYTM5ZDZlMzg2ZTEyOTEzNDRlYTExNGRk YmI0YmIxYzFiMzYzNy4uYWM4M2RkYjQ3ZDVjNTRjZjYyYjJhYjk0ZjNlZmNkZTdmODBiY2Y1OCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxOCBAQAorMjAyMS0wNC0yNyAgV2Vuc29uIEhzaWVoICA8d2Vu c29uX2hzaWVoQGFwcGxlLmNvbT4KKworICAgICAgICBbaU9TXSBXZWIgY29udGVudCBwcm9jZXNz IG9jY2FzaW9uYWxseSBjcmFzaGVzIHVuZGVyIFZpc2libGVTZWxlY3Rpb246OmFkanVzdFBvc2l0 aW9uRm9yRW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0yMjUwNzIKKyAgICAgICAgcmRhcjovLzc3MTU5NDg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBgcmFuZ2VGb3JQb2ludEluUm9vdFZpZXdD b29yZGluYXRlc2Agcm9idXN0IGluIHRoZSBjYXNlIHdoZXJlIHRoZSBvcmlnaW5hbCBzZWxlY3Rp b24gbWF5IGhhdmUgYmVjb21lCisgICAgICAgIG9ycGhhbmVkIG9yIG51bGwsIGJ5IGNoZWNraW5n IHRoYXQgdGhlIGB0YXJnZXROb2RlYCBhbmQgZXhpc3RpbmcgYHNlbGVjdGlvblN0YXJ0YCBvciBg c2VsZWN0aW9uRW5kYCBhcmUgaW4gYQorICAgICAgICB0cmVlIHNjb3BlIGJlZm9yZSBhY2Nlc3Np bmcgYHRyZWVTY29wZSgpYC4KKworICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9pb3MvV2Vi UGFnZUlPUy5tbToKKyAgICAgICAgKFdlYktpdDo6cmFuZ2VGb3JQb2ludEluUm9vdFZpZXdDb29y ZGluYXRlcyk6CisKIDIwMjEtMDQtMjYgIFRpbSBOZ3V5ZW4gIDxudGltQGFwcGxlLmNvbT4KIAog ICAgICAgICBBZGQgbW9yZSBlYWdlciBPT0IgY2hlY2tzIHdoZW4gY3JlYXRpbmcgRGlzcGxheUxp c3RSZWFkZXJIYW5kbGUgJiBEaXNwbGF5TGlzdFdyaXRlckhhbmRsZS4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9Qb3NpdGlvbi5oIGIvU291cmNlL1dlYkNvcmUvZG9tL1Bvc2l0aW9u LmgKaW5kZXggYzc0OTA5ZGY4ZWNkZGFjMjc4YjY3ZmE3NTcxZWVjMTk1ZjFiYjg1OC4uNTEyOTM3 ZjY2OThmYTlhMDE5MzE3YzQ5MzE4ZjQyZDhmYTUxMzVjOCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvZG9tL1Bvc2l0aW9uLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmgK QEAgLTEyNCw2ICsxMjQsOCBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBjb250YWluZXIgPyBj b250YWluZXItPnJvb3RFZGl0YWJsZUVsZW1lbnQoKSA6IG51bGxwdHI7CiAgICAgfQogCisgICAg Ym9vbCBpc0luVHJlZVNjb3BlKCkgY29uc3QgeyByZXR1cm4gbV9hbmNob3JOb2RlICYmIG1fYW5j aG9yTm9kZS0+aXNJblRyZWVTY29wZSgpOyB9CisKICAgICAvLyBUaGVzZSBzaG91bGQgb25seSBi ZSB1c2VkIGZvciBQb3NpdGlvbklzT2Zmc2V0SW5BbmNob3IgcG9zaXRpb25zLCB1bmxlc3MKICAg ICAvLyB0aGUgcG9zaXRpb24gaXMgYSBsZWdhY3kgZWRpdGluZyBwb3NpdGlvbi4KICAgICB2b2lk IG1vdmVUb1Bvc2l0aW9uKE5vZGUqIGFuY2hvck5vZGUsIHVuc2lnbmVkIG9mZnNldCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9pb3MvV2ViUGFnZUlPUy5t bSBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL2lvcy9XZWJQYWdlSU9TLm1tCmlu ZGV4IGUxMWZlZTc2MzUzYjQzMmVhOGY0ZGUwNDUxNGIzYmE0M2ExN2ZhNDcuLmIzNWMwYzc1MjQ3 ZDlhODg1MTY4ZGU2ZTg2ZWQyNjk1YTNkMzVjZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv V2ViUHJvY2Vzcy9XZWJQYWdlL2lvcy9XZWJQYWdlSU9TLm1tCisrKyBiL1NvdXJjZS9XZWJLaXQv V2ViUHJvY2Vzcy9XZWJQYWdlL2lvcy9XZWJQYWdlSU9TLm1tCkBAIC0xNTI0LDE0ICsxNTI0LDE0 IEBAIHN0YXRpYyBPcHRpb25hbDxTaW1wbGVSYW5nZT4gcmFuZ2VGb3JQb2ludEluUm9vdFZpZXdD b29yZGluYXRlcyhGcmFtZSYgZnJhbWUsIGNvCiAgICAgaWYgKGJhc2VJc1N0YXJ0KSB7CiAgICAg ICAgIGlmIChyZXN1bHQgPD0gc2VsZWN0aW9uU3RhcnQpCiAgICAgICAgICAgICByZXN1bHQgPSBz ZWxlY3Rpb25TdGFydC5uZXh0KCk7Ci0gICAgICAgIGVsc2UgaWYgKHRhcmdldE5vZGUgJiYgc2Vs ZWN0aW9uU3RhcnQuZGVlcEVxdWl2YWxlbnQoKS50cmVlU2NvcGUoKSAhPSAmdGFyZ2V0Tm9kZS0+ dHJlZVNjb3BlKCkpCisgICAgICAgIGVsc2UgaWYgKHRhcmdldE5vZGUgJiYgdGFyZ2V0Tm9kZS0+ aXNJblRyZWVTY29wZSgpICYmIHNlbGVjdGlvblN0YXJ0LmRlZXBFcXVpdmFsZW50KCkuaXNJblRy ZWVTY29wZSgpICYmIHNlbGVjdGlvblN0YXJ0LmRlZXBFcXVpdmFsZW50KCkudHJlZVNjb3BlKCkg IT0gJnRhcmdldE5vZGUtPnRyZWVTY29wZSgpKQogICAgICAgICAgICAgcmVzdWx0ID0gVmlzaWJs ZVNlbGVjdGlvbjo6YWRqdXN0UG9zaXRpb25Gb3JFbmQocmVzdWx0LmRlZXBFcXVpdmFsZW50KCks IHNlbGVjdGlvblN0YXJ0LmRlZXBFcXVpdmFsZW50KCkuY29udGFpbmVyTm9kZSgpKTsKIAogICAg ICAgICByYW5nZSA9IG1ha2VTaW1wbGVSYW5nZShzZWxlY3Rpb25TdGFydCwgcmVzdWx0KTsKICAg ICB9IGVsc2UgewogICAgICAgICBpZiAoc2VsZWN0aW9uRW5kIDw9IHJlc3VsdCkKICAgICAgICAg ICAgIHJlc3VsdCA9IHNlbGVjdGlvbkVuZC5wcmV2aW91cygpOwotICAgICAgICBlbHNlIGlmICh0 YXJnZXROb2RlICYmIHNlbGVjdGlvbkVuZC5kZWVwRXF1aXZhbGVudCgpLnRyZWVTY29wZSgpICE9 ICZ0YXJnZXROb2RlLT50cmVlU2NvcGUoKSkKKyAgICAgICAgZWxzZSBpZiAodGFyZ2V0Tm9kZSAm JiB0YXJnZXROb2RlLT5pc0luVHJlZVNjb3BlKCkgJiYgc2VsZWN0aW9uRW5kLmRlZXBFcXVpdmFs ZW50KCkuaXNJblRyZWVTY29wZSgpICYmIHNlbGVjdGlvbkVuZC5kZWVwRXF1aXZhbGVudCgpLnRy ZWVTY29wZSgpICE9ICZ0YXJnZXROb2RlLT50cmVlU2NvcGUoKSkKICAgICAgICAgICAgIHJlc3Vs dCA9IFZpc2libGVTZWxlY3Rpb246OmFkanVzdFBvc2l0aW9uRm9yU3RhcnQocmVzdWx0LmRlZXBF cXVpdmFsZW50KCksIHNlbGVjdGlvbkVuZC5kZWVwRXF1aXZhbGVudCgpLmNvbnRhaW5lck5vZGUo KSk7CiAKICAgICAgICAgcmFuZ2UgPSBtYWtlU2ltcGxlUmFuZ2UocmVzdWx0LCBzZWxlY3Rpb25F bmQpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCmluZGV4IDk4NDRmYjQ0MjYxNzQyYmMzYjZkZWMzNDFjMTYxYzIyZGVmZGVjMDUuLmVl YzBmOGFiNmM4ZTQxNGIzNWEwMmQ4MDQ5OGM4NTRiNjEzZTY1MmEgMTAwNjQ0Ci0tLSBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwx NyBAQAorMjAyMS0wNC0yNyAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4K KworICAgICAgICBbaU9TXSBXZWIgY29udGVudCBwcm9jZXNzIG9jY2FzaW9uYWxseSBjcmFzaGVz IHVuZGVyIFZpc2libGVTZWxlY3Rpb246OmFkanVzdFBvc2l0aW9uRm9yRW5kCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjUwNzIKKyAgICAgICAgcmRh cjovLzc3MTU5NDg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgQWRkIGEgbGF5b3V0IHRlc3QgdGhhdCBwcm9ncmFtbWF0aWNhbGx5IGNsZWFycyB0aGUg c2VsZWN0aW9uIGluIHRoZSBtaWRkbGUgb2YgY2hhbmdpbmcgaXQgYnkgbW92aW5nIHNlbGVjdGlv bgorICAgICAgICBoYW5kbGVzLgorCisgICAgICAgICogZWRpdGluZy9zZWxlY3Rpb24vaW9zL2Ns ZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmctc2VsZWN0aW9uLWhhbmRsZXMtZXhwZWN0ZWQudHh0 OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NlbGVjdGlvbi9pb3MvY2xlYXItc2VsZWN0aW9u LXdoaWxlLW1vdmluZy1zZWxlY3Rpb24taGFuZGxlcy5odG1sOiBBZGRlZC4KKwogMjAyMS0wNC0y NiAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNvbT4KIAogICAgICAgICBTdWJk aXZpZGUgaW1hZ2Ugb3ZlcmxheSB0ZXh0IGludG8gb25lIG9yIG1vcmUgZWxlbWVudHMgcGVyIGxp bmUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL2lvcy9jbGVhci1z ZWxlY3Rpb24td2hpbGUtbW92aW5nLXNlbGVjdGlvbi1oYW5kbGVzLWV4cGVjdGVkLnR4dCBiL0xh eW91dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL2lvcy9jbGVhci1zZWxlY3Rpb24td2hpbGUtbW92 aW5nLXNlbGVjdGlvbi1oYW5kbGVzLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mM2VjNDMxMjE1 NGQzNjAzMDdkMzNiMDhlNWVjZWYxZmZlNDRiN2RjCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0 VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vaW9zL2NsZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmct c2VsZWN0aW9uLWhhbmRsZXMtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNiBAQAorUEFTUyBEaWQg bm90IGNyYXNoCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExF VEUKK0xvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZXRldHVyIHNhZGlwc2NpbmcgZWxp dHIsIHNlZCBkaWFtIG5vbnVteWVpcm1vZHRlbXBvciBpbnZpZHVudCB1dCBsYWJvcmUgZXQgZG9s b3JlIG1hZ25hIGFsaXF1eWFtIGVyYXQsIHNlZCBkaWFtIHZvbHVwdHVhLgorVGhpcyB0ZXN0IHZl cmlmaWVzIHRoYXQgcHJvZ3JhbW1hdGljYWxseSBjbGVhcmluZyB0aGUgdGV4dCBzZWxlY3Rpb24g d2hpbGUgaW50ZXJhY3Rpbmcgd2l0aCBzZWxlY3Rpb24gaGFuZGxlcyBkb2VzIG5vdCBjYXVzZSBh IGNyYXNoLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zZWxlY3Rpb24vaW9zL2Ns ZWFyLXNlbGVjdGlvbi13aGlsZS1tb3Zpbmctc2VsZWN0aW9uLWhhbmRsZXMuaHRtbCBiL0xheW91 dFRlc3RzL2VkaXRpbmcvc2VsZWN0aW9uL2lvcy9jbGVhci1zZWxlY3Rpb24td2hpbGUtbW92aW5n LXNlbGVjdGlvbi1oYW5kbGVzLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNzgxMjkwMTk3OTY0ZGU1OWMwNjY1 ODI4ODFmYmJkNTJlYTYxMjZkMwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRp bmcvc2VsZWN0aW9uL2lvcy9jbGVhci1zZWxlY3Rpb24td2hpbGUtbW92aW5nLXNlbGVjdGlvbi1o YW5kbGVzLmh0bWwKQEAgLTAsMCArMSw0OCBAQAorPCFET0NUWVBFIGh0bWw+IDwhLS0gd2Via2l0 LXRlc3QtcnVubmVyIFsgdXNlRmxleGlibGVWaWV3cG9ydD10cnVlIF0gLS0+Cis8aHRtbD4KKzxt ZXRhIG5hbWU9InZpZXdwb3J0IiBjb250ZW50PSJ3aWR0aD1kZXZpY2Utd2lkdGgsIGluaXRpYWwt c2NhbGU9MSI+Cis8aGVhZD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi9yZXNvdXJjZXMvanMtdGVz dC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vcmVzb3VyY2VzL3VpLWhlbHBl ci5qcyI+PC9zY3JpcHQ+Cis8c3R5bGU+Citib2R5IHsKKyAgICBtYXJnaW46IDA7CisgICAgZm9u dC1zaXplOiAxOHB4OworfQorPC9zdHlsZT4KKzxzY3JpcHQ+Citqc1Rlc3RJc0FzeW5jID0gdHJ1 ZTsKKworYWRkRXZlbnRMaXN0ZW5lcigibG9hZCIsIGFzeW5jICgpID0+IHsKKyAgICBsZXQgdGFy Z2V0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInRhcmdldCIpOworICAgIGF3YWl0IFVJSGVs cGVyLmxvbmdQcmVzc0VsZW1lbnQodGFyZ2V0KTsKKyAgICBhd2FpdCBVSUhlbHBlci53YWl0Rm9y U2VsZWN0aW9uVG9BcHBlYXIoKTsKKyAgICBsZXQgZ3JhYmJlclJlY3QgPSBhd2FpdCBVSUhlbHBl ci5nZXRTZWxlY3Rpb25FbmRHcmFiYmVyVmlld1JlY3QoKTsKKyAgICBsZXQgZ3JhYmJlckxvY2F0 aW9uWCA9IGdyYWJiZXJSZWN0LmxlZnQgKyAoZ3JhYmJlclJlY3Qud2lkdGggLyAyKTsKKyAgICBs ZXQgZ3JhYmJlckxvY2F0aW9uWSA9IGdyYWJiZXJSZWN0LnRvcCArIChncmFiYmVyUmVjdC5oZWln aHQgLyAyKTsKKworICAgIHNlbGVjdGlvbkNoYW5nZUNvdW50ID0gMDsKKyAgICBkb2N1bWVudC5h ZGRFdmVudExpc3RlbmVyKCJzZWxlY3Rpb25jaGFuZ2UiLCAoKSA9PiB7CisgICAgICAgICsrc2Vs ZWN0aW9uQ2hhbmdlQ291bnQ7CisgICAgICAgIGlmIChzZWxlY3Rpb25DaGFuZ2VDb3VudCA+IDUg JiYgZ2V0U2VsZWN0aW9uKCkucmFuZ2VDb3VudCkKKyAgICAgICAgICAgIGdldFNlbGVjdGlvbigp LnJlbW92ZUFsbFJhbmdlcygpOworICAgIH0pOworCisgICAgYXdhaXQgVUlIZWxwZXIuc2VuZEV2 ZW50U3RyZWFtKG5ldyBVSUhlbHBlci5FdmVudFN0cmVhbUJ1aWxkZXIoKQorICAgICAgICAuYmVn aW4oZ3JhYmJlckxvY2F0aW9uWCwgZ3JhYmJlckxvY2F0aW9uWSkKKyAgICAgICAgLm1vdmUoMTAs IGdyYWJiZXJMb2NhdGlvblksIDEpCisgICAgICAgIC5lbmQoMTAsIGdyYWJiZXJMb2NhdGlvblkp CisgICAgICAgIC50YWtlUmVzdWx0KCkpOworCisgICAgdGVzdFBhc3NlZCgiRGlkIG5vdCBjcmFz aCIpOworICAgIGZpbmlzaEpTVGVzdCgpOworfSk7Cis8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5 PgorICAgIExvcmVtIGlwc3VtIGRvbG9yIHNpdCBhbWV0LCBjb25zZXRldHVyIHNhZGlwc2Npbmcg ZWxpdHIsIHNlZCBkaWFtCisgICAgPHNwYW4gaWQ9InRhcmdldCI+bm9udW15ZWlybW9kdGVtcG9y PC9zcGFuPiBpbnZpZHVudCB1dCBsYWJvcmUgZXQgZG9sb3JlIG1hZ25hIGFsaXF1eWFtIGVyYXQs CisgICAgc2VkIGRpYW0gdm9sdXB0dWEuCisgICAgPHA+VGhpcyB0ZXN0IHZlcmlmaWVzIHRoYXQg cHJvZ3JhbW1hdGljYWxseSBjbGVhcmluZyB0aGUgdGV4dCBzZWxlY3Rpb24gd2hpbGUgaW50ZXJh Y3Rpbmcgd2l0aCBzZWxlY3Rpb24gaGFuZGxlcyBkb2VzIG5vdCBjYXVzZSBhIGNyYXNoLjwvcD4K KzwvYm9keT4KKzwvaHRtbD4K 427290 2021-04-28 13:22:23 -0700 2021-04-28 17:25:41 -0700 Patch bug-225072-20210428132222.patch text/plain 4748 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjc2NzMyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODI1Y2JhOGUxZGM0YjAy YTM0OWUzYmVmYzdjYTMyODNlZTMxYjc2NC4uZDgwZmE3YjA1MjNmZWVkNDM5Zjk1NGI1ODA1ZTYw OTA1OWZmYTRmYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTA0LTI4ICBXZW5z b24gSHNpZWggIDx3ZW5zb25faHNpZWhAYXBwbGUuY29tPgorCisgICAgICAgIFtpT1NdIFdlYiBj b250ZW50IHByb2Nlc3Mgb2NjYXNpb25hbGx5IGNyYXNoZXMgdW5kZXIgVmlzaWJsZVNlbGVjdGlv bjo6YWRqdXN0UG9zaXRpb25Gb3JFbmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIyNTA3MgorICAgICAgICByZGFyOi8vNzcxNTk0ODkKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBSZW1vdmUgYSBoZWxwZXIg bWV0aG9kIHRoYXQgd2FzIGFkZGVkIGluIHIyNzY2ODgsIHdoaWNoIHdlIG5vIGxvbmdlciBuZWVk LgorCisgICAgICAgICogZG9tL1Bvc2l0aW9uLmg6CisgICAgICAgIChXZWJDb3JlOjpQb3NpdGlv bjo6aXNJblRyZWVTY29wZSBjb25zdCk6IERlbGV0ZWQuCisKIDIwMjEtMDQtMjggIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAgICAgICAgRmluZS10dW5lIHNvbWUg bW9yZSBzZWxlY3Rpb24gYmVoYXZpb3JzIGluIGltYWdlIG92ZXJsYXlzCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDQ1 MjVmZGY4MjFhOGY2M2UwNGI0NDFiY2Y1YTBhYmM2NGIzNmJlMTguLjgxMDM0OThjNDFlZTBjMzNj OTQ0ZmVhOTFlZTJlMjQ2OTkxNjUxMzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdl TG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjEt MDQtMjggIFdlbnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAg W2lPU10gV2ViIGNvbnRlbnQgcHJvY2VzcyBvY2Nhc2lvbmFsbHkgY3Jhc2hlcyB1bmRlciBWaXNp YmxlU2VsZWN0aW9uOjphZGp1c3RQb3NpdGlvbkZvckVuZAorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI1MDcyCisgICAgICAgIHJkYXI6Ly83NzE1OTQ4 OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBm aXggZm9yIHRoaXMgY3Jhc2ggdGhhdCBJIGxhbmRlZCBpbiByMjc2Njg4IHdhcyBiYXNlZCBvbiBh IG1pc3VuZGVyc3RhbmRpbmcgdGhhdCBhY2Nlc3NpbmcgYHRyZWVTY29wZSgpYAorICAgICAgICB3 b3VsZCB0cmlnZ2VyIGEgbnVsbCBwb2ludGVyIGRlcmVmIGlmIGBpc0luVHJlZVNjb3BlKClgIGlz IGBmYWxzZWAuIFRoaXMgaXMgbm90IHRoZSBjYXNlLCBzaW5jZSB0aGUgYHRyZWVTY29wZWAKKyAg ICAgICAgb2YgYSBgTm9kZWAgaXMgYSBzZXBhcmF0ZSBub3Rpb24gZnJvbSB3aGV0aGVyIHRoYXQg YE5vZGVgIGlzIGNvbm5lY3RlZCB0byBzYWlkIHRyZWUgc2NvcGUuCisKKyAgICAgICAgU2luY2Ug dGhpcyBjcmFzaCBpcyByZWFsbHkgZHVlIHRvIGRlcmVmZXJlbmNpbmcgYSBudWxsIGNvbnRhaW5l ciBub2RlIGluIHRoZSBjYXNlIHdoZXJlIGBzZWxlY3Rpb25TdGFydGAgb3IKKyAgICAgICAgYHNl bGVjdGlvbkVuZGAgYXJlIG51bGwsIGEgYmV0dGVyIGZpeCBpcyB0byBqdXN0IGNoZWNrIHRoZSBu dWxsaXR5IG9mIHRoZSBjb250YWluZXIgbm9kZS4KKworICAgICAgICAqIFdlYlByb2Nlc3MvV2Vi UGFnZS9pb3MvV2ViUGFnZUlPUy5tbToKKyAgICAgICAgKFdlYktpdDo6cmFuZ2VGb3JQb2ludElu Um9vdFZpZXdDb29yZGluYXRlcyk6CisKIDIwMjEtMDQtMjggIENvbW1pdCBRdWV1ZSAgPGNvbW1p dC1xdWV1ZUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJldmVydGluZyByMjc2 NjU4LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL1Bvc2l0aW9uLmggYi9Tb3VyY2Uv V2ViQ29yZS9kb20vUG9zaXRpb24uaAppbmRleCA1MTI5MzdmNjY5OGZhOWEwMTkzMTdjNDkzMThm NDJkOGZhNTEzNWM4Li5jNzQ5MDlkZjhlY2RkYWMyNzhiNjdmYTc1NzFlZWMxOTVmMWJiODU4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9kb20vUG9zaXRpb24uaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9kb20vUG9zaXRpb24uaApAQCAtMTI0LDggKzEyNCw2IEBAIHB1YmxpYzoKICAgICAgICAg cmV0dXJuIGNvbnRhaW5lciA/IGNvbnRhaW5lci0+cm9vdEVkaXRhYmxlRWxlbWVudCgpIDogbnVs bHB0cjsKICAgICB9CiAKLSAgICBib29sIGlzSW5UcmVlU2NvcGUoKSBjb25zdCB7IHJldHVybiBt X2FuY2hvck5vZGUgJiYgbV9hbmNob3JOb2RlLT5pc0luVHJlZVNjb3BlKCk7IH0KLQogICAgIC8v IFRoZXNlIHNob3VsZCBvbmx5IGJlIHVzZWQgZm9yIFBvc2l0aW9uSXNPZmZzZXRJbkFuY2hvciBw b3NpdGlvbnMsIHVubGVzcwogICAgIC8vIHRoZSBwb3NpdGlvbiBpcyBhIGxlZ2FjeSBlZGl0aW5n IHBvc2l0aW9uLgogICAgIHZvaWQgbW92ZVRvUG9zaXRpb24oTm9kZSogYW5jaG9yTm9kZSwgdW5z aWduZWQgb2Zmc2V0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQ YWdlL2lvcy9XZWJQYWdlSU9TLm1tIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2Uv aW9zL1dlYlBhZ2VJT1MubW0KaW5kZXggYjM1YzBjNzUyNDdkOWE4ODUxNjhkZTZlODZlZDI2OTVh M2QzNWNlOC4uY2YxMzFkYjc3NDAyMGE4NTFhOTIwMGVhMzViYmU4NWI5MTQ2MTRlMyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW0K KysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvaW9zL1dlYlBhZ2VJT1MubW0K QEAgLTE1MjQsMTUgKzE1MjQsMTUgQEAgc3RhdGljIE9wdGlvbmFsPFNpbXBsZVJhbmdlPiByYW5n ZUZvclBvaW50SW5Sb290Vmlld0Nvb3JkaW5hdGVzKEZyYW1lJiBmcmFtZSwgY28KICAgICBpZiAo YmFzZUlzU3RhcnQpIHsKICAgICAgICAgaWYgKHJlc3VsdCA8PSBzZWxlY3Rpb25TdGFydCkKICAg ICAgICAgICAgIHJlc3VsdCA9IHNlbGVjdGlvblN0YXJ0Lm5leHQoKTsKLSAgICAgICAgZWxzZSBp ZiAodGFyZ2V0Tm9kZSAmJiB0YXJnZXROb2RlLT5pc0luVHJlZVNjb3BlKCkgJiYgc2VsZWN0aW9u U3RhcnQuZGVlcEVxdWl2YWxlbnQoKS5pc0luVHJlZVNjb3BlKCkgJiYgc2VsZWN0aW9uU3RhcnQu ZGVlcEVxdWl2YWxlbnQoKS50cmVlU2NvcGUoKSAhPSAmdGFyZ2V0Tm9kZS0+dHJlZVNjb3BlKCkp Ci0gICAgICAgICAgICByZXN1bHQgPSBWaXNpYmxlU2VsZWN0aW9uOjphZGp1c3RQb3NpdGlvbkZv ckVuZChyZXN1bHQuZGVlcEVxdWl2YWxlbnQoKSwgc2VsZWN0aW9uU3RhcnQuZGVlcEVxdWl2YWxl bnQoKS5jb250YWluZXJOb2RlKCkpOworICAgICAgICBlbHNlIGlmIChhdXRvIGNvbnRhaW5lck5v ZGUgPSBtYWtlUmVmUHRyKHNlbGVjdGlvblN0YXJ0LmRlZXBFcXVpdmFsZW50KCkuY29udGFpbmVy Tm9kZSgpKTsgY29udGFpbmVyTm9kZSAmJiB0YXJnZXROb2RlICYmICZjb250YWluZXJOb2RlLT50 cmVlU2NvcGUoKSAhPSAmdGFyZ2V0Tm9kZS0+dHJlZVNjb3BlKCkpCisgICAgICAgICAgICByZXN1 bHQgPSBWaXNpYmxlU2VsZWN0aW9uOjphZGp1c3RQb3NpdGlvbkZvckVuZChyZXN1bHQuZGVlcEVx dWl2YWxlbnQoKSwgY29udGFpbmVyTm9kZS5nZXQoKSk7CiAKICAgICAgICAgcmFuZ2UgPSBtYWtl U2ltcGxlUmFuZ2Uoc2VsZWN0aW9uU3RhcnQsIHJlc3VsdCk7CiAgICAgfSBlbHNlIHsKICAgICAg ICAgaWYgKHNlbGVjdGlvbkVuZCA8PSByZXN1bHQpCiAgICAgICAgICAgICByZXN1bHQgPSBzZWxl Y3Rpb25FbmQucHJldmlvdXMoKTsKLSAgICAgICAgZWxzZSBpZiAodGFyZ2V0Tm9kZSAmJiB0YXJn ZXROb2RlLT5pc0luVHJlZVNjb3BlKCkgJiYgc2VsZWN0aW9uRW5kLmRlZXBFcXVpdmFsZW50KCku aXNJblRyZWVTY29wZSgpICYmIHNlbGVjdGlvbkVuZC5kZWVwRXF1aXZhbGVudCgpLnRyZWVTY29w ZSgpICE9ICZ0YXJnZXROb2RlLT50cmVlU2NvcGUoKSkKLSAgICAgICAgICAgIHJlc3VsdCA9IFZp c2libGVTZWxlY3Rpb246OmFkanVzdFBvc2l0aW9uRm9yU3RhcnQocmVzdWx0LmRlZXBFcXVpdmFs ZW50KCksIHNlbGVjdGlvbkVuZC5kZWVwRXF1aXZhbGVudCgpLmNvbnRhaW5lck5vZGUoKSk7Cisg ICAgICAgIGVsc2UgaWYgKGF1dG8gY29udGFpbmVyTm9kZSA9IG1ha2VSZWZQdHIoc2VsZWN0aW9u RW5kLmRlZXBFcXVpdmFsZW50KCkuY29udGFpbmVyTm9kZSgpKTsgY29udGFpbmVyTm9kZSAmJiB0 YXJnZXROb2RlICYmICZjb250YWluZXJOb2RlLT50cmVlU2NvcGUoKSAhPSAmdGFyZ2V0Tm9kZS0+ dHJlZVNjb3BlKCkpCisgICAgICAgICAgICByZXN1bHQgPSBWaXNpYmxlU2VsZWN0aW9uOjphZGp1 c3RQb3NpdGlvbkZvclN0YXJ0KHJlc3VsdC5kZWVwRXF1aXZhbGVudCgpLCBjb250YWluZXJOb2Rl LmdldCgpKTsKIAogICAgICAgICByYW5nZSA9IG1ha2VTaW1wbGVSYW5nZShyZXN1bHQsIHNlbGVj dGlvbkVuZCk7CiAgICAgfQo=