200126 2019-07-25 09:07:40 -0700 Avoid UIProcess hangs due to the WebContent process being stuck on a sync XHR 2019-07-26 10:07:36 -0700 1 1 1 Unclassified WebKit WebKit2 WebKit Nightly Build Unspecified Unspecified RESOLVED DUPLICATE 200138 https://bugs.webkit.org/show_bug.cgi?id=200138 InRadar P2 Normal --- 200107 1 cdumez cdumez beidson dbates ews-watchlist ggaren japhet simon.fraser thorton webkit-bug-importer wenson_hsieh oldest_to_newest 1555801 0 cdumez 2019-07-25 09:07:40 -0700 Avoid UIProcess hangs due to the WebContent process being stuck on a sync XHR. 1555802 1 cdumez 2019-07-25 09:08:03 -0700 <rdar://problem/52698157> 1555803 2 374891 cdumez 2019-07-25 09:14:37 -0700 Created attachment 374891 Patch 1555867 3 374891 simon.fraser 2019-07-25 12:40:09 -0700 Comment on attachment 374891 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=374891&action=review > Source/WebKit/ChangeLog:14 > + to process touch event-related sync IPC from the UIProcess, which will avoid > + UIProcess hangs. Doesn't that risk re-entering JavaScript and WebCore code? 1555868 4 cdumez 2019-07-25 12:42:38 -0700 (In reply to Simon Fraser (smfr) from comment #3) > Comment on attachment 374891 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=374891&action=review > > > Source/WebKit/ChangeLog:14 > > + to process touch event-related sync IPC from the UIProcess, which will avoid > > + UIProcess hangs. > > Doesn't that risk re-entering JavaScript and WebCore code? Well yes, this is the trade-off here. That said, such re-entrancy was already possible before I changed our behavior in Oct 2018. 1555870 5 374891 beidson 2019-07-25 12:46:06 -0700 Comment on attachment 374891 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=374891&action=review > Source/WebCore/xml/XMLHttpRequest.cpp:648 > + // This call may re-enter WebCore. Why is it okay to reintroduce this? I made comments in the radar that seem to be ignored in this patch. 1555871 6 374891 beidson 2019-07-25 12:47:40 -0700 Comment on attachment 374891 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=374891&action=review >> Source/WebCore/xml/XMLHttpRequest.cpp:648 >> + // This call may re-enter WebCore. > > Why is it okay to reintroduce this? > > I made comments in the radar that seem to be ignored in this patch. Maybe that's too broad of a statement, but this is a huge hammer that says "always respond to all messages" whereas I was envisioning "look at the specific messages that hang and target ways to mitigate just them." 1555872 7 cdumez 2019-07-25 12:53:07 -0700 (In reply to Brady Eidson from comment #5) > Comment on attachment 374891 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=374891&action=review > > > Source/WebCore/xml/XMLHttpRequest.cpp:648 > > + // This call may re-enter WebCore. > > Why is it okay to reintroduce this? Well, the belief is that it is OK as long as we're in the middle of running script and we make sure not to make assumptions about our state right after returning from the sync IPC. In any case, this is the change that was requested from me to address the hangs in the short-term. I'll let Geoff comment more on this if necessary. > > I made comments in the radar that seem to be ignored in this patch. The patch does prevent UI-Process hangs, which seems to be what your comment was about? If somebody has a better concrete idea, I am happy to consider but we do not have a lot of time to address those hangs. 1555874 8 cdumez 2019-07-25 12:55:34 -0700 (In reply to Brady Eidson from comment #6) > Comment on attachment 374891 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=374891&action=review > > >> Source/WebCore/xml/XMLHttpRequest.cpp:648 > >> + // This call may re-enter WebCore. > > > > Why is it okay to reintroduce this? > > > > I made comments in the radar that seem to be ignored in this patch. > > Maybe that's too broad of a statement, but this is a huge hammer that says > "always respond to all messages" whereas I was envisioning "look at the > specific messages that hang and target ways to mitigate just them." I only process incoming *synchronous* messages, aren't those by definition the ones that hang? Or do you want to target specifically the couple of touch-event related ones? It is in theory feasible but in practice it won't look nice to check for specific message names. Also, why only those messages? Those are not any less risky, they end up running script and thus can do anything to WebCore. 1555877 9 cdumez 2019-07-25 13:11:40 -0700 (In reply to Chris Dumez from comment #8) > (In reply to Brady Eidson from comment #6) > > Comment on attachment 374891 [details] > > Patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=374891&action=review > > > > >> Source/WebCore/xml/XMLHttpRequest.cpp:648 > > >> + // This call may re-enter WebCore. > > > > > > Why is it okay to reintroduce this? > > > > > > I made comments in the radar that seem to be ignored in this patch. > > > > Maybe that's too broad of a statement, but this is a huge hammer that says > > "always respond to all messages" whereas I was envisioning "look at the > > specific messages that hang and target ways to mitigate just them." > > I only process incoming *synchronous* messages, aren't those by definition > the ones that hang? Or do you want to target specifically the couple of > touch-event related ones? It is in theory feasible but in practice it won't > look nice to check for specific message names. Also, why only those > messages? Those are not any less risky, they end up running script and thus > can do anything to WebCore. I guess one viable alternative I can think of is add a IPC::SendSyncOption::CancelIfDestinationIsSendingSyncIPC flag on the 2 touch-related IPCs from the UIProcess, and somehow manage to cancel them on the WebContent process side (without running any script or changing any state), if the WebContent process is currently sending a sync IPC. I am not sure yet how easy this would be to implement, but this would potentially be safer. I am unsure how bad it would be for those 2 touch-related IPCs to get cancelled whenever the WebContent process is busy. This might lead to missed touches for examples. 1555902 10 beidson 2019-07-25 14:52:14 -0700 (In reply to Chris Dumez from comment #9) > (In reply to Chris Dumez from comment #8) > > (In reply to Brady Eidson from comment #6) > > > Comment on attachment 374891 [details] > > > Patch > > > > > > View in context: > > > https://bugs.webkit.org/attachment.cgi?id=374891&action=review > > > > > > >> Source/WebCore/xml/XMLHttpRequest.cpp:648 > > > >> + // This call may re-enter WebCore. > > > > > > > > Why is it okay to reintroduce this? > > > > > > > > I made comments in the radar that seem to be ignored in this patch. > > > > > > Maybe that's too broad of a statement, but this is a huge hammer that says > > > "always respond to all messages" whereas I was envisioning "look at the > > > specific messages that hang and target ways to mitigate just them." > > > > I only process incoming *synchronous* messages, aren't those by definition > > the ones that hang? But *all* incoming sync messages hang > > Or do you want to target specifically the couple of > > touch-event related ones? It is in theory feasible but in practice it won't > > look nice to check for specific message names. Also, why only those > > messages? Those are not any less risky, they end up running script and thus > > can do anything to WebCore. There's two sides where you can tackle this: 1 - Have the WebProcess side respond to these messages 2 - Have the UIProcess side *not send them* A naive proposal (which is admittedly racey) is for the WebProcess to tell the ui process "I'm about to do a sync XHR" and then to notify "I'm done with the sync XHR" The UI process could avoid sending these sync messages in the meantime. > I guess one viable alternative I can think of is add a > IPC::SendSyncOption::CancelIfDestinationIsSendingSyncIPC flag on the 2 > touch-related IPCs from the UIProcess, and somehow manage to cancel them on > the WebContent process side (without running any script or changing any > state), if the WebContent process is currently sending a sync IPC. I am not > sure yet how easy this would be to implement, but this would potentially be > safer. I am unsure how bad it would be for those 2 touch-related IPCs to get > cancelled whenever the WebContent process is busy. This might lead to missed > touches for examples. Why is is valuable to make sure we handle ALL touch events during a long running sync XHR? Wouldn't it be broken to handle dozens/hundreds of touch event messages delayed after the sync XHR finally finishes? 1555905 11 cdumez 2019-07-25 14:59:08 -0700 Will upload alternative patch based on Wenson's proposal at Bug 200138. 1556137 12 cdumez 2019-07-26 10:07:36 -0700 *** This bug has been marked as a duplicate of bug 200138 *** 374891 2019-07-25 09:14:37 -0700 2019-07-26 10:07:28 -0700 Patch bug-200126-20190725091437.patch text/plain 8093 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjQ3ODIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjMxY2Y2Y2Q0YTJjZmUw NzcyMDkyYjBkZDIwMGYyNTA0N2JjMTZiOC4uMGQxYmRjZDZhNDY4MGI5NWI4NTRmN2M0NGY4OTVm YjU2MTUxOWRkMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDE5LTA3LTI1ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgQXZvaWQgVUlQcm9jZXNzIGhh bmdzIGR1ZSB0byB0aGUgV2ViQ29udGVudCBwcm9jZXNzIGJlaW5nIHN0dWNrIG9uIGEgc3luYyBY SFIKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMDEy NgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTI2OTgxNTc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIHNvbWUgbW9yZSBjaGVja3MgYW5kIHBy b3RlY3RvcnMgbm93IHRoYXQgY2FsbHMgdG8gRnJhbWVMb2FkZXI6OmxvYWRSZXNvdXJjZVN5bmNo cm9ub3VzbHkoKQorICAgICAgICBtYXkgcmUtZW50ZXIgV2ViQ29yZSBhbmQgY2hhbmdlIG91ciBz dGF0ZS4KKworICAgICAgICAqIGxvYWRlci9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXIuY3BwOgor ICAgICAgICAoV2ViQ29yZTo6RG9jdW1lbnRUaHJlYWRhYmxlTG9hZGVyOjpsb2FkUmVxdWVzdCk6 CisgICAgICAgICogbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkZy YW1lTG9hZGVyOjpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KToKKyAgICAgICAgKiB4bWwvWE1M SHR0cFJlcXVlc3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6WE1MSHR0cFJlcXVlc3Q6OmNyZWF0 ZVJlcXVlc3QpOgorCiAyMDE5LTA3LTI1ICBDaHJpcyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+ CiAKICAgICAgICAgQXZvaWQgVUkgUHJvY2VzcyBoYW5ncyB3aGVuIHRoZSBXZWJDb250ZW50IHBy b2Nlc3MgaXMgc2hvd2luZyBKUyBwcm9tcHRzIC8gYWxlcnRzCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGQxZGZkNWVk ZWRiYTBhYmI3ODkyOTA1OTNhYmU2NzYyYzU5MTU5OGYuLmM3ZGU2ZTBhMWM3OGFjYjI3MzkyMTRh Njk2ZTZiM2JmMTlkNmJkYzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMTktMDctMjUg IENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBBdm9pZCBVSVByb2Nl c3MgaGFuZ3MgZHVlIHRvIHRoZSBXZWJDb250ZW50IHByb2Nlc3MgYmVpbmcgc3R1Y2sgb24gYSBz eW5jIFhIUgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjAwMTI2CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81MjY5ODE1Nz4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2UgbmV3IFNlbmRTeW5jT3B0aW9u OjpQcm9jZXNzSW5jb21pbmdTeW5jTWVzc2FnZXNXaGVuV2FpdGluZ0ZvclN5bmNSZXBseSBzZW5k U3luYworICAgICAgICBvcHRpb24gZm9yIHRoZSBOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vz czo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZCgpIHN5bmNocm9ub3VzCisgICAgICAgIElQQy4gVGhp cyBhbGxvd3MgdGhlIFdlYkNvbnRlbnQgcHJvY2VzcyB0byBwcm9jZXNzIGluY29taW5nIHN5bmNo cm9ub3VzIElQQyB3aGlsZQorICAgICAgICBpdCBpcyB3YWl0aW5nIGZvciBhIHN5bmNocm9ub3Vz IFhIUiB0byBjb21wbGV0ZS4gSW4gcGFydGljdWxhciwgaXQgd291bGQgYWxsb3cgaXQKKyAgICAg ICAgdG8gcHJvY2VzcyB0b3VjaCBldmVudC1yZWxhdGVkIHN5bmMgSVBDIGZyb20gdGhlIFVJUHJv Y2Vzcywgd2hpY2ggd2lsbCBhdm9pZAorICAgICAgICBVSVByb2Nlc3MgaGFuZ3MuCisKKyAgICAg ICAgKiBXZWJQcm9jZXNzL05ldHdvcmsvV2ViTG9hZGVyU3RyYXRlZ3kuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJMb2FkZXJTdHJhdGVneTo6bG9hZFJlc291cmNlU3luY2hyb25vdXNseSk6CisK IDIwMTktMDctMjUgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBB dm9pZCBVSSBQcm9jZXNzIGhhbmdzIHdoZW4gdGhlIFdlYkNvbnRlbnQgcHJvY2VzcyBpcyBzaG93 aW5nIEpTIHByb21wdHMgLyBhbGVydHMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRl ci9Eb2N1bWVudFRocmVhZGFibGVMb2FkZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0Rv Y3VtZW50VGhyZWFkYWJsZUxvYWRlci5jcHAKaW5kZXggNWU3OTkxNjgwMGFlODYwNjE0NzQ2Yzlk MTUxMTM5NTk1MDEwNDNhYS4uNTAwMmY4YWQxZWI0OGY3NTg3NjllZGVlYTg4YmMwMGVjNGZlZjEw MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxv YWRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0RvY3VtZW50VGhyZWFkYWJsZUxv YWRlci5jcHAKQEAgLTU2Niw2ICs1NjYsNyBAQCB2b2lkIERvY3VtZW50VGhyZWFkYWJsZUxvYWRl cjo6bG9hZFJlcXVlc3QoUmVzb3VyY2VSZXF1ZXN0JiYgcmVxdWVzdCwgU2VjdXJpdHlDaAogICAg ICAgICBhdXRvJiBmcmFtZUxvYWRlciA9IG1fZG9jdW1lbnQuZnJhbWUoKS0+bG9hZGVyKCk7CiAg ICAgICAgIGlmICghZnJhbWVMb2FkZXIubWl4ZWRDb250ZW50Q2hlY2tlcigpLmNhblJ1bkluc2Vj dXJlQ29udGVudChtX2RvY3VtZW50LnNlY3VyaXR5T3JpZ2luKCksIHJlcXVlc3RVUkwpKQogICAg ICAgICAgICAgcmV0dXJuOworICAgICAgICAvLyBUaGlzIGNhbGwgbWF5IHJlLWVudGVyIFdlYkNv cmUuCiAgICAgICAgIGlkZW50aWZpZXIgPSBmcmFtZUxvYWRlci5sb2FkUmVzb3VyY2VTeW5jaHJv bm91c2x5KHJlcXVlc3QsIG1fb3B0aW9ucy5jbGllbnRDcmVkZW50aWFsUG9saWN5LCBtX29wdGlv bnMsICptX29yaWdpbmFsSGVhZGVycywgZXJyb3IsIHJlc3BvbnNlLCBkYXRhKTsKICAgICB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9sb2FkZXIvRnJhbWVMb2FkZXIuY3BwCmluZGV4IGZjMjNhMTQ3N2VkYzkxYWRj Yzg1NzUyOTVkZGQxNGEwYTk5NGQ1ODIuLjAwZDE2NGRiMWM5MWJkMGZiZGNlOGUyYjYzMThjNTUz Yzk1MmNkZDIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2xvYWRlci9GcmFtZUxvYWRlci5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvbG9hZGVyL0ZyYW1lTG9hZGVyLmNwcApAQCAtMzA4Myw2 ICszMDgzLDcgQEAgdm9pZCBGcmFtZUxvYWRlcjo6bG9hZFBvc3RSZXF1ZXN0KEZyYW1lTG9hZFJl cXVlc3QmJiByZXF1ZXN0LCBjb25zdCBTdHJpbmcmIHJlZmUKIAogdW5zaWduZWQgbG9uZyBGcmFt ZUxvYWRlcjo6bG9hZFJlc291cmNlU3luY2hyb25vdXNseShjb25zdCBSZXNvdXJjZVJlcXVlc3Qm IHJlcXVlc3QsIENsaWVudENyZWRlbnRpYWxQb2xpY3kgY2xpZW50Q3JlZGVudGlhbFBvbGljeSwg Y29uc3QgRmV0Y2hPcHRpb25zJiBvcHRpb25zLCBjb25zdCBIVFRQSGVhZGVyTWFwJiBvcmlnaW5h bFJlcXVlc3RIZWFkZXJzLCBSZXNvdXJjZUVycm9yJiBlcnJvciwgUmVzb3VyY2VSZXNwb25zZSYg cmVzcG9uc2UsIFJlZlB0cjxTaGFyZWRCdWZmZXI+JiBkYXRhKQogeworICAgIFJlZjxGcmFtZT4g cHJvdGVjdGVkRnJhbWUobV9mcmFtZSk7CiAgICAgQVNTRVJUKG1fZnJhbWUuZG9jdW1lbnQoKSk7 CiAgICAgU3RyaW5nIHJlZmVycmVyID0gU2VjdXJpdHlQb2xpY3k6OmdlbmVyYXRlUmVmZXJyZXJI ZWFkZXIobV9mcmFtZS5kb2N1bWVudCgpLT5yZWZlcnJlclBvbGljeSgpLCByZXF1ZXN0LnVybCgp LCBvdXRnb2luZ1JlZmVycmVyKCkpOwogICAgIApAQCAtMzEyNiw5ICszMTI3LDExIEBAIHVuc2ln bmVkIGxvbmcgRnJhbWVMb2FkZXI6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkoY29uc3QgUmVz b3VyY2VSZXF1ZXN0JiByZXF1CiAKICAgICAgICAgaWYgKCFkb2N1bWVudExvYWRlcigpLT5hcHBs aWNhdGlvbkNhY2hlSG9zdCgpLm1heWJlTG9hZFN5bmNocm9ub3VzbHkobmV3UmVxdWVzdCwgZXJy b3IsIHJlc3BvbnNlLCBkYXRhKSkgewogICAgICAgICAgICAgVmVjdG9yPGNoYXI+IGJ1ZmZlcjsK KyAgICAgICAgICAgIC8vIFRoaXMgY2FsbCBtYXkgcmUtZW50ZXIgV2ViQ29yZS4KICAgICAgICAg ICAgIHBsYXRmb3JtU3RyYXRlZ2llcygpLT5sb2FkZXJTdHJhdGVneSgpLT5sb2FkUmVzb3VyY2VT eW5jaHJvbm91c2x5KCp0aGlzLCBpZGVudGlmaWVyLCBuZXdSZXF1ZXN0LCBjbGllbnRDcmVkZW50 aWFsUG9saWN5LCBvcHRpb25zLCBvcmlnaW5hbFJlcXVlc3RIZWFkZXJzLCBlcnJvciwgcmVzcG9u c2UsIGJ1ZmZlcik7CiAgICAgICAgICAgICBkYXRhID0gU2hhcmVkQnVmZmVyOjpjcmVhdGUoV1RG TW92ZShidWZmZXIpKTsKLSAgICAgICAgICAgIGRvY3VtZW50TG9hZGVyKCktPmFwcGxpY2F0aW9u Q2FjaGVIb3N0KCkubWF5YmVMb2FkRmFsbGJhY2tTeW5jaHJvbm91c2x5KG5ld1JlcXVlc3QsIGVy cm9yLCByZXNwb25zZSwgZGF0YSk7CisgICAgICAgICAgICBpZiAoYXV0byogZG9jdW1lbnRMb2Fk ZXIgPSB0aGlzLT5kb2N1bWVudExvYWRlcigpKQorICAgICAgICAgICAgICAgIGRvY3VtZW50TG9h ZGVyLT5hcHBsaWNhdGlvbkNhY2hlSG9zdCgpLm1heWJlTG9hZEZhbGxiYWNrU3luY2hyb25vdXNs eShuZXdSZXF1ZXN0LCBlcnJvciwgcmVzcG9uc2UsIGRhdGEpOwogICAgICAgICAgICAgUmVzb3Vy Y2VMb2FkT2JzZXJ2ZXI6OnNoYXJlZCgpLmxvZ1N1YnJlc291cmNlTG9hZGluZygmbV9mcmFtZSwg bmV3UmVxdWVzdCwgcmVzcG9uc2UpOwogICAgICAgICB9CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3htbC9Y TUxIdHRwUmVxdWVzdC5jcHAKaW5kZXggNWM2NDc0ZmY0N2Y2ZDAyYWRjYmRhMjllY2FkNTY0ZjRi NDZiMzAyOC4uYjA2YTk3N2E2ZDQ4MTg1NDIxNGVlODdhMzkyNGJmN2MyZTlkNTc5YiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUveG1sL1hNTEh0dHBSZXF1ZXN0LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS94bWwvWE1MSHR0cFJlcXVlc3QuY3BwCkBAIC01NzMsNiArNTczLDggQEAgRXhjZXB0 aW9uT3I8dm9pZD4gWE1MSHR0cFJlcXVlc3Q6OmNyZWF0ZVJlcXVlc3QoKQogICAgIC8vIE9ubHkg R0VUIHJlcXVlc3QgaXMgc3VwcG9ydGVkIGZvciBibG9iIFVSTC4KICAgICBpZiAoIW1fYXN5bmMg JiYgbV91cmwucHJvdG9jb2xJc0Jsb2IoKSAmJiBtX21ldGhvZCAhPSAiR0VUIikKICAgICAgICAg cmV0dXJuIEV4Y2VwdGlvbiB7IE5ldHdvcmtFcnJvciB9OworICAgICAgICAKKyAgICBSZWY8WE1M SHR0cFJlcXVlc3Q+IHByb3RlY3RlZFRoaXMoKnRoaXMpOwogCiAgICAgaWYgKG1fYXN5bmMgJiYg bV91cGxvYWQgJiYgbV91cGxvYWQtPmhhc0V2ZW50TGlzdGVuZXJzKCkpCiAgICAgICAgIG1fdXBs b2FkTGlzdGVuZXJGbGFnID0gdHJ1ZTsKQEAgLTY0Myw2ICs2NDUsNyBAQCBFeGNlcHRpb25Pcjx2 b2lkPiBYTUxIdHRwUmVxdWVzdDo6Y3JlYXRlUmVxdWVzdCgpCiAgICAgfSBlbHNlIHsKICAgICAg ICAgcmVxdWVzdC5zZXREb21haW5Gb3JDYWNoZVBhcnRpdGlvbihzY3JpcHRFeGVjdXRpb25Db250 ZXh0KCktPmRvbWFpbkZvckNhY2hlUGFydGl0aW9uKCkpOwogICAgICAgICBJbnNwZWN0b3JJbnN0 cnVtZW50YXRpb246OndpbGxMb2FkWEhSU3luY2hyb25vdXNseShzY3JpcHRFeGVjdXRpb25Db250 ZXh0KCkpOworICAgICAgICAvLyBUaGlzIGNhbGwgbWF5IHJlLWVudGVyIFdlYkNvcmUuCiAgICAg ICAgIFRocmVhZGFibGVMb2FkZXI6OmxvYWRSZXNvdXJjZVN5bmNocm9ub3VzbHkoKnNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQoKSwgV1RGTW92ZShyZXF1ZXN0KSwgKnRoaXMsIG9wdGlvbnMpOwogICAg ICAgICBJbnNwZWN0b3JJbnN0cnVtZW50YXRpb246OmRpZExvYWRYSFJTeW5jaHJvbm91c2x5KHNj cmlwdEV4ZWN1dGlvbkNvbnRleHQoKSk7CiAgICAgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9XZWJQcm9jZXNzL05ldHdvcmsvV2ViTG9hZGVyU3RyYXRlZ3kuY3BwIGIvU291cmNlL1dlYktp dC9XZWJQcm9jZXNzL05ldHdvcmsvV2ViTG9hZGVyU3RyYXRlZ3kuY3BwCmluZGV4IGUyMWY0YTEz OTU3YzRkZTk4N2FlNDdiM2UyMDZiOGJjZDE5YzgwNjYuLjkwMTNiNGM5ZmIxNDdiNWIxOWY0OGMz ZWI2MDE2YzNkNzc5NjUxZDYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9O ZXR3b3JrL1dlYkxvYWRlclN0cmF0ZWd5LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nl c3MvTmV0d29yay9XZWJMb2FkZXJTdHJhdGVneS5jcHAKQEAgLTU2OSw3ICs1NjksOCBAQCB2b2lk IFdlYkxvYWRlclN0cmF0ZWd5Ojpsb2FkUmVzb3VyY2VTeW5jaHJvbm91c2x5KEZyYW1lTG9hZGVy JiBmcmFtZUxvYWRlciwgdW5zaQogICAgIGlmIChzaG91bGROb3RpZnlPZlVwbG9hZCkKICAgICAg ICAgV2ViUHJvY2Vzczo6c2luZ2xldG9uKCkucGFyZW50UHJvY2Vzc0Nvbm5lY3Rpb24oKS0+c2Vu ZChNZXNzYWdlczo6V2ViUHJvY2Vzc1Bvb2w6OlNldFdlYlByb2Nlc3NIYXNVcGxvYWRzIHsgUHJv Y2Vzczo6aWRlbnRpZmllcigpIH0sIDApOwogCi0gICAgaWYgKCFXZWJQcm9jZXNzOjpzaW5nbGV0 b24oKS5lbnN1cmVOZXR3b3JrUHJvY2Vzc0Nvbm5lY3Rpb24oKS5jb25uZWN0aW9uKCkuc2VuZFN5 bmMoTWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hy b25vdXNMb2FkKGxvYWRQYXJhbWV0ZXJzKSwgTWVzc2FnZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9X ZWJQcm9jZXNzOjpQZXJmb3JtU3luY2hyb25vdXNMb2FkOjpSZXBseShlcnJvciwgcmVzcG9uc2Us IGRhdGEpLCAwKSkgeworICAgIC8vIFRoaXMgc3luY2hyb25vdXMgSVBDIG1heSByZS1lbnRlciB0 aGUgV2ViQ29udGVudCBwcm9jZXNzLgorICAgIGlmICghV2ViUHJvY2Vzczo6c2luZ2xldG9uKCku ZW5zdXJlTmV0d29ya1Byb2Nlc3NDb25uZWN0aW9uKCkuY29ubmVjdGlvbigpLnNlbmRTeW5jKE1l c3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6UGVyZm9ybVN5bmNocm9ub3Vz TG9hZChsb2FkUGFyYW1ldGVycyksIE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJv Y2Vzczo6UGVyZm9ybVN5bmNocm9ub3VzTG9hZDo6UmVwbHkoZXJyb3IsIHJlc3BvbnNlLCBkYXRh KSwgMCwgU2Vjb25kczo6aW5maW5pdHkoKSwgSVBDOjpTZW5kU3luY09wdGlvbjo6UHJvY2Vzc0lu Y29taW5nU3luY01lc3NhZ2VzV2hlbldhaXRpbmdGb3JTeW5jUmVwbHkpKSB7CiAgICAgICAgIFJF TEVBU0VfTE9HX0VSUk9SX0lGX0FMTE9XRUQoc2Vzc2lvbklELCAibG9hZFJlc291cmNlU3luY2hy b25vdXNseTogZmFpbGVkIHNlbmRpbmcgc3luY2hyb25vdXMgbmV0d29yayBwcm9jZXNzIG1lc3Nh Z2UgKHBhZ2VJRCA9ICUiIFBSSXU2NCAiLCBmcmFtZUlEID0gJSIgUFJJdTY0ICIsIHJlc291cmNl SUQgPSAlbHUpIiwgcGFnZUlELnRvVUludDY0KCksIGZyYW1lSUQsIHJlc291cmNlTG9hZElkZW50 aWZpZXIpOwogICAgICAgICBpZiAoYXV0byogcGFnZSA9IHdlYlBhZ2UgPyB3ZWJQYWdlLT5jb3Jl UGFnZSgpIDogbnVsbHB0cikKICAgICAgICAgICAgIHBhZ2UtPmRpYWdub3N0aWNMb2dnaW5nQ2xp ZW50KCkubG9nRGlhZ25vc3RpY01lc3NhZ2UoV2ViQ29yZTo6RGlhZ25vc3RpY0xvZ2dpbmdLZXlz OjppbnRlcm5hbEVycm9yS2V5KCksIFdlYkNvcmU6OkRpYWdub3N0aWNMb2dnaW5nS2V5czo6c3lu Y2hyb25vdXNNZXNzYWdlRmFpbGVkS2V5KCksIFdlYkNvcmU6OlNob3VsZFNhbXBsZTo6Tm8pOwo=