103058 2012-11-22 05:10:25 -0800 It's confusing that return values of 'bool Node::dispatchEvent(...)' and 'bool Node::dispatchMouseEvent(..)' have the opposite meanings. 2013-01-29 00:38:02 -0800 1 1 1 Unclassified WebKit UI Events 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 hayato hayato ojan qinmin webkit.review.bot oldest_to_newest 773847 0 hayato 2012-11-22 05:10:25 -0800 Every return values from 'bool dispatchXXXEvent(...)' member functions should have the same meanings to avoid confusions. 773848 1 hayato 2012-11-22 05:11:11 -0800 I think we should use enum, or struct, as a return value, but that might be a goal in the long term. 773861 2 175653 hayato 2012-11-22 05:27:31 -0800 Created attachment 175653 Make them return the same meaning bool. 774823 3 175653 webkit.review.bot 2012-11-24 07:12:42 -0800 Comment on attachment 175653 Make them return the same meaning bool. Clearing flags on attachment: 175653 Committed r135650: <http://trac.webkit.org/changeset/135650> 774824 4 webkit.review.bot 2012-11-24 07:12:45 -0800 All reviewed patches have been landed. Closing bug. 817408 5 qinmin 2013-01-27 13:18:13 -0800 I am having a hard time understanding this patch and it doesn't look correct to me. after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. 817457 6 hayato 2013-01-27 18:22:19 -0800 Thank you for the comment. (In reply to comment #5) > I am having a hard time understanding this patch and it doesn't look correct to me. > > > after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. > > This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? > > What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? That was on my rader when I wrote this patch, but I gave up changing all at once. That requires a lot of changes. I don't know the historical reason, but dispatchXXXEvent and handleXXXEvent use bool as opposite meaning as far as I remember. This patch attacked only dispatchXXXEvent, without touching handleXXEvent. I think using 'bool' in both cases as a return value is the root cause of confusion. Actually I tried to introduce enum, but I was not confident whether using enum here is good or not since we have to change a lot of code. > > I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. Agreed. We have to resolve the current inconsistency usage of bool. That requires further patches. 817463 7 qinmin 2013-01-27 18:46:49 -0800 (In reply to comment #6) > Thank you for the comment. > > (In reply to comment #5) > > I am having a hard time understanding this patch and it doesn't look correct to me. > > > > > > after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. > > > > This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? > > > > What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? > > That was on my rader when I wrote this patch, but I gave up changing all at once. That requires a lot of changes. I don't know the historical reason, but dispatchXXXEvent and handleXXXEvent use bool as opposite meaning as far as I remember. This patch attacked only dispatchXXXEvent, without touching handleXXEvent. then we should not return !swallowevent in handlemousepressevent. that changes the previous behavior. > > I think using 'bool' in both cases as a return value is the root cause of confusion. Actually I tried to introduce enum, but I was not confident whether using enum here is good or not since we have to change a lot of code. > > > > > I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. > > Agreed. We have to resolve the current inconsistency usage of bool. That requires further patches. 817474 8 hayato 2013-01-27 19:27:19 -0800 (In reply to comment #7) > (In reply to comment #6) > > Thank you for the comment. > > > > (In reply to comment #5) > > > I am having a hard time understanding this patch and it doesn't look correct to me. > > > > > > > > > after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. > > > > > > This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? > > > > > > What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? > > > > That was on my rader when I wrote this patch, but I gave up changing all at once. That requires a lot of changes. I don't know the historical reason, but dispatchXXXEvent and handleXXXEvent use bool as opposite meaning as far as I remember. This patch attacked only dispatchXXXEvent, without touching handleXXEvent. > > > then we should not return !swallowevent in handlemousepressevent. that changes the previous behavior. I understand that. That might not be my intention. Let me investigate the current code base and codebase when this patch was landed further. In current code base, the only client which uses the return value of the EventHandler::handleMousePressed(const PlatformMouseEvent&) looks EventHandler::handleGensutureTap(). Is that right? > > > > > I think using 'bool' in both cases as a return value is the root cause of confusion. Actually I tried to introduce enum, but I was not confident whether using enum here is good or not since we have to change a lot of code. > > > > > > > > I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. > > > > Agreed. We have to resolve the current inconsistency usage of bool. That requires further patches. 817506 9 hayato 2013-01-27 21:27:32 -0800 I investigated. This change of line (!swallowEvent) in handleMousePressEvent seems unnecessary as you mentioned. The bad part is there isn't any test which catch that. Let me revert the line in another patch. I'll add a layout test too. Thank you for reporting. I missed that. (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #6) > > > Thank you for the comment. > > > > > > (In reply to comment #5) > > > > I am having a hard time understanding this patch and it doesn't look correct to me. > > > > > > > > > > > > after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. > > > > > > > > This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? > > > > > > > > What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? > > > > > > That was on my rader when I wrote this patch, but I gave up changing all at once. That requires a lot of changes. I don't know the historical reason, but dispatchXXXEvent and handleXXXEvent use bool as opposite meaning as far as I remember. This patch attacked only dispatchXXXEvent, without touching handleXXEvent. > > > > > > then we should not return !swallowevent in handlemousepressevent. that changes the previous behavior. > > I understand that. That might not be my intention. Let me investigate the current code base and codebase when this patch was landed further. > > In current code base, the only client which uses the return value of the EventHandler::handleMousePressed(const PlatformMouseEvent&) looks EventHandler::handleGensutureTap(). > Is that right? > > > > > > > > > > I think using 'bool' in both cases as a return value is the root cause of confusion. Actually I tried to introduce enum, but I was not confident whether using enum here is good or not since we have to change a lot of code. > > > > > > > > > > > I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. > > > > > > Agreed. We have to resolve the current inconsistency usage of bool. That requires further patches. 817507 10 175653 hayato 2013-01-27 21:32:10 -0800 Comment on attachment 175653 Make them return the same meaning bool. View in context: https://bugs.webkit.org/attachment.cgi?id=175653&action=review > Source/WebCore/page/EventHandler.cpp:1691 > + return !swallowEvent; I'll try to revert only this line. If you find any other things, please let me know. 817513 11 qinmin 2013-01-27 21:56:42 -0800 Thanks, this line should only affect HandleGestureTap() (In reply to comment #9) > I investigated. This change of line (!swallowEvent) in handleMousePressEvent seems unnecessary as you mentioned. > The bad part is there isn't any test which catch that. > > Let me revert the line in another patch. I'll add a layout test too. > > Thank you for reporting. I missed that. > > > (In reply to comment #8) > > (In reply to comment #7) > > > (In reply to comment #6) > > > > Thank you for the comment. > > > > > > > > (In reply to comment #5) > > > > > I am having a hard time understanding this patch and it doesn't look correct to me. > > > > > > > > > > > > > > > after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. > > > > > > > > > > This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? > > > > > > > > > > What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? > > > > > > > > That was on my rader when I wrote this patch, but I gave up changing all at once. That requires a lot of changes. I don't know the historical reason, but dispatchXXXEvent and handleXXXEvent use bool as opposite meaning as far as I remember. This patch attacked only dispatchXXXEvent, without touching handleXXEvent. > > > > > > > > > then we should not return !swallowevent in handlemousepressevent. that changes the previous behavior. > > > > I understand that. That might not be my intention. Let me investigate the current code base and codebase when this patch was landed further. > > > > In current code base, the only client which uses the return value of the EventHandler::handleMousePressed(const PlatformMouseEvent&) looks EventHandler::handleGensutureTap(). > > Is that right? > > > > > > > > > > > > > > > I think using 'bool' in both cases as a return value is the root cause of confusion. Actually I tried to introduce enum, but I was not confident whether using enum here is good or not since we have to change a lot of code. > > > > > > > > > > > > > > I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. > > > > > > > > Agreed. We have to resolve the current inconsistency usage of bool. That requires further patches. 817549 12 hayato 2013-01-27 23:41:25 -0800 Thank you. I've tried to add a Layout test so we can catch the regresson in the future, but I could not find how to detect it from the LayoutTest layer. I referred to LayoutTests/fast/events/touch/gesture/gesture-click.html, which hits EventHandler:handleGestureTap(), but I couldn't find any side effects caused by defaultPrevented value which is set in EventHandler:handleGestureTap. I guess you have some ideas. I appreciate your feedbacks. (In reply to comment #11) > Thanks, this line should only affect HandleGestureTap() > > (In reply to comment #9) > > I investigated. This change of line (!swallowEvent) in handleMousePressEvent seems unnecessary as you mentioned. > > The bad part is there isn't any test which catch that. > > > > Let me revert the line in another patch. I'll add a layout test too. > > > > Thank you for reporting. I missed that. > > > > > > (In reply to comment #8) > > > (In reply to comment #7) > > > > (In reply to comment #6) > > > > > Thank you for the comment. > > > > > > > > > > (In reply to comment #5) > > > > > > I am having a hard time understanding this patch and it doesn't look correct to me. > > > > > > > > > > > > > > > > > > after this patch, MouseEventDispatchMediator::dispatchEvent will return a true instead of false in case the event was not canceled. I am ok with that, but better add some comments in the header to indicate that. > > > > > > > > > > > > This patch also tries to change the return value of EventHandler::dispatchMouseEvent(). However, this doesn't seem to cover all the paths in which swallowEvent is changed. For example, in some code paths there is swallowEvent = true and that is not changed. However, this patch will return !swallowEvent instead, isn't that changing the behavior of those cases? > > > > > > > > > > > > What confuses me most is handleMousePressEvent(). Why we change the return value to be !swallowEvent? What should be the return value of handleMousePressEvent()? Can you add a comment in the header? If this is to indicate whether the event was canceled or not, why not change the return value of handleMouseReleaseEvent? > > > > > > > > > > That was on my rader when I wrote this patch, but I gave up changing all at once. That requires a lot of changes. I don't know the historical reason, but dispatchXXXEvent and handleXXXEvent use bool as opposite meaning as far as I remember. This patch attacked only dispatchXXXEvent, without touching handleXXEvent. > > > > > > > > > > > > then we should not return !swallowevent in handlemousepressevent. that changes the previous behavior. > > > > > > I understand that. That might not be my intention. Let me investigate the current code base and codebase when this patch was landed further. > > > > > > In current code base, the only client which uses the return value of the EventHandler::handleMousePressed(const PlatformMouseEvent&) looks EventHandler::handleGensutureTap(). > > > Is that right? > > > > > > > > > > > > > > > > > > > > I think using 'bool' in both cases as a return value is the root cause of confusion. Actually I tried to introduce enum, but I was not confident whether using enum here is good or not since we have to change a lot of code. > > > > > > > > > > > > > > > > > I think we need some documentation in eventhandler. And we definitely need some test here to see what is being changed and whether that is correct. > > > > > > > > > > Agreed. We have to resolve the current inconsistency usage of bool. That requires further patches. 817735 13 qinmin 2013-01-28 07:27:14 -0800 probably in webkit_unittests should be fine 818666 14 hayato 2013-01-29 00:38:02 -0800 Thank you for suggestion. I've never used webkit_unittests. I'd like to avoid using webkit_unittests here since this is rather a web facing feature and should be tested by LayoutTest for all ports. Let me file another bug until we can find a way to test that. (In reply to comment #13) > probably in webkit_unittests should be fine 175653 2012-11-22 05:27:31 -0800 2013-01-27 21:32:10 -0800 Make them return the same meaning bool. bug-103058-20121122222516.patch text/plain 10657 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTM1MzM5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzg5NzhjMmZiNjkyZmM3 MmNlNmI4NDIzMTNmMTIyMTAzYzMzYzgzOC4uZWFhYTAwYjRjMzFhYWI3MDQ1MmVkZDExMWU1NzQw NDFmODQ1YTQ3ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisyMDEyLTExLTIyICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBJdCdzIGNvbmZ1c2luZyB0 aGF0IHJldHVybiB2YWx1ZXMgb2YgJ2Jvb2wgTm9kZTo6ZGlzcGF0Y2hFdmVudCguLi4pJyBhbmQg J2Jvb2wgTm9kZTo6ZGlzcGF0Y2hNb3VzZUV2ZW50KC4uKScgaGF2ZSB0aGUgb3Bwb3NpdGUgbWVh bmluZ3MuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MDMwNTgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBS ZWZhY3RvciBNb3VzZUV2ZW50RGlzcGF0Y2hNZWRpYXRvcjo6ZGlzcGF0Y2hFdmVudCgpIGFuZAor ICAgICAgICBFdmVudEhhbmRsZXI6OmRpc3BhdGNoTW91c2VFdmVudCgpIHNvIHRoYXQgdGhleSBy ZXR1cm4gYm9vbAorICAgICAgICB3aGljaCBoYXMgdGhlIHNhbWUgbWVhbmluZyBvZiB0aGUgcmV0 dXJuIHZhbHVlIG9mCisgICAgICAgIE5vZGU6OmRpc3BhdGNoRXZlbnQoKS4KKworICAgICAgICBO byB0ZXN0cy4gTm8gY2hhbmdlIGluIGJlaGF2aW9yLgorCisgICAgICAgICogZG9tL01vdXNlRXZl bnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6TW91c2VFdmVudERpc3BhdGNoTWVkaWF0b3I6OmRp c3BhdGNoRXZlbnQpOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50KToKKyAgICAgICAg KFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VEb3VibGVDbGlja0V2ZW50KToKKyAg ICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VNb3ZlRXZlbnQpOgorICAg ICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZVJlbGVhc2VFdmVudCk6Cisg ICAgICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OmRpc3BhdGNoTW91c2VFdmVudCk6CisgICAg ICAgIChXZWJDb3JlOjpFdmVudEhhbmRsZXI6OnNlbmRDb250ZXh0TWVudUV2ZW50KToKKyAgICAg ICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6c2VuZENvbnRleHRNZW51RXZlbnRGb3JLZXkpOgor CiAyMDEyLTExLTIwICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAgICAgICAg NyUgcmVncmVzc2lvbiBpbiBkcm9tYWVvX2RvbWNvcmVxdWVyeS9kb21fcXVlcnlfZ2V0RWxlbWVu dHNCeVRhZ05hbWVfX25vdF9pbl9kb2N1bWVudApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZG9tL01vdXNlRXZlbnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL01vdXNlRXZlbnQuY3BwCmlu ZGV4IDllOTJjMjcxMzZjY2Y5MGRiZTNiN2IyNjBiNWJiNjdhZWE0NDU2YWIuLmRkZTE5MzYxNWMx YjQxNTc1NTJmNzYzOTk3OTFlNTMwMTJjZDVhZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2RvbS9Nb3VzZUV2ZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vTW91c2VFdmVudC5j cHAKQEAgLTIyNywxMCArMjI3LDEwIEBAIE1vdXNlRXZlbnQqIE1vdXNlRXZlbnREaXNwYXRjaE1l ZGlhdG9yOjpldmVudCgpIGNvbnN0CiBib29sIE1vdXNlRXZlbnREaXNwYXRjaE1lZGlhdG9yOjpk aXNwYXRjaEV2ZW50KEV2ZW50RGlzcGF0Y2hlciogZGlzcGF0Y2hlcikgY29uc3QKIHsKICAgICBp ZiAoZGlzcGF0Y2hlci0+bm9kZSgpLT5kaXNhYmxlZCgpKSAvLyBEb24ndCBldmVuIHNlbmQgRE9N IGV2ZW50cyBmb3IgZGlzYWJsZWQgY29udHJvbHMuLgotICAgICAgICByZXR1cm4gdHJ1ZTsKKyAg ICAgICAgcmV0dXJuIGZhbHNlOwogCiAgICAgaWYgKGV2ZW50KCktPnR5cGUoKS5pc0VtcHR5KCkp Ci0gICAgICAgIHJldHVybiBmYWxzZTsgLy8gU2hvdWxkbid0IGhhcHBlbi4KKyAgICAgICAgcmV0 dXJuIHRydWU7IC8vIFNob3VsZG4ndCBoYXBwZW4uCiAKICAgICBFdmVudFRhcmdldCogcmVsYXRl ZFRhcmdldCA9IGV2ZW50KCktPnJlbGF0ZWRUYXJnZXQoKTsKICAgICBkaXNwYXRjaGVyLT5hZGp1 c3RSZWxhdGVkVGFyZ2V0KGV2ZW50KCksIHJlbGF0ZWRUYXJnZXQpOwpAQCAtMjM5LDcgKzIzOSw3 IEBAIGJvb2wgTW91c2VFdmVudERpc3BhdGNoTWVkaWF0b3I6OmRpc3BhdGNoRXZlbnQoRXZlbnRE aXNwYXRjaGVyKiBkaXNwYXRjaGVyKSBjb25zCiAgICAgYm9vbCBzd2FsbG93RXZlbnQgPSBldmVu dCgpLT5kZWZhdWx0SGFuZGxlZCgpIHx8IGV2ZW50KCktPmRlZmF1bHRQcmV2ZW50ZWQoKTsKIAog ICAgIGlmIChldmVudCgpLT50eXBlKCkgIT0gZXZlbnROYW1lcygpLmNsaWNrRXZlbnQgfHwgZXZl bnQoKS0+ZGV0YWlsKCkgIT0gMikKLSAgICAgICAgcmV0dXJuIHN3YWxsb3dFdmVudDsKKyAgICAg ICAgcmV0dXJuICFzd2FsbG93RXZlbnQ7CiAgICAgLy8gU3BlY2lhbCBjYXNlOiBJZiBpdCdzIGEg ZG91YmxlIGNsaWNrIGV2ZW50LCB3ZSBhbHNvIHNlbmQgdGhlIGRibGNsaWNrIGV2ZW50LiBUaGlz IGlzIG5vdCBwYXJ0CiAgICAgLy8gb2YgdGhlIERPTSBzcGVjcywgYnV0IGlzIHVzZWQgZm9yIGNv bXBhdGliaWxpdHkgd2l0aCB0aGUgb25kYmxjbGljaz0iIiBhdHRyaWJ1dGUuIFRoaXMgaXMgdHJl YXRlZAogICAgIC8vIGFzIGEgc2VwYXJhdGUgZXZlbnQgaW4gb3RoZXIgRE9NLWNvbXBsaWFudCBi cm93c2VycyBsaWtlIEZpcmVmb3gsIGFuZCBzbyB3ZSBkbyB0aGUgc2FtZS4KQEAgLTI1Miw4ICsy NTIsOCBAQCBib29sIE1vdXNlRXZlbnREaXNwYXRjaE1lZGlhdG9yOjpkaXNwYXRjaEV2ZW50KEV2 ZW50RGlzcGF0Y2hlciogZGlzcGF0Y2hlcikgY29ucwogICAgICAgICBkb3VibGVDbGlja0V2ZW50 LT5zZXREZWZhdWx0SGFuZGxlZCgpOwogICAgIEV2ZW50RGlzcGF0Y2hlcjo6ZGlzcGF0Y2hFdmVu dChkaXNwYXRjaGVyLT5ub2RlKCksIE1vdXNlRXZlbnREaXNwYXRjaE1lZGlhdG9yOjpjcmVhdGUo ZG91YmxlQ2xpY2tFdmVudCkpOwogICAgIGlmIChkb3VibGVDbGlja0V2ZW50LT5kZWZhdWx0SGFu ZGxlZCgpIHx8IGRvdWJsZUNsaWNrRXZlbnQtPmRlZmF1bHRQcmV2ZW50ZWQoKSkKLSAgICAgICAg cmV0dXJuIHRydWU7Ci0gICAgcmV0dXJuIHN3YWxsb3dFdmVudDsKKyAgICAgICAgcmV0dXJuIGZh bHNlOworICAgIHJldHVybiAhc3dhbGxvd0V2ZW50OwogfQogCiB9IC8vIG5hbWVzcGFjZSBXZWJD b3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggM2E3NzM5ZmJlMmE4NDNh ZmYyNmU3ODlmNzU0YjNmODcyMzRkOGFiNC4uMzMxNTIwODAyYzYwODM3NThiYmM2M2Y4MWYyNDdj YzFiZTJhNGQyNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtMTY0NCw3 ICsxNjQ0LDcgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUHJlc3NFdmVudChjb25z dCBQbGF0Zm9ybU1vdXNlRXZlbnQmIG1vdXNlRXZlbnQpCiAKICAgICBtX2ZyYW1lLT5zZWxlY3Rp b24oKS0+c2V0Q2FyZXRCbGlua2luZ1N1c3BlbmRlZCh0cnVlKTsKIAotICAgIGJvb2wgc3dhbGxv d0V2ZW50ID0gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5tb3VzZWRvd25FdmVudCwg bWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCB0cnVlKTsK KyAgICBib29sIHN3YWxsb3dFdmVudCA9ICFkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygp Lm1vdXNlZG93bkV2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1v dXNlRXZlbnQsIHRydWUpOwogICAgIG1fY2FwdHVyZXNEcmFnZ2luZyA9ICFzd2FsbG93RXZlbnQg fHwgbWV2LnNjcm9sbGJhcigpOwogCiAgICAgLy8gSWYgdGhlIGhpdCB0ZXN0aW5nIG9yaWdpbmFs bHkgZGV0ZXJtaW5lZCB0aGUgZXZlbnQgd2FzIGluIGEgc2Nyb2xsYmFyLCByZWZldGNoIHRoZSBN b3VzZUV2ZW50V2l0aEhpdFRlc3RSZXN1bHRzCkBAIC0xNjg4LDcgKzE2ODgsNyBAQCBib29sIEV2 ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VQcmVzc0V2ZW50KGNvbnN0IFBsYXRmb3JtTW91c2VFdmVu dCYgbW91c2VFdmVudCkKICAgICAgICAgICAgIHN3YWxsb3dFdmVudCA9IGhhbmRsZU1vdXNlUHJl c3NFdmVudChtZXYpOwogICAgIH0KIAotICAgIHJldHVybiBzd2FsbG93RXZlbnQ7CisgICAgcmV0 dXJuICFzd2FsbG93RXZlbnQ7CiB9CiAKIC8vIFRoaXMgbWV0aG9kIG9ubHkgZXhpc3RzIGZvciBw bGF0Zm9ybXMgdGhhdCBkb24ndCBrbm93IGhvdyB0byBkZWxpdmVyIApAQCAtMTcxMiw5ICsxNzEy LDkgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlRG91YmxlQ2xpY2tFdmVudChjb25z dCBQbGF0Zm9ybU1vdXNlRXZlbnQmIG1vdXNlRXYKICAgICAgICAgcmV0dXJuIHRydWU7CiAKICAg ICBtX2NsaWNrQ291bnQgPSBtb3VzZUV2ZW50LmNsaWNrQ291bnQoKTsKLSAgICBib29sIHN3YWxs b3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBF dmVudCwgbWV2LnRhcmdldE5vZGUoKSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBm YWxzZSk7CisgICAgYm9vbCBzd2FsbG93TW91c2VVcEV2ZW50ID0gIWRpc3BhdGNoTW91c2VFdmVu dChldmVudE5hbWVzKCkubW91c2V1cEV2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2Ns aWNrQ291bnQsIG1vdXNlRXZlbnQsIGZhbHNlKTsKIAotICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZl bnQgPSBtb3VzZUV2ZW50LmJ1dHRvbigpICE9IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJnZXROb2Rl KCkgPT0gbV9jbGlja05vZGUgJiYgZGlzcGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlj a0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQs IHRydWUpOworICAgIGJvb2wgc3dhbGxvd0NsaWNrRXZlbnQgPSBtb3VzZUV2ZW50LmJ1dHRvbigp ICE9IFJpZ2h0QnV0dG9uICYmIG1ldi50YXJnZXROb2RlKCkgPT0gbV9jbGlja05vZGUgJiYgIWRp c3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkuY2xpY2tFdmVudCwgbWV2LnRhcmdldE5vZGUo KSwgdHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCB0cnVlKTsKIAogICAgIGlmIChtX2xh c3RTY3JvbGxiYXJVbmRlck1vdXNlKQogICAgICAgICBzd2FsbG93TW91c2VVcEV2ZW50ID0gbV9s YXN0U2Nyb2xsYmFyVW5kZXJNb3VzZS0+bW91c2VVcChtb3VzZUV2ZW50KTsKQEAgLTE4MTEsNyAr MTgxMSw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpoYW5kbGVNb3VzZU1vdmVFdmVudChjb25zdCBQ bGF0Zm9ybU1vdXNlRXZlbnQmIG1vdXNlRXZlbnQsIEhpCiAjZW5kaWYKIAogICAgIGlmIChtX2Zy YW1lU2V0QmVpbmdSZXNpemVkKQotICAgICAgICByZXR1cm4gZGlzcGF0Y2hNb3VzZUV2ZW50KGV2 ZW50TmFtZXMoKS5tb3VzZW1vdmVFdmVudCwgbV9mcmFtZVNldEJlaW5nUmVzaXplZC5nZXQoKSwg ZmFsc2UsIDAsIG1vdXNlRXZlbnQsIGZhbHNlKTsKKyAgICAgICAgcmV0dXJuICFkaXNwYXRjaE1v dXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNlbW92ZUV2ZW50LCBtX2ZyYW1lU2V0QmVpbmdSZXNp emVkLmdldCgpLCBmYWxzZSwgMCwgbW91c2VFdmVudCwgZmFsc2UpOwogCiAgICAgLy8gU2VuZCBl dmVudHMgcmlnaHQgdG8gYSBzY3JvbGxiYXIgaWYgdGhlIG1vdXNlIGlzIHByZXNzZWQuCiAgICAg aWYgKG1fbGFzdFNjcm9sbGJhclVuZGVyTW91c2UgJiYgbV9tb3VzZVByZXNzZWQpCkBAIC0xODg2 LDcgKzE4ODYsNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlTW91c2VNb3ZlRXZlbnQoY29u c3QgUGxhdGZvcm1Nb3VzZUV2ZW50JiBtb3VzZUV2ZW50LCBIaQogICAgIGlmIChzd2FsbG93RXZl bnQpCiAgICAgICAgIHJldHVybiB0cnVlOwogICAgIAotICAgIHN3YWxsb3dFdmVudCA9IGRpc3Bh dGNoTW91c2VFdmVudChldmVudE5hbWVzKCkubW91c2Vtb3ZlRXZlbnQsIG1ldi50YXJnZXROb2Rl KCksIGZhbHNlLCAwLCBtb3VzZUV2ZW50LCB0cnVlKTsKKyAgICBzd2FsbG93RXZlbnQgPSAhZGlz cGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5tb3VzZW1vdmVFdmVudCwgbWV2LnRhcmdldE5v ZGUoKSwgZmFsc2UsIDAsIG1vdXNlRXZlbnQsIHRydWUpOwogI2lmIEVOQUJMRShEUkFHX1NVUFBP UlQpCiAgICAgaWYgKCFzd2FsbG93RXZlbnQpCiAgICAgICAgIHN3YWxsb3dFdmVudCA9IGhhbmRs ZU1vdXNlRHJhZ2dlZEV2ZW50KG1ldik7CkBAIC0xOTMzLDcgKzE5MzMsNyBAQCBib29sIEV2ZW50 SGFuZGxlcjo6aGFuZGxlTW91c2VSZWxlYXNlRXZlbnQoY29uc3QgUGxhdGZvcm1Nb3VzZUV2ZW50 JiBtb3VzZUV2ZW50KQogI2VuZGlmCiAKICAgICBpZiAobV9mcmFtZVNldEJlaW5nUmVzaXplZCkK LSAgICAgICAgcmV0dXJuIGRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkubW91c2V1cEV2 ZW50LCBtX2ZyYW1lU2V0QmVpbmdSZXNpemVkLmdldCgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1v dXNlRXZlbnQsIGZhbHNlKTsKKyAgICAgICAgcmV0dXJuICFkaXNwYXRjaE1vdXNlRXZlbnQoZXZl bnROYW1lcygpLm1vdXNldXBFdmVudCwgbV9mcmFtZVNldEJlaW5nUmVzaXplZC5nZXQoKSwgdHJ1 ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiAKICAgICBpZiAobV9sYXN0U2Ny b2xsYmFyVW5kZXJNb3VzZSkgewogICAgICAgICBpbnZhbGlkYXRlQ2xpY2soKTsKQEAgLTE5NDgs MTQgKzE5NDgsMTQgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmhhbmRsZU1vdXNlUmVsZWFzZUV2ZW50 KGNvbnN0IFBsYXRmb3JtTW91c2VFdmVudCYgbW91c2VFdmVudCkKICAgICBpZiAoc3ViZnJhbWUg JiYgcGFzc01vdXNlUmVsZWFzZUV2ZW50VG9TdWJmcmFtZShtZXYsIHN1YmZyYW1lKSkKICAgICAg ICAgcmV0dXJuIHRydWU7CiAKLSAgICBib29sIHN3YWxsb3dNb3VzZVVwRXZlbnQgPSBkaXNwYXRj aE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLm1vdXNldXBFdmVudCwgbWV2LnRhcmdldE5vZGUoKSwg dHJ1ZSwgbV9jbGlja0NvdW50LCBtb3VzZUV2ZW50LCBmYWxzZSk7CisgICAgYm9vbCBzd2FsbG93 TW91c2VVcEV2ZW50ID0gIWRpc3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkubW91c2V1cEV2 ZW50LCBtZXYudGFyZ2V0Tm9kZSgpLCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIGZh bHNlKTsKIAogICAgIE5vZGUqIGNsaWNrVGFyZ2V0ID0gbWV2LnRhcmdldE5vZGUoKTsKICAgICBp ZiAoY2xpY2tUYXJnZXQpCiAgICAgICAgIGNsaWNrVGFyZ2V0ID0gY2xpY2tUYXJnZXQtPnNoYWRv d0FuY2VzdG9yTm9kZSgpOwogICAgIE5vZGUqIGFkanVzdGVkQ2xpY2tOb2RlID0gbV9jbGlja05v ZGUgPyBtX2NsaWNrTm9kZS0+c2hhZG93QW5jZXN0b3JOb2RlKCkgOiAwOwogCi0gICAgYm9vbCBz d2FsbG93Q2xpY2tFdmVudCA9IG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVudC5idXR0b24o KSAhPSBSaWdodEJ1dHRvbiAmJiBjbGlja1RhcmdldCA9PSBhZGp1c3RlZENsaWNrTm9kZSAmJiBk aXNwYXRjaE1vdXNlRXZlbnQoZXZlbnROYW1lcygpLmNsaWNrRXZlbnQsIG1ldi50YXJnZXROb2Rl KCksIHRydWUsIG1fY2xpY2tDb3VudCwgbW91c2VFdmVudCwgdHJ1ZSk7CisgICAgYm9vbCBzd2Fs bG93Q2xpY2tFdmVudCA9IG1fY2xpY2tDb3VudCA+IDAgJiYgbW91c2VFdmVudC5idXR0b24oKSAh PSBSaWdodEJ1dHRvbiAmJiBjbGlja1RhcmdldCA9PSBhZGp1c3RlZENsaWNrTm9kZSAmJiAhZGlz cGF0Y2hNb3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50LCBtZXYudGFyZ2V0Tm9kZSgp LCB0cnVlLCBtX2NsaWNrQ291bnQsIG1vdXNlRXZlbnQsIHRydWUpOwogCiAgICAgaWYgKG1fcmVz aXplTGF5ZXIpIHsKICAgICAgICAgbV9yZXNpemVMYXllci0+c2V0SW5SZXNpemVNb2RlKGZhbHNl KTsKQEAgLTIzNDAsMTQgKzIzNDAsMTQgQEAgYm9vbCBFdmVudEhhbmRsZXI6OmRpc3BhdGNoTW91 c2VFdmVudChjb25zdCBBdG9taWNTdHJpbmcmIGV2ZW50VHlwZSwgTm9kZSogdGFyZ2UKICAgICBi b29sIHN3YWxsb3dFdmVudCA9IGZhbHNlOwogCiAgICAgaWYgKG1fbm9kZVVuZGVyTW91c2UpCi0g ICAgICAgIHN3YWxsb3dFdmVudCA9IG1fbm9kZVVuZGVyTW91c2UtPmRpc3BhdGNoTW91c2VFdmVu dChtb3VzZUV2ZW50LCBldmVudFR5cGUsIGNsaWNrQ291bnQpOworICAgICAgICBzd2FsbG93RXZl bnQgPSAhKG1fbm9kZVVuZGVyTW91c2UtPmRpc3BhdGNoTW91c2VFdmVudChtb3VzZUV2ZW50LCBl dmVudFR5cGUsIGNsaWNrQ291bnQpKTsKIAogICAgIGlmICghc3dhbGxvd0V2ZW50ICYmIGV2ZW50 VHlwZSA9PSBldmVudE5hbWVzKCkubW91c2Vkb3duRXZlbnQpIHsKIAogICAgICAgICAvLyBJZiBj bGlja2luZyBvbiBhIGZyYW1lIHNjcm9sbGJhciwgZG8gbm90IG1lc3MgdXAgd2l0aCBjb250ZW50 IGZvY3VzLgogICAgICAgICBpZiAoRnJhbWVWaWV3KiB2aWV3ID0gbV9mcmFtZS0+dmlldygpKSB7 CiAgICAgICAgICAgICBpZiAodmlldy0+c2Nyb2xsYmFyQXRQb2ludChtb3VzZUV2ZW50LnBvc2l0 aW9uKCkpKQotICAgICAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgICAgICAgICBy ZXR1cm4gdHJ1ZTsKICAgICAgICAgfQogCiAgICAgICAgIC8vIFRoZSBsYXlvdXQgbmVlZHMgdG8g YmUgdXAgdG8gZGF0ZSB0byBkZXRlcm1pbmUgaWYgYW4gZWxlbWVudCBpcyBmb2N1c2FibGUuCkBA IC0yMzcwLDcgKzIzNzAsNyBAQCBib29sIEV2ZW50SGFuZGxlcjo6ZGlzcGF0Y2hNb3VzZUV2ZW50 KGNvbnN0IEF0b21pY1N0cmluZyYgZXZlbnRUeXBlLCBOb2RlKiB0YXJnZQogICAgICAgICAgICAg ICAgIGlmIChtX2ZyYW1lLT5zZWxlY3Rpb24oKS0+aXNSYW5nZSgpCiAgICAgICAgICAgICAgICAg ICAgICYmIG1fZnJhbWUtPnNlbGVjdGlvbigpLT50b05vcm1hbGl6ZWRSYW5nZSgpLT5jb21wYXJl Tm9kZShuLCBlYykgPT0gUmFuZ2U6Ok5PREVfSU5TSURFCiAgICAgICAgICAgICAgICAgICAgICYm IG4tPmlzRGVzY2VuZGFudE9mKG1fZnJhbWUtPmRvY3VtZW50KCktPmZvY3VzZWROb2RlKCkpKQot ICAgICAgICAgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgICAgICAgICAgICAgIHJl dHVybiB0cnVlOwogICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICBicmVhazsK ICAgICAgICAgICAgIH0KQEAgLTIzOTAsNyArMjM5MCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpk aXNwYXRjaE1vdXNlRXZlbnQoY29uc3QgQXRvbWljU3RyaW5nJiBldmVudFR5cGUsIE5vZGUqIHRh cmdlCiAgICAgICAgIH0KICAgICB9CiAKLSAgICByZXR1cm4gc3dhbGxvd0V2ZW50OworICAgIHJl dHVybiAhc3dhbGxvd0V2ZW50OwogfQogCiAjaWYgIVBMQVRGT1JNKEdUSykgJiYgIShQTEFURk9S TShDSFJPTUlVTSkgJiYgKE9TKFVOSVgpICYmICFPUyhEQVJXSU4pKSkKQEAgLTI3ODQsNyArMjc4 NCw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpzZW5kQ29udGV4dE1lbnVFdmVudChjb25zdCBQbGF0 Zm9ybU1vdXNlRXZlbnQmIGV2ZW50KQogICAgICAgICBzZWxlY3RDbG9zZXN0V29yZE9yTGlua0Zy b21Nb3VzZUV2ZW50KG1ldik7CiAgICAgfQogCi0gICAgc3dhbGxvd0V2ZW50ID0gZGlzcGF0Y2hN b3VzZUV2ZW50KGV2ZW50TmFtZXMoKS5jb250ZXh0bWVudUV2ZW50LCBtZXYudGFyZ2V0Tm9kZSgp LCB0cnVlLCAwLCBldmVudCwgZmFsc2UpOworICAgIHN3YWxsb3dFdmVudCA9ICFkaXNwYXRjaE1v dXNlRXZlbnQoZXZlbnROYW1lcygpLmNvbnRleHRtZW51RXZlbnQsIG1ldi50YXJnZXROb2RlKCks IHRydWUsIDAsIGV2ZW50LCBmYWxzZSk7CiAgICAgCiAgICAgcmV0dXJuIHN3YWxsb3dFdmVudDsK IH0KQEAgLTI4NTksNyArMjg1OSw3IEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpzZW5kQ29udGV4dE1l bnVFdmVudEZvcktleSgpCiAKICAgICBQbGF0Zm9ybU1vdXNlRXZlbnQgbW91c2VFdmVudChwb3Np dGlvbiwgZ2xvYmFsUG9zaXRpb24sIFJpZ2h0QnV0dG9uLCBldmVudFR5cGUsIDEsIGZhbHNlLCBm YWxzZSwgZmFsc2UsIGZhbHNlLCBXVEY6OmN1cnJlbnRUaW1lKCkpOwogCi0gICAgcmV0dXJuIGRp c3BhdGNoTW91c2VFdmVudChldmVudE5hbWVzKCkuY29udGV4dG1lbnVFdmVudCwgdGFyZ2V0Tm9k ZSwgdHJ1ZSwgMCwgbW91c2VFdmVudCwgZmFsc2UpOworICAgIHJldHVybiAhZGlzcGF0Y2hNb3Vz ZUV2ZW50KGV2ZW50TmFtZXMoKS5jb250ZXh0bWVudUV2ZW50LCB0YXJnZXROb2RlLCB0cnVlLCAw LCBtb3VzZUV2ZW50LCBmYWxzZSk7CiB9CiAKICNpZiBFTkFCTEUoR0VTVFVSRV9FVkVOVFMpCg==