231220 2021-10-05 01:49:17 -0700 Clean up shouldAutofocus in HTMLFormControlElement.cpp 2021-10-09 01:32:42 -0700 1 1 1 Unclassified WebKit DOM WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 203139 1 ntim ntim cdumez changseok esprehn+autocc ews-watchlist gyuyoung.kim mifenton rniwa webkit-bug-importer youennf oldest_to_newest 1800445 0 ntim 2021-10-05 01:49:17 -0700 Factor out uses of `element->document()`. 1800448 1 440183 ntim 2021-10-05 02:09:05 -0700 Created attachment 440183 Patch 1800450 2 440183 youennf 2021-10-05 02:16:42 -0700 Comment on attachment 440183 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440183&action=review > Source/WebCore/html/HTMLFormControlElement.cpp:211 > + Ref document = element->document(); Not sure we need to ref it, we are only using document getters, then calling addConsoleMessage and returning. I would just do auto& document = element->document(); 1800467 3 440189 ntim 2021-10-05 02:47:33 -0700 Created attachment 440189 Patch 1800490 4 ntim 2021-10-05 02:54:48 -0700 Committed r283543 (242508@main): <https://commits.webkit.org/242508@main> 1800491 5 webkit-bug-importer 2021-10-05 02:55:19 -0700 <rdar://problem/83878528> 1800709 6 440189 rniwa 2021-10-05 12:42:31 -0700 Comment on attachment 440189 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=440189&action=review > Source/WebCore/html/HTMLFormControlElement.cpp:211 > + auto& document = element.document(); We should store this in Ref. 1801617 7 ntim 2021-10-07 08:52:49 -0700 (In reply to Ryosuke Niwa from comment #6) > Comment on attachment 440189 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=440189&action=review > > > Source/WebCore/html/HTMLFormControlElement.cpp:211 > > + auto& document = element.document(); > > We should store this in Ref. See comment 2 by Youenn. Making the argument a `const HTMLFormControlElement&` should be sufficient for safety, but if you think Ref is necessary here, please file a bug and mention why. 1801686 8 rniwa 2021-10-07 11:35:16 -0700 (In reply to Tim Nguyen (:ntim) from comment #7) > (In reply to Ryosuke Niwa from comment #6) > > Comment on attachment 440189 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=440189&action=review > > > > > Source/WebCore/html/HTMLFormControlElement.cpp:211 > > > + auto& document = element.document(); > > > > We should store this in Ref. > > See comment 2 by Youenn. Making the argument a `const > HTMLFormControlElement&` should be sufficient for safety, but if you think > Ref is necessary here, please file a bug and mention why. An object being const is no guarantee of safety. There are thousands of const_cast in WebKit. Also, generally, people who leave code comments like this isn't responsible for filing a new bug. It's on you. 1801806 9 ntim 2021-10-07 14:56:30 -0700 (In reply to Ryosuke Niwa from comment #8) > An object being const is no guarantee of safety. There are thousands of > const_cast in WebKit. > > Also, generally, people who leave code comments like this isn't responsible > for filing a new bug. It's on you. I don't mind filing a bug, though this is against what Youenn said in comment 2 (who told me to use `auto&` instead of `Ref`). Why is `Ref` necessary in this case? 1801840 10 rniwa 2021-10-07 16:02:30 -0700 (In reply to Tim Nguyen (:ntim) from comment #9) > (In reply to Ryosuke Niwa from comment #8) > > An object being const is no guarantee of safety. There are thousands of > > const_cast in WebKit. > > > > Also, generally, people who leave code comments like this isn't responsible > > for filing a new bug. It's on you. > > I don't mind filing a bug, though this is against what Youenn said in > comment 2 (who told me to use `auto&` instead of `Ref`). Why is `Ref` > necessary in this case? Generally, whenever we're strong a pointer or a reference to a ref counted object in stack, we want to use Ref/RefPtr instead of a raw pointer / raw reference unless we're only calling trivial functions (e.g. just returning a member variable). See https://lists.webkit.org/pipermail/webkit-dev/2020-September/031386.html 1801951 11 youennf 2021-10-08 00:27:54 -0700 (In reply to Ryosuke Niwa from comment #10) > (In reply to Tim Nguyen (:ntim) from comment #9) > > (In reply to Ryosuke Niwa from comment #8) > > > An object being const is no guarantee of safety. There are thousands of > > > const_cast in WebKit. > > > > > > Also, generally, people who leave code comments like this isn't responsible > > > for filing a new bug. It's on you. > > > > I don't mind filing a bug, though this is against what Youenn said in > > comment 2 (who told me to use `auto&` instead of `Ref`). Why is `Ref` > > necessary in this case? > > Generally, whenever we're strong a pointer or a reference to a ref counted > object in stack, we want to use Ref/RefPtr instead of a raw pointer / raw > reference unless we're only calling trivial functions (e.g. just returning a > member variable). See > https://lists.webkit.org/pipermail/webkit-dev/2020-September/031386.html I think shouldAutofocus is at the boundary. It is possible to refactor it to only call trivial getters, the only call (addConsoleMessage) could be moved outside if needed by returning a String error message (addConsoleMesage would be called by shouldAutofocus caller if string is not null). Also, why refing, if we can just call document() each time, which is probably fast. 1801956 12 rniwa 2021-10-08 00:46:58 -0700 (In reply to youenn fablet from comment #11) > (In reply to Ryosuke Niwa from comment #10) > > (In reply to Tim Nguyen (:ntim) from comment #9) > > > (In reply to Ryosuke Niwa from comment #8) > > > > An object being const is no guarantee of safety. There are thousands of > > > > const_cast in WebKit. > > > > > > > > Also, generally, people who leave code comments like this isn't responsible > > > > for filing a new bug. It's on you. > > > > > > I don't mind filing a bug, though this is against what Youenn said in > > > comment 2 (who told me to use `auto&` instead of `Ref`). Why is `Ref` > > > necessary in this case? > > > > Generally, whenever we're strong a pointer or a reference to a ref counted > > object in stack, we want to use Ref/RefPtr instead of a raw pointer / raw > > reference unless we're only calling trivial functions (e.g. just returning a > > member variable). See > > https://lists.webkit.org/pipermail/webkit-dev/2020-September/031386.html > > I think shouldAutofocus is at the boundary. There is no such a thing as "at boundary". The rule here dictates that we should be strong it in Ref/RefPtr. > It is possible to refactor it to only call trivial getters, the only call > (addConsoleMessage) could be moved outside if needed by returning a String > error message (addConsoleMesage would be called by shouldAutofocus caller if > string is not null). Since such a refactoring hasn't been done, we should just store it in Ref/RefPtr. It's really not useful to avoid ref-counting like that. > Also, why refing, if we can just call document() each time, which is > probably fast. No, document() dereferences m_treeScope and then has to check whether m_treeScope is a document or not. If a node is inside a shadow tree, then it has to perform a secondary lookup to obtain the document. Also, calling document() each time isn't safe either because if you're calling a non-trivial function on Document (or its superclass), then such a non-trivial function could end up invoking some other function (e.g. IPC code) and trigger a synchronous destruction of Document. Generally, we don't want everyone who has to modify any code in WebCore to having to reason about what is or what isn't safe. Here, instead of contemplating why calling a given function is safe on a document, we should simply keep the document alive longer. 1801982 13 youennf 2021-10-08 03:47:27 -0700 > There is no such a thing as "at boundary". The rule here dictates that we > should be strong it in Ref/RefPtr. There is no use of document after a non-trivial call, that is why I think it is sort of a gray area. > > It is possible to refactor it to only call trivial getters, the only call > > (addConsoleMessage) could be moved outside if needed by returning a String > > error message (addConsoleMesage would be called by shouldAutofocus caller if > > string is not null). > > Since such a refactoring hasn't been done, we should just store it in > Ref/RefPtr. It's really not useful to avoid ref-counting like that. I can look at the refactoring, I usually like splitting safe/non mutable code from mutable code. > > Also, why refing, if we can just call document() each time, which is > > probably fast. > > No, document() dereferences m_treeScope and then has to check whether > m_treeScope is a document or not. If a node is inside a shadow tree, then it > has to perform a secondary lookup to obtain the document. Quickly looking at the code, I do not see the tree scope check nor the shadow tree specific path. I might have missed something. > Also, calling > document() each time isn't safe either because if you're calling a > non-trivial function on Document (or its superclass), then such a > non-trivial function could end up invoking some other function (e.g. IPC > code) and trigger a synchronous destruction of Document. Agreed but then we have a problem since the expectation is that having a valid element guarantees having a valid document reference. So we should then ref element as well? 1801989 14 youennf 2021-10-08 04:08:11 -0700 > I can look at the refactoring, I usually like splitting safe/non mutable > code from mutable code. I had a try at https://bugs.webkit.org/show_bug.cgi?id=231417 1802370 15 rniwa 2021-10-09 01:32:42 -0700 (In reply to youenn fablet from comment #13) > > There is no such a thing as "at boundary". The rule here dictates that we > > should be strong it in Ref/RefPtr. > > There is no use of document after a non-trivial call, that is why I think it > is sort of a gray area. The problem is that this kind of code is fragile. Any future changes to any one of currently trivial functions can introduce a new use-after-free. We don't want to make WebKit totally unmaintainable by making every function change require a massive audit of every caller as well as every ancestor callers. This immediately results in exponential growth of code to audit, and results either in new use-after-free to be introduced or makes it impossible to make any future code changes. Either option is unacceptable. > > > It is possible to refactor it to only call trivial getters, the only call > > > (addConsoleMessage) could be moved outside if needed by returning a String > > > error message (addConsoleMesage would be called by shouldAutofocus caller if > > > string is not null). > > > > Since such a refactoring hasn't been done, we should just store it in > > Ref/RefPtr. It's really not useful to avoid ref-counting like that. > > I can look at the refactoring, I usually like splitting safe/non mutable > code from mutable code. It doesn't matter whether such a refactoring is done or not. The above issue withstands regardless. > > > Also, why refing, if we can just call document() each time, which is > > > probably fast. > > > > No, document() dereferences m_treeScope and then has to check whether > > m_treeScope is a document or not. If a node is inside a shadow tree, then it > > has to perform a secondary lookup to obtain the document. > > Quickly looking at the code, I do not see the tree scope check nor the > shadow tree specific path. > I might have missed something. Node::document is defined as this: Document& document() const { return treeScope().documentScope(); } TreeScope& treeScope() const { ASSERT(m_treeScope); return *m_treeScope; } TreeScope::documentScope is defined as follows: Document& documentScope() const { return m_documentScope.get(); } Here, m_documentScope != this when TreeScope is a ShadowRoot. > > Also, calling > > document() each time isn't safe either because if you're calling a > > non-trivial function on Document (or its superclass), then such a > > non-trivial function could end up invoking some other function (e.g. IPC > > code) and trigger a synchronous destruction of Document. > > Agreed but then we have a problem since the expectation is that having a > valid element guarantees having a valid document reference. > So we should then ref element as well? That's on the caller. The caller should keep the element alive per rules in https://lists.webkit.org/pipermail/webkit-dev/2020-September/031386.html. A subtle issue here is that an element can be the last thing keeping this document alive, and if there is any script execution, then that script can adopt this element to another document, making document eligible for deletion. There are hundreds of subtle object model subtleties like this scattered across WebCore, and most WebKit engineers aren't familiar with all of them. As such, it's quite silly to rely on everyone to be aware of them all and carefully remembering to only Ref when it's absolutely needed. This is precisely why we're adopting new rule on how to reply Ref/RefPtr as outlined in https://lists.webkit.org/pipermail/webkit-dev/2020-September/031386.html. Please go talk with Geoff if you have any questions or concerns. 440183 2021-10-05 02:09:05 -0700 2021-10-05 02:47:29 -0700 Patch bug-231220-20211005110904.patch text/plain 3393 ntim U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTQyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmViMWI3MjY4ZjVlODk5 N2M5MWZiNzkwNmI2M2RjYmM5MTM5NjkwZC4uYzIxOTQyOGQ4OGI4NzVmOGY3NjkzNDU0NjZmMWQ1 ODMwM2I3YzAwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDIxLTEwLTA1ICBUaW0g Tmd1eWVuICA8bnRpbUBhcHBsZS5jb20+CisKKyAgICAgICAgQ2xlYW4gdXAgc2hvdWxkQXV0b2Zv Y3VzIGluIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzEyMjAKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBObyBiZWhhdmlvdXIgY2hhbmdlLgorCisgICAgICAg IE1pbm9yIGNsZWFudXBzOgorICAgICAgICAtIENsZWFuIHVwIHJlcGVhdGVkIGNhbGxzIG9mIGVs ZW1lbnQtPmRvY3VtZW50KCkKKyAgICAgICAgLSBVc2UgdG9wT3JpZ2luKCkgaW5zdGVhZCB0b3BE b2N1bWVudCgpLnNlY3VyaXR5T3JpZ2luKCkgKHNhbWUgdGhpbmcsIGJ1dCBzaG9ydGVyKQorCisg ICAgICAgICogaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OnNob3VsZEF1dG9mb2N1cyk6CisKIDIwMjEtMTAtMDUgIE15bGVzIEMuIE1heGZpZWxkICA8 bW1heGZpZWxkQGFwcGxlLmNvbT4KIAogICAgICAgICBOZWdhdGl2ZSBpbnRlZ2VycyBpbiBAZm9u dC1wYWxldHRlLXZhbHVlcyBhcmUgaW52YWxpZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRN TEZvcm1Db250cm9sRWxlbWVudC5jcHAKaW5kZXggMTQxZTY1OGZlYTU0ZDRlOWExNGNmMmY1NGVm MzIxOGI0YzFiNzFiZS4uOTJiMGUyZGM1Y2M2ZDEzMWQxM2VlZDliMjRlNWMzMjFjNGY1ODExYiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCkBA IC0yLDcgKzIsNyBAQAogICogQ29weXJpZ2h0IChDKSAxOTk5IExhcnMgS25vbGwgKGtub2xsQGtk ZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDE5OTkgQW50dGkgS29pdmlzdG8gKGtvaXZpc3RvQGtk ZS5vcmcpCiAgKiAgICAgICAgICAgKEMpIDIwMDEgRGlyayBNdWVsbGVyIChtdWVsbGVyQGtkZS5v cmcpCi0gKiBDb3B5cmlnaHQgKEMpIDIwMDQtMjAyMCBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKiBDb3B5cmlnaHQgKEMpIDIwMDQtMjAyMSBBcHBsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCiAgKiAgICAgICAgICAgKEMpIDIwMDYgQWxleGV5IFByb3NrdXJ5YWtvdiAoYXBA bnlwb3AuY29tKQogICoKICAqIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKQEAgLTIwNywxNyArMjA3LDE3IEBAIHN0YXRpYyBib29s IHNob3VsZEF1dG9mb2N1cyhIVE1MRm9ybUNvbnRyb2xFbGVtZW50KiBlbGVtZW50KQogICAgICAg ICByZXR1cm4gZmFsc2U7CiAgICAgaWYgKCFlbGVtZW50LT5oYXNBdHRyaWJ1dGVXaXRob3V0U3lu Y2hyb25pemF0aW9uKGF1dG9mb2N1c0F0dHIpKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAg aWYgKCFlbGVtZW50LT5pc0Nvbm5lY3RlZCgpIHx8ICFlbGVtZW50LT5kb2N1bWVudCgpLnJlbmRl clZpZXcoKSkKKworICAgIFJlZiBkb2N1bWVudCA9IGVsZW1lbnQtPmRvY3VtZW50KCk7CisgICAg aWYgKCFlbGVtZW50LT5pc0Nvbm5lY3RlZCgpIHx8ICFkb2N1bWVudC0+cmVuZGVyVmlldygpKQog ICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgaWYgKGVsZW1lbnQtPmRvY3VtZW50KCkuaXNTYW5k Ym94ZWQoU2FuZGJveEF1dG9tYXRpY0ZlYXR1cmVzKSkgeworICAgIGlmIChkb2N1bWVudC0+aXNT YW5kYm94ZWQoU2FuZGJveEF1dG9tYXRpY0ZlYXR1cmVzKSkgewogICAgICAgICAvLyBGSVhNRTog VGhpcyBtZXNzYWdlIHNob3VsZCBiZSBtb3ZlZCBvZmYgdGhlIGNvbnNvbGUgb25jZSBhIHNvbHV0 aW9uIHRvIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDMyNzQgZXhp c3RzLgotICAgICAgICBlbGVtZW50LT5kb2N1bWVudCgpLmFkZENvbnNvbGVNZXNzYWdlKE1lc3Nh Z2VTb3VyY2U6OlNlY3VyaXR5LCBNZXNzYWdlTGV2ZWw6OkVycm9yLCAiQmxvY2tlZCBhdXRvZm9j dXNpbmcgb24gYSBmb3JtIGNvbnRyb2wgYmVjYXVzZSB0aGUgZm9ybSdzIGZyYW1lIGlzIHNhbmRi b3hlZCBhbmQgdGhlICdhbGxvdy1zY3JpcHRzJyBwZXJtaXNzaW9uIGlzIG5vdCBzZXQuIl9zKTsK KyAgICAgICAgZG9jdW1lbnQtPmFkZENvbnNvbGVNZXNzYWdlKE1lc3NhZ2VTb3VyY2U6OlNlY3Vy aXR5LCBNZXNzYWdlTGV2ZWw6OkVycm9yLCAiQmxvY2tlZCBhdXRvZm9jdXNpbmcgb24gYSBmb3Jt IGNvbnRyb2wgYmVjYXVzZSB0aGUgZm9ybSdzIGZyYW1lIGlzIHNhbmRib3hlZCBhbmQgdGhlICdh bGxvdy1zY3JpcHRzJyBwZXJtaXNzaW9uIGlzIG5vdCBzZXQuIl9zKTsKICAgICAgICAgcmV0dXJu IGZhbHNlOwogICAgIH0KLQotICAgIGF1dG8mIGRvY3VtZW50ID0gZWxlbWVudC0+ZG9jdW1lbnQo KTsKLSAgICBpZiAoIWRvY3VtZW50LmZyYW1lKCktPmlzTWFpbkZyYW1lKCkgJiYgIWRvY3VtZW50 LnRvcERvY3VtZW50KCkuc2VjdXJpdHlPcmlnaW4oKS5pc1NhbWVPcmlnaW5Eb21haW4oZG9jdW1l bnQuc2VjdXJpdHlPcmlnaW4oKSkpIHsKLSAgICAgICAgZG9jdW1lbnQuYWRkQ29uc29sZU1lc3Nh Z2UoTWVzc2FnZVNvdXJjZTo6U2VjdXJpdHksIE1lc3NhZ2VMZXZlbDo6RXJyb3IsICJCbG9ja2Vk IGF1dG9mb2N1c2luZyBvbiBhIGZvcm0gY29udHJvbCBpbiBhIGNyb3NzLW9yaWdpbiBzdWJmcmFt ZS4iX3MpOworICAgIGlmICghZG9jdW1lbnQtPmZyYW1lKCktPmlzTWFpbkZyYW1lKCkgJiYgIWRv Y3VtZW50LT50b3BPcmlnaW4oKS5pc1NhbWVPcmlnaW5Eb21haW4oZG9jdW1lbnQtPnNlY3VyaXR5 T3JpZ2luKCkpKSB7CisgICAgICAgIGRvY3VtZW50LT5hZGRDb25zb2xlTWVzc2FnZShNZXNzYWdl U291cmNlOjpTZWN1cml0eSwgTWVzc2FnZUxldmVsOjpFcnJvciwgIkJsb2NrZWQgYXV0b2ZvY3Vz aW5nIG9uIGEgZm9ybSBjb250cm9sIGluIGEgY3Jvc3Mtb3JpZ2luIHN1YmZyYW1lLiJfcyk7CiAg ICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAK 440189 2021-10-05 02:47:33 -0700 2021-10-05 02:47:33 -0700 Patch bug-231220-20211005114732.patch text/plain 5729 ntim U3VidmVyc2lvbiBSZXZpc2lvbjogMjgzNTQyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmViMWI3MjY4ZjVlODk5 N2M5MWZiNzkwNmI2M2RjYmM5MTM5NjkwZC4uZWVhMmE2MTkxZDQ4YWEyZThmZGI0MzU4YjMxODdi MDkxM2ZkM2ZlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDIxLTEwLTA1ICBUaW0g Tmd1eWVuICA8bnRpbUBhcHBsZS5jb20+CisKKyAgICAgICAgQ2xlYW4gdXAgc2hvdWxkQXV0b2Zv Y3VzIGluIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCisgICAgICAgIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMzEyMjAKKworICAgICAgICBSZXZpZXdlZCBieSBZ b3Vlbm4gRmFibGV0LgorCisgICAgICAgIE5vIGJlaGF2aW91ciBjaGFuZ2UuCisKKyAgICAgICAg TWlub3IgY2xlYW51cHM6CisgICAgICAgIC0gTWFrZSBzaG91bGRBdXRvZm9jdXMgdGFrZSBgY29u c3QgSFRNTEZvcm1Db250cm9sRWxlbWVudCZgIGluc3RlYWQgb2YgYEhUTUxGb3JtQ29udHJvbEVs ZW1lbnQqYAorICAgICAgICAtIENsZWFuIHVwIHJlcGVhdGVkIGNhbGxzIHRvIGVsZW1lbnQtPmRv Y3VtZW50KCkKKyAgICAgICAgLSBVc2UgdG9wT3JpZ2luKCkgaW5zdGVhZCB0b3BEb2N1bWVudCgp LnNlY3VyaXR5T3JpZ2luKCkgKHNhbWUgdGhpbmcsIGJ1dCBzaG9ydGVyKQorCisgICAgICAgICog aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OnNob3Vs ZEF1dG9mb2N1cyk6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRm9ybUNvbnRyb2xFbGVtZW50Ojpk aWRBdHRhY2hSZW5kZXJlcnMpOgorICAgICAgICAqIGh0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVu dC5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6aGFzQXV0b2Zv Y3VzZWQgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTEZvcm1Db250cm9sRWxlbWVudDo6 aGFzQXV0b2ZvY3VzZWQpOiBEZWxldGVkLgorCiAyMDIxLTEwLTA1ICBNeWxlcyBDLiBNYXhmaWVs ZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CiAKICAgICAgICAgTmVnYXRpdmUgaW50ZWdlcnMgaW4g QGZvbnQtcGFsZXR0ZS12YWx1ZXMgYXJlIGludmFsaWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuY3BwCmluZGV4IDE0MWU2NThmZWE1NGQ0ZTlhMTRjZjJm NTRlZjMyMThiNGMxYjcxYmUuLjliMjY5NzZhNjAzNGE4MDVmZjA5ZGE2NDRmNTZjMTFlZDlmZGEx YmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVu dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmNw cApAQCAtMiw3ICsyLDcgQEAKICAqIENvcHlyaWdodCAoQykgMTk5OSBMYXJzIEtub2xsIChrbm9s bEBrZGUub3JnKQogICogICAgICAgICAgIChDKSAxOTk5IEFudHRpIEtvaXZpc3RvIChrb2l2aXN0 b0BrZGUub3JnKQogICogICAgICAgICAgIChDKSAyMDAxIERpcmsgTXVlbGxlciAobXVlbGxlckBr ZGUub3JnKQotICogQ29weXJpZ2h0IChDKSAyMDA0LTIwMjAgQXBwbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICogQ29weXJpZ2h0IChDKSAyMDA0LTIwMjEgQXBwbGUgSW5jLiBBbGwgcmln aHRzIHJlc2VydmVkLgogICogICAgICAgICAgIChDKSAyMDA2IEFsZXhleSBQcm9za3VyeWFrb3Yg KGFwQG55cG9wLmNvbSkKICAqCiAgKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91 IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCkBAIC0yMDEsNDAgKzIwMSw0MCBAQCB2b2lkIEhU TUxGb3JtQ29udHJvbEVsZW1lbnQ6OnJlcXVpcmVkU3RhdGVDaGFuZ2VkKCkKICAgICBpbnZhbGlk YXRlU3R5bGVGb3JTdWJ0cmVlKCk7CiB9CiAKLXN0YXRpYyBib29sIHNob3VsZEF1dG9mb2N1cyhI VE1MRm9ybUNvbnRyb2xFbGVtZW50KiBlbGVtZW50KQorc3RhdGljIGJvb2wgc2hvdWxkQXV0b2Zv Y3VzKGNvbnN0IEhUTUxGb3JtQ29udHJvbEVsZW1lbnQmIGVsZW1lbnQpCiB7Ci0gICAgaWYgKCFl bGVtZW50LT5yZW5kZXJlcigpKQorICAgIGlmICghZWxlbWVudC5yZW5kZXJlcigpKQogICAgICAg ICByZXR1cm4gZmFsc2U7Ci0gICAgaWYgKCFlbGVtZW50LT5oYXNBdHRyaWJ1dGVXaXRob3V0U3lu Y2hyb25pemF0aW9uKGF1dG9mb2N1c0F0dHIpKQorICAgIGlmICghZWxlbWVudC5oYXNBdHRyaWJ1 dGVXaXRob3V0U3luY2hyb25pemF0aW9uKGF1dG9mb2N1c0F0dHIpKQogICAgICAgICByZXR1cm4g ZmFsc2U7Ci0gICAgaWYgKCFlbGVtZW50LT5pc0Nvbm5lY3RlZCgpIHx8ICFlbGVtZW50LT5kb2N1 bWVudCgpLnJlbmRlclZpZXcoKSkKKworICAgIGF1dG8mIGRvY3VtZW50ID0gZWxlbWVudC5kb2N1 bWVudCgpOworICAgIGlmICghZWxlbWVudC5pc0Nvbm5lY3RlZCgpIHx8ICFkb2N1bWVudC5yZW5k ZXJWaWV3KCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICBpZiAoZWxlbWVudC0+ZG9jdW1l bnQoKS5pc1NhbmRib3hlZChTYW5kYm94QXV0b21hdGljRmVhdHVyZXMpKSB7CisgICAgaWYgKGRv Y3VtZW50LmlzU2FuZGJveGVkKFNhbmRib3hBdXRvbWF0aWNGZWF0dXJlcykpIHsKICAgICAgICAg Ly8gRklYTUU6IFRoaXMgbWVzc2FnZSBzaG91bGQgYmUgbW92ZWQgb2ZmIHRoZSBjb25zb2xlIG9u Y2UgYSBzb2x1dGlvbiB0byBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTAzMjc0IGV4aXN0cy4KLSAgICAgICAgZWxlbWVudC0+ZG9jdW1lbnQoKS5hZGRDb25zb2xlTWVz c2FnZShNZXNzYWdlU291cmNlOjpTZWN1cml0eSwgTWVzc2FnZUxldmVsOjpFcnJvciwgIkJsb2Nr ZWQgYXV0b2ZvY3VzaW5nIG9uIGEgZm9ybSBjb250cm9sIGJlY2F1c2UgdGhlIGZvcm0ncyBmcmFt ZSBpcyBzYW5kYm94ZWQgYW5kIHRoZSAnYWxsb3ctc2NyaXB0cycgcGVybWlzc2lvbiBpcyBub3Qg c2V0LiJfcyk7CisgICAgICAgIGRvY3VtZW50LmFkZENvbnNvbGVNZXNzYWdlKE1lc3NhZ2VTb3Vy Y2U6OlNlY3VyaXR5LCBNZXNzYWdlTGV2ZWw6OkVycm9yLCAiQmxvY2tlZCBhdXRvZm9jdXNpbmcg b24gYSBmb3JtIGNvbnRyb2wgYmVjYXVzZSB0aGUgZm9ybSdzIGZyYW1lIGlzIHNhbmRib3hlZCBh bmQgdGhlICdhbGxvdy1zY3JpcHRzJyBwZXJtaXNzaW9uIGlzIG5vdCBzZXQuIl9zKTsKICAgICAg ICAgcmV0dXJuIGZhbHNlOwogICAgIH0KLQotICAgIGF1dG8mIGRvY3VtZW50ID0gZWxlbWVudC0+ ZG9jdW1lbnQoKTsKLSAgICBpZiAoIWRvY3VtZW50LmZyYW1lKCktPmlzTWFpbkZyYW1lKCkgJiYg IWRvY3VtZW50LnRvcERvY3VtZW50KCkuc2VjdXJpdHlPcmlnaW4oKS5pc1NhbWVPcmlnaW5Eb21h aW4oZG9jdW1lbnQuc2VjdXJpdHlPcmlnaW4oKSkpIHsKKyAgICBpZiAoIWRvY3VtZW50LmZyYW1l KCktPmlzTWFpbkZyYW1lKCkgJiYgIWRvY3VtZW50LnRvcE9yaWdpbigpLmlzU2FtZU9yaWdpbkRv bWFpbihkb2N1bWVudC5zZWN1cml0eU9yaWdpbigpKSkgewogICAgICAgICBkb2N1bWVudC5hZGRD b25zb2xlTWVzc2FnZShNZXNzYWdlU291cmNlOjpTZWN1cml0eSwgTWVzc2FnZUxldmVsOjpFcnJv ciwgIkJsb2NrZWQgYXV0b2ZvY3VzaW5nIG9uIGEgZm9ybSBjb250cm9sIGluIGEgY3Jvc3Mtb3Jp Z2luIHN1YmZyYW1lLiJfcyk7CiAgICAgICAgIHJldHVybiBmYWxzZTsKICAgICB9CiAKLSAgICBp ZiAoZWxlbWVudC0+aGFzQXV0b2ZvY3VzZWQoKSkKKyAgICBpZiAoZWxlbWVudC5oYXNBdXRvZm9j dXNlZCgpKQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICAvLyBGSVhNRTogU2hvdWxkIHRo aXMgc2V0IG9mIGhhc1RhZ05hbWUgY2hlY2tzIGJlIHJlcGxhY2VkIGJ5IGEKICAgICAvLyB2aXJ0 dWFsIG1lbWJlciBmdW5jdGlvbj8KLSAgICBpZiAoaXM8SFRNTElucHV0RWxlbWVudD4oKmVsZW1l bnQpKQotICAgICAgICByZXR1cm4gIWRvd25jYXN0PEhUTUxJbnB1dEVsZW1lbnQ+KCplbGVtZW50 KS5pc0lucHV0VHlwZUhpZGRlbigpOwotICAgIGlmIChlbGVtZW50LT5oYXNUYWdOYW1lKHNlbGVj dFRhZykpCisgICAgaWYgKGlzPEhUTUxJbnB1dEVsZW1lbnQ+KGVsZW1lbnQpKQorICAgICAgICBy ZXR1cm4gIWRvd25jYXN0PEhUTUxJbnB1dEVsZW1lbnQ+KGVsZW1lbnQpLmlzSW5wdXRUeXBlSGlk ZGVuKCk7CisgICAgaWYgKGVsZW1lbnQuaGFzVGFnTmFtZShzZWxlY3RUYWcpKQogICAgICAgICBy ZXR1cm4gdHJ1ZTsKLSAgICBpZiAoZWxlbWVudC0+aGFzVGFnTmFtZShrZXlnZW5UYWcpKQorICAg IGlmIChlbGVtZW50Lmhhc1RhZ05hbWUoa2V5Z2VuVGFnKSkKICAgICAgICAgcmV0dXJuIHRydWU7 Ci0gICAgaWYgKGVsZW1lbnQtPmhhc1RhZ05hbWUoYnV0dG9uVGFnKSkKKyAgICBpZiAoZWxlbWVu dC5oYXNUYWdOYW1lKGJ1dHRvblRhZykpCiAgICAgICAgIHJldHVybiB0cnVlOwotICAgIGlmIChp czxIVE1MVGV4dEFyZWFFbGVtZW50PigqZWxlbWVudCkpCisgICAgaWYgKGlzPEhUTUxUZXh0QXJl YUVsZW1lbnQ+KGVsZW1lbnQpKQogICAgICAgICByZXR1cm4gdHJ1ZTsKIAogICAgIHJldHVybiBm YWxzZTsKQEAgLTI0OCw3ICsyNDgsNyBAQCB2b2lkIEhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OmRp ZEF0dGFjaFJlbmRlcmVycygpCiAgICAgaWYgKHJlbmRlcmVyKCkpCiAgICAgICAgIHJlbmRlcmVy KCktPnVwZGF0ZUZyb21FbGVtZW50KCk7CiAKLSAgICBpZiAoc2hvdWxkQXV0b2ZvY3VzKHRoaXMp KSB7CisgICAgaWYgKHNob3VsZEF1dG9mb2N1cygqdGhpcykpIHsKICAgICAgICAgc2V0QXV0b2Zv Y3VzZWQoKTsKIAogICAgICAgICBSZWZQdHI8SFRNTEZvcm1Db250cm9sRWxlbWVudD4gZWxlbWVu dCA9IHRoaXM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJv bEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5o CmluZGV4IGNkZmE1YmQzMjRkZTBiOWI0YjYzYzVkNzk2OGFlODRlZjE3ZGNkMzEuLjI1ZTM0NTAw ZWFhYTYwYWNmZjk5NTRjNGZhYmUzNTc1NDVmZTI5MTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5oCkBAIC0xMTYsNyArMTE2LDcgQEAgcHVibGljOgog ICAgIGJvb2wgaXNSZWFkT25seSgpIGNvbnN0IHsgcmV0dXJuIG1faXNSZWFkT25seTsgfQogICAg IGJvb2wgaXNEaXNhYmxlZE9yUmVhZE9ubHkoKSBjb25zdCB7IHJldHVybiBpc0Rpc2FibGVkRm9y bUNvbnRyb2woKSB8fCBtX2lzUmVhZE9ubHk7IH0KIAotICAgIGJvb2wgaGFzQXV0b2ZvY3VzZWQo KSB7IHJldHVybiBtX2hhc0F1dG9mb2N1c2VkOyB9CisgICAgYm9vbCBoYXNBdXRvZm9jdXNlZCgp IGNvbnN0IHsgcmV0dXJuIG1faGFzQXV0b2ZvY3VzZWQ7IH0KICAgICB2b2lkIHNldEF1dG9mb2N1 c2VkKCkgeyBtX2hhc0F1dG9mb2N1c2VkID0gdHJ1ZTsgfQogCiAgICAgV0VCQ09SRV9FWFBPUlQg U3RyaW5nIGF1dG9jb21wbGV0ZSgpIGNvbnN0Owo=