192016 2018-11-27 11:03:50 -0800 Web Inspector: REGRESSION(?): all "Show *" develop menu items cause the page to crash 2018-11-28 20:41:38 -0800 1 1 1 Unclassified WebKit Web Inspector WebKit Nightly Build All All RESOLVED FIXED InRadar P2 Normal --- 1 hi joepeck hi inspector-bugzilla-changes joepeck webkit-bug-importer oldest_to_newest 1481969 0 hi 2018-11-27 11:03:50 -0800 This affects: - Show JavaScript Console - Show Page Source - Show Page Resources - Start Timeline Recording - Start Element Selection The "Show Web Inspector" item (and it's associated keyboard shortcut) work correctly. 1482038 1 webkit-bug-importer 2018-11-27 12:20:27 -0800 <rdar://problem/46284421> 1482041 2 webkit-bug-importer 2018-11-27 12:20:34 -0800 <rdar://problem/46284417> 1482042 3 joepeck 2018-11-27 12:20:42 -0800 Interesting. Should be easy to track these down and pipe them appropriately. 1482715 4 355936 joepeck 2018-11-28 15:39:54 -0800 Created attachment 355936 [PATCH] Proposed Fix 1482751 5 355936 hi 2018-11-28 17:11:44 -0800 Comment on attachment 355936 [PATCH] Proposed Fix View in context: https://bugs.webkit.org/attachment.cgi?id=355936&action=review r=me > Source/WebInspectorUI/UserInterface/Base/Main.js:160 > + this._targetsAvailablePromise = new WI.WrappedPromise; This does seem like the "perfect" use case for a Promise, but it scares me a bit cause it means delaying the code it runs just _that_ much more. Considering this is at startup, I'd like to avoid any delays (no matter how small) whenever/wherever we can. Perhaps we can do something like this: --- WI.loaded --- this._loadOperations = new Set; --- WI.loaded --- --- WI.initializeBackendTarget --- this._completeLoadOperation("initializeBackendTarget"); --- WI.initializeBackendTarget --- --- WI.contentLoaded --- this._completeLoadOperation("contentLoaded"); --- WI.contentLoaded --- WI._completeLoadOperation = function(name) { this._loadOperations.add(name); if (this._loadOperations.has("initializeBackendTarget") && this._loadOperations.has("contentLoaded")) InspectorFrontendAPI.loadCompleted(); }; > Source/WebInspectorUI/UserInterface/Base/Main.js:559 > + }) Style: missing `;` > Source/WebInspectorUI/UserInterface/Base/Main.js:588 > +WI.whenTargetsAvailable = function() Since `WI._targetsAvailablePromise` is only used within `Main.js`, can we remove this function and just inline: WI._targetsAvailablePromise.promise.then(() => { InspectorFrontendAPI.loadCompleted(); }); As an aside, maybe we should add a `then()` to `WI.WrappedPromise` so we can avoid this 🤔 (e.g. forwarding) > Source/WebInspectorUI/UserInterface/Base/Main.js:591 > +} Style: missing `;` > Source/WebKit/ChangeLog:12 > + once the UIProcess creates it. So queue actions that to take place Typo: "actions that take place" > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:195 > + whenFrontendConnectionEstablished([=] { Capture by value? Not by reference? > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:207 > + whenFrontendConnectionEstablished([=] { Ditto (195) > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:219 > + whenFrontendConnectionEstablished([=] { Ditto (195) > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:238 > + m_frontendConnection->send(Messages::WebInspectorUI::ShowMainResourceForFrame(inspectorFrameIdentifier), 0); Ditto (195) > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:247 > + whenFrontendConnectionEstablished([=] { Ditto (195) > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:257 > + whenFrontendConnectionEstablished([=] { Ditto (195) > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:267 > + whenFrontendConnectionEstablished([=] { Ditto (195) > Source/WebKit/WebProcess/WebPage/WebInspector.cpp:277 > + whenFrontendConnectionEstablished([=] { Ditto (195) 1482831 6 355936 joepeck 2018-11-28 20:31:54 -0800 Comment on attachment 355936 [PATCH] Proposed Fix View in context: https://bugs.webkit.org/attachment.cgi?id=355936&action=review >> Source/WebInspectorUI/UserInterface/Base/Main.js:160 >> + this._targetsAvailablePromise = new WI.WrappedPromise; > > This does seem like the "perfect" use case for a Promise, but it scares me a bit cause it means delaying the code it runs just _that_ much more. Considering this is at startup, I'd like to avoid any delays (no matter how small) whenever/wherever we can. Perhaps we can do something like this: > > --- WI.loaded --- > this._loadOperations = new Set; > --- WI.loaded --- > > --- WI.initializeBackendTarget --- > this._completeLoadOperation("initializeBackendTarget"); > --- WI.initializeBackendTarget --- > > --- WI.contentLoaded --- > this._completeLoadOperation("contentLoaded"); > --- WI.contentLoaded --- > > WI._completeLoadOperation = function(name) { > this._loadOperations.add(name); > if (this._loadOperations.has("initializeBackendTarget") && this._loadOperations.has("contentLoaded")) > InspectorFrontendAPI.loadCompleted(); > }; I agree with the sentiment but I think the delay is the smartest thing to do here so I'm going to stick with it for now. In fact I went with a Promise so that it would happen in a microtask as soon as possible and not a timeout delay. In legacy cases, this should happen approximately a few statements later than it used to. In the multi-target case it'll happen as soon as the backend target (and page target) are initialized. Using immediate callbacks like you've done would call InspectorFrontendAPI.loadCompleted before the page target is initialized, and so in the particular case (Cmd+Shift+C not working before page target loaded) it wouldn't have been enough. I do think there is room for improvement in startup here. I ran into a bunch of complexities separating target initialization from the UI initialization, so I know we can be doing better. But I think once we've worked out all the correctness issues (like realizing the mistaken order of IFH.loadCompleted for example) we can address performance of a working system. >> Source/WebInspectorUI/UserInterface/Base/Main.js:588 >> +WI.whenTargetsAvailable = function() > > Since `WI._targetsAvailablePromise` is only used within `Main.js`, can we remove this function and just inline: > > WI._targetsAvailablePromise.promise.then(() => { > InspectorFrontendAPI.loadCompleted(); > }); > > As an aside, maybe we should add a `then()` to `WI.WrappedPromise` so we can avoid this 🤔 (e.g. forwarding) I expect whenTargetsAvailable to have potential use elsewhere given I've already hit this pattern once and could think of another place to use it. I'll leave it for now. >> Source/WebKit/WebProcess/WebPage/WebInspector.cpp:195 >> + whenFrontendConnectionEstablished([=] { > > Capture by value? Not by reference? Nothing is being captured in almost all of these (other than `this`). The only one that has anything of value is a string, which we treat as a value anyways. If I'm overlooking something let me know. 1482832 7 joepeck 2018-11-28 20:41:38 -0800 https://trac.webkit.org/changeset/238660/webkit 355936 2018-11-28 15:39:54 -0800 2018-11-28 17:11:44 -0800 [PATCH] Proposed Fix develop-menu-1.patch text/plain 9584 joepeck ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCmluZGV4IGIwMTI2ODIxZjdkLi42ZTNmZjhmM2Y2NiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkluc3BlY3RvclVJL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2Vi SW5zcGVjdG9yVUkvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTgtMTEtMjggIEpvc2Vw aCBQZWNvcmFybyAgPHBlY29yYXJvQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBSRUdSRVNTSU9OKD8pOiBhbGwgIlNob3cgKiIgZGV2ZWxvcCBtZW51IGl0ZW1zIGNhdXNlIHRo ZSBwYWdlIHRvIGNyYXNoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xOTIwMTYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzQ2Mjg0NDIxPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVXNlckludGVyZmFj ZS9CYXNlL01haW4uanM6CisgICAgICAgIChXSS5sb2FkZWQpOgorICAgICAgICAoV0kuaW5pdGlh bGl6ZUJhY2tlbmRUYXJnZXQpOgorICAgICAgICAoV0kuY29udGVudExvYWRlZCk6CisgICAgICAg IChXSS53aGVuVGFyZ2V0c0F2YWlsYWJsZSk6CisgICAgICAgIERvbid0IGV2YWx1YXRlIGFueSBJ bnNwZWN0b3JGcm9udGVuZEFQSSBjb21tYW5kcyB1bnRpbCB0aGUgZnJvbnRlbmQKKyAgICAgICAg aGFzIGluaXRpYWxpemVkIGEgbWFpbiB0YXJnZXQgYW5kIHRoZSB1c2VyIGludGVyZmFjZS4KKwog MjAxOC0xMS0yNyAgTWF0dCBCYWtlciAgPG1hdHRiYWtlckBhcHBsZS5jb20+CiAKICAgICAgICAg V2ViIEluc3BlY3RvcjogVGFibGUgc2VsZWN0aW9uIHNob3VsZCBiZSBoYW5kbGVkIGJ5IGEgU2Vs ZWN0aW9uQ29udHJvbGxlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJ bnRlcmZhY2UvQmFzZS9NYWluLmpzIGIvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZh Y2UvQmFzZS9NYWluLmpzCmluZGV4IDJkMzA1MTc0YTQwLi5jMzE2MTQ4MTUyYyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkluc3BlY3RvclVJL1VzZXJJbnRlcmZhY2UvQmFzZS9NYWluLmpzCisrKyBi L1NvdXJjZS9XZWJJbnNwZWN0b3JVSS9Vc2VySW50ZXJmYWNlL0Jhc2UvTWFpbi5qcwpAQCAtMTU3 LDYgKzE1Nyw3IEBAIFdJLmxvYWRlZCA9IGZ1bmN0aW9uKCkKICAgICB0aGlzLm1vZGlmaWVyS2V5 cyA9IHthbHRLZXk6IGZhbHNlLCBtZXRhS2V5OiBmYWxzZSwgc2hpZnRLZXk6IGZhbHNlfTsKICAg ICB0aGlzLnZpc2libGUgPSBmYWxzZTsKICAgICB0aGlzLl93aW5kb3dLZXlkb3duTGlzdGVuZXJz ID0gW107CisgICAgdGhpcy5fdGFyZ2V0c0F2YWlsYWJsZVByb21pc2UgPSBuZXcgV0kuV3JhcHBl ZFByb21pc2U7CiAKICAgICAvLyBUYXJnZXRzLgogICAgIFdJLmJhY2tlbmRUYXJnZXQgPSBudWxs OwpAQCAtMTgxLDYgKzE4Miw4IEBAIFdJLmluaXRpYWxpemVCYWNrZW5kVGFyZ2V0ID0gZnVuY3Rp b24odGFyZ2V0KQogICAgIFdJLmJhY2tlbmRUYXJnZXQgPSB0YXJnZXQ7CiAKICAgICBXSS5yZXNl dE1haW5FeGVjdXRpb25Db250ZXh0KCk7CisKKyAgICB0aGlzLl90YXJnZXRzQXZhaWxhYmxlUHJv bWlzZS5yZXNvbHZlKCk7CiB9OwogCiBXSS5pbml0aWFsaXplUGFnZVRhcmdldCA9IGZ1bmN0aW9u KHRhcmdldCkKQEAgLTU1MSw3ICs1NTQsOSBAQCBXSS5jb250ZW50TG9hZGVkID0gZnVuY3Rpb24o KQogICAgIHRoaXMudGFiQmFyLmFkZEV2ZW50TGlzdGVuZXIoV0kuVGFiQmFyLkV2ZW50LlRhYkJh ckl0ZW1zUmVvcmRlcmVkLCB0aGlzLl9yZW1lbWJlck9wZW5UYWJzLCB0aGlzKTsKIAogICAgIC8v IFNpZ25hbCB0aGF0IHRoZSBmcm9udGVuZCBpcyBub3cgcmVhZHkgdG8gcmVjZWl2ZSBtZXNzYWdl cy4KLSAgICBJbnNwZWN0b3JGcm9udGVuZEFQSS5sb2FkQ29tcGxldGVkKCk7CisgICAgV0kud2hl blRhcmdldHNBdmFpbGFibGUoKS50aGVuKCgpID0+IHsKKyAgICAgICAgSW5zcGVjdG9yRnJvbnRl bmRBUEkubG9hZENvbXBsZXRlZCgpOworICAgIH0pCiAKICAgICAvLyBUZWxsIHRoZSBJbnNwZWN0 b3JGcm9udGVuZEhvc3Qgd2UgbG9hZGVkLCB3aGljaCBjYXVzZXMgdGhlIHdpbmRvdyB0byBkaXNw bGF5CiAgICAgLy8gYW5kIHBlbmRpbmcgSW5zcGVjdG9yRnJvbnRlbmRBUEkgY29tbWFuZHMgdG8g YmUgc2VudC4KQEAgLTU4MCw2ICs1ODUsMTEgQEAgV0kucGVyZm9ybU9uZVRpbWVGcm9udGVuZElu aXRpYWxpemF0aW9uc1VzaW5nVGFyZ2V0ID0gZnVuY3Rpb24odGFyZ2V0KQogICAgIH0KIH07CiAK K1dJLndoZW5UYXJnZXRzQXZhaWxhYmxlID0gZnVuY3Rpb24oKQoreworICAgIHJldHVybiB0aGlz Ll90YXJnZXRzQXZhaWxhYmxlUHJvbWlzZS5wcm9taXNlOworfQorCiBXSS5pc1RhYlR5cGVBbGxv d2VkID0gZnVuY3Rpb24odGFiVHlwZSkKIHsKICAgICBsZXQgdGFiQ2xhc3MgPSB0aGlzLl9rbm93 blRhYkNsYXNzZXNCeVR5cGUuZ2V0KHRhYlR5cGUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwppbmRleCAyZDUwNWY4OGEyNi4u MjI5MjljYTNiOWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTgtMTEtMjggIEpvc2Vw aCBQZWNvcmFybyAgPHBlY29yYXJvQGFwcGxlLmNvbT4KKworICAgICAgICBXZWIgSW5zcGVjdG9y OiBSRUdSRVNTSU9OKD8pOiBhbGwgIlNob3cgKiIgZGV2ZWxvcCBtZW51IGl0ZW1zIGNhdXNlIHRo ZSBwYWdlIHRvIGNyYXNoCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xOTIwMTYKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzQ2Mjg0NDIxPgorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFByZXZpb3VzbHkgY2Fs bGluZyB0aGUgUGFnZSdzIGluc3BlY3RvckNvbnRyb2xsZXIuc2hvdygpCisgICAgICAgIHdvdWxk IGNyZWF0ZSBhIGZyb250ZW5kIGNvbm5lY3Rpb24gb24gdGhlIFdlYlByb2Nlc3Mgc2lkZS4KKyAg ICAgICAgSG93ZXZlciBub3cgdGhlIGZyb250ZW5kIGNvbm5lY3Rpb24gaXMgaGFuZGVkIHRvIHRo ZSBXZWJQcm9jZXNzCisgICAgICAgIG9uY2UgdGhlIFVJUHJvY2VzcyBjcmVhdGVzIGl0LiBTbyBx dWV1ZSBhY3Rpb25zIHRoYXQgdG8gdGFrZSBwbGFjZQorICAgICAgICBpbW1lZGlhdGVseSBhZnRl ciBzaG93aW5nIHRoZSBpbnNwZWN0b3IgdW50aWwgd2UgaGF2ZSBhIGZyb250ZW5kCisgICAgICAg IHRvIHNlbmQgdGhlIGFjdGlvbnMgdG8uCisKKyAgICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2Uv V2ViSW5zcGVjdG9yLmg6CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkluc3BlY3Rv ci5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYkluc3BlY3Rvcjo6c2V0RnJvbnRlbmRDb25uZWN0 aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViSW5zcGVjdG9yOjpjbG9zZUZyb250ZW5kQ29ubmVj dGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYkluc3BlY3Rvcjo6d2hlbkZyb250ZW5kQ29ubmVj dGlvbkVzdGFibGlzaGVkKToKKyAgICAgICAgKFdlYktpdDo6V2ViSW5zcGVjdG9yOjpzaG93Q29u c29sZSk6CisgICAgICAgIChXZWJLaXQ6OldlYkluc3BlY3Rvcjo6c2hvd1Jlc291cmNlcyk6Cisg ICAgICAgIChXZWJLaXQ6OldlYkluc3BlY3Rvcjo6c2hvd1RpbWVsaW5lcyk6CisgICAgICAgIChX ZWJLaXQ6OldlYkluc3BlY3Rvcjo6c2hvd01haW5SZXNvdXJjZUZvckZyYW1lKToKKyAgICAgICAg KFdlYktpdDo6V2ViSW5zcGVjdG9yOjpzdGFydFBhZ2VQcm9maWxpbmcpOgorICAgICAgICAoV2Vi S2l0OjpXZWJJbnNwZWN0b3I6OnN0b3BQYWdlUHJvZmlsaW5nKToKKyAgICAgICAgKFdlYktpdDo6 V2ViSW5zcGVjdG9yOjpzdGFydEVsZW1lbnRTZWxlY3Rpb24pOgorICAgICAgICAoV2ViS2l0OjpX ZWJJbnNwZWN0b3I6OnN0b3BFbGVtZW50U2VsZWN0aW9uKToKKwogMjAxOC0xMS0yNyAgSm9zZXBo IFBlY29yYXJvICA8cGVjb3Jhcm9AYXBwbGUuY29tPgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6 IFJFR1JFU1NJT04ocjIzODM3OCk6IHJlbG9hZGluZyBXZWJJbnNwZWN0b3IgYWZ0ZXIgYSBzZXR0 aW5ncyBjaGFuZ2UgZG9lc24ndCByZS1zaG93IFdlYkluc3BlY3RvcgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViSW5zcGVjdG9yLmNwcCBiL1NvdXJjZS9X ZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdlL1dlYkluc3BlY3Rvci5jcHAKaW5kZXggYTZmMjI0YmE0 NTMuLjhhODNiODA2ZmFjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2Vi UGFnZS9XZWJJbnNwZWN0b3IuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQ YWdlL1dlYkluc3BlY3Rvci5jcHAKQEAgLTEwMCw2ICsxMDAsMTAgQEAgdm9pZCBXZWJJbnNwZWN0 b3I6OnNldEZyb250ZW5kQ29ubmVjdGlvbihJUEM6OkF0dGFjaG1lbnQgZW5jb2RlZENvbm5lY3Rp b25JZGVudGkKIAogICAgIG1fZnJvbnRlbmRDb25uZWN0aW9uID0gSVBDOjpDb25uZWN0aW9uOjpj cmVhdGVDbGllbnRDb25uZWN0aW9uKGNvbm5lY3Rpb25JZGVudGlmaWVyLCAqdGhpcyk7CiAgICAg bV9mcm9udGVuZENvbm5lY3Rpb24tPm9wZW4oKTsKKworICAgIGZvciAoYXV0byYgY2FsbGJhY2sg OiBtX2Zyb250ZW5kQ29ubmVjdGlvbkFjdGlvbnMpCisgICAgICAgIGNhbGxiYWNrKCk7CisgICAg bV9mcm9udGVuZENvbm5lY3Rpb25BY3Rpb25zLmNsZWFyKCk7CiB9CiAKIHZvaWQgV2ViSW5zcGVj dG9yOjpjbG9zZUZyb250ZW5kQ29ubmVjdGlvbigpCkBAIC0xMTIsNiArMTE2LDggQEAgdm9pZCBX ZWJJbnNwZWN0b3I6OmNsb3NlRnJvbnRlbmRDb25uZWN0aW9uKCkKICAgICAgICAgbV9mcm9udGVu ZENvbm5lY3Rpb24gPSBudWxscHRyOwogICAgIH0KIAorICAgIG1fZnJvbnRlbmRDb25uZWN0aW9u QWN0aW9ucy5jbGVhcigpOworCiAgICAgbV9hdHRhY2hlZCA9IGZhbHNlOwogICAgIG1fcHJldmlv dXNDYW5BdHRhY2ggPSBmYWxzZTsKIH0KQEAgLTEyMSw2ICsxMjcsMTYgQEAgdm9pZCBXZWJJbnNw ZWN0b3I6OmJyaW5nVG9Gcm9udCgpCiAgICAgV2ViUHJvY2Vzczo6c2luZ2xldG9uKCkucGFyZW50 UHJvY2Vzc0Nvbm5lY3Rpb24oKS0+c2VuZChNZXNzYWdlczo6V2ViSW5zcGVjdG9yUHJveHk6OkJy aW5nVG9Gcm9udCgpLCBtX3BhZ2UtPnBhZ2VJRCgpKTsKIH0KIAordm9pZCBXZWJJbnNwZWN0b3I6 OndoZW5Gcm9udGVuZENvbm5lY3Rpb25Fc3RhYmxpc2hlZChGdW5jdGlvbjx2b2lkKCk+JiYgY2Fs bGJhY2spCit7CisgICAgaWYgKG1fZnJvbnRlbmRDb25uZWN0aW9uKSB7CisgICAgICAgIGNhbGxi YWNrKCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBtX2Zyb250ZW5kQ29ubmVjdGlv bkFjdGlvbnMuYXBwZW5kKFdURk1vdmUoY2FsbGJhY2spKTsKK30KKwogLy8gQ2FsbGVkIGJ5IFdl Ykluc3BlY3RvciBtZXNzYWdlcwogdm9pZCBXZWJJbnNwZWN0b3I6OnNob3coKQogewpAQCAtMTc1 LDcgKzE5MSwxMCBAQCB2b2lkIFdlYkluc3BlY3Rvcjo6c2hvd0NvbnNvbGUoKQogICAgICAgICBy ZXR1cm47CiAKICAgICBtX3BhZ2UtPmNvcmVQYWdlKCktPmluc3BlY3RvckNvbnRyb2xsZXIoKS5z aG93KCk7Ci0gICAgbV9mcm9udGVuZENvbm5lY3Rpb24tPnNlbmQoTWVzc2FnZXM6OldlYkluc3Bl Y3RvclVJOjpTaG93Q29uc29sZSgpLCAwKTsKKworICAgIHdoZW5Gcm9udGVuZENvbm5lY3Rpb25F c3RhYmxpc2hlZChbPV0geworICAgICAgICBtX2Zyb250ZW5kQ29ubmVjdGlvbi0+c2VuZChNZXNz YWdlczo6V2ViSW5zcGVjdG9yVUk6OlNob3dDb25zb2xlKCksIDApOworICAgIH0pOwogfQogCiB2 b2lkIFdlYkluc3BlY3Rvcjo6c2hvd1Jlc291cmNlcygpCkBAIC0xODQsNyArMjAzLDEwIEBAIHZv aWQgV2ViSW5zcGVjdG9yOjpzaG93UmVzb3VyY2VzKCkKICAgICAgICAgcmV0dXJuOwogCiAgICAg bV9wYWdlLT5jb3JlUGFnZSgpLT5pbnNwZWN0b3JDb250cm9sbGVyKCkuc2hvdygpOwotICAgIG1f ZnJvbnRlbmRDb25uZWN0aW9uLT5zZW5kKE1lc3NhZ2VzOjpXZWJJbnNwZWN0b3JVSTo6U2hvd1Jl c291cmNlcygpLCAwKTsKKworICAgIHdoZW5Gcm9udGVuZENvbm5lY3Rpb25Fc3RhYmxpc2hlZChb PV0geworICAgICAgICBtX2Zyb250ZW5kQ29ubmVjdGlvbi0+c2VuZChNZXNzYWdlczo6V2ViSW5z cGVjdG9yVUk6OlNob3dSZXNvdXJjZXMoKSwgMCk7CisgICAgfSk7CiB9CiAKIHZvaWQgV2ViSW5z cGVjdG9yOjpzaG93VGltZWxpbmVzKCkKQEAgLTE5Myw3ICsyMTUsMTAgQEAgdm9pZCBXZWJJbnNw ZWN0b3I6OnNob3dUaW1lbGluZXMoKQogICAgICAgICByZXR1cm47CiAKICAgICBtX3BhZ2UtPmNv cmVQYWdlKCktPmluc3BlY3RvckNvbnRyb2xsZXIoKS5zaG93KCk7Ci0gICAgbV9mcm9udGVuZENv bm5lY3Rpb24tPnNlbmQoTWVzc2FnZXM6OldlYkluc3BlY3RvclVJOjpTaG93VGltZWxpbmVzKCks IDApOworCisgICAgd2hlbkZyb250ZW5kQ29ubmVjdGlvbkVzdGFibGlzaGVkKFs9XSB7CisgICAg ICAgIG1fZnJvbnRlbmRDb25uZWN0aW9uLT5zZW5kKE1lc3NhZ2VzOjpXZWJJbnNwZWN0b3JVSTo6 U2hvd1RpbWVsaW5lcygpLCAwKTsKKyAgICB9KTsKIH0KIAogdm9pZCBXZWJJbnNwZWN0b3I6OnNo b3dNYWluUmVzb3VyY2VGb3JGcmFtZSh1aW50NjRfdCBmcmFtZUlkZW50aWZpZXIpCkBAIC0yMDgs NyArMjMzLDEwIEBAIHZvaWQgV2ViSW5zcGVjdG9yOjpzaG93TWFpblJlc291cmNlRm9yRnJhbWUo dWludDY0X3QgZnJhbWVJZGVudGlmaWVyKQogICAgIG1fcGFnZS0+Y29yZVBhZ2UoKS0+aW5zcGVj dG9yQ29udHJvbGxlcigpLnNob3coKTsKIAogICAgIFN0cmluZyBpbnNwZWN0b3JGcmFtZUlkZW50 aWZpZXIgPSBtX3BhZ2UtPmNvcmVQYWdlKCktPmluc3BlY3RvckNvbnRyb2xsZXIoKS5wYWdlQWdl bnQoKS0+ZnJhbWVJZChmcmFtZS0+Y29yZUZyYW1lKCkpOwotICAgIG1fZnJvbnRlbmRDb25uZWN0 aW9uLT5zZW5kKE1lc3NhZ2VzOjpXZWJJbnNwZWN0b3JVSTo6U2hvd01haW5SZXNvdXJjZUZvckZy YW1lKGluc3BlY3RvckZyYW1lSWRlbnRpZmllciksIDApOworCisgICAgd2hlbkZyb250ZW5kQ29u bmVjdGlvbkVzdGFibGlzaGVkKFs9XSB7CisgICAgICAgIG1fZnJvbnRlbmRDb25uZWN0aW9uLT5z ZW5kKE1lc3NhZ2VzOjpXZWJJbnNwZWN0b3JVSTo6U2hvd01haW5SZXNvdXJjZUZvckZyYW1lKGlu c3BlY3RvckZyYW1lSWRlbnRpZmllciksIDApOworICAgIH0pOwogfQogCiB2b2lkIFdlYkluc3Bl Y3Rvcjo6c3RhcnRQYWdlUHJvZmlsaW5nKCkKQEAgLTIxNiw3ICsyNDQsOSBAQCB2b2lkIFdlYklu c3BlY3Rvcjo6c3RhcnRQYWdlUHJvZmlsaW5nKCkKICAgICBpZiAoIW1fcGFnZS0+Y29yZVBhZ2Uo KSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgbV9mcm9udGVuZENvbm5lY3Rpb24tPnNlbmQoTWVz c2FnZXM6OldlYkluc3BlY3RvclVJOjpTdGFydFBhZ2VQcm9maWxpbmcoKSwgMCk7CisgICAgd2hl bkZyb250ZW5kQ29ubmVjdGlvbkVzdGFibGlzaGVkKFs9XSB7CisgICAgICAgIG1fZnJvbnRlbmRD b25uZWN0aW9uLT5zZW5kKE1lc3NhZ2VzOjpXZWJJbnNwZWN0b3JVSTo6U3RhcnRQYWdlUHJvZmls aW5nKCksIDApOworICAgIH0pOwogfQogCiB2b2lkIFdlYkluc3BlY3Rvcjo6c3RvcFBhZ2VQcm9m aWxpbmcoKQpAQCAtMjI0LDcgKzI1NCw5IEBAIHZvaWQgV2ViSW5zcGVjdG9yOjpzdG9wUGFnZVBy b2ZpbGluZygpCiAgICAgaWYgKCFtX3BhZ2UtPmNvcmVQYWdlKCkpCiAgICAgICAgIHJldHVybjsK IAotICAgIG1fZnJvbnRlbmRDb25uZWN0aW9uLT5zZW5kKE1lc3NhZ2VzOjpXZWJJbnNwZWN0b3JV STo6U3RvcFBhZ2VQcm9maWxpbmcoKSwgMCk7CisgICAgd2hlbkZyb250ZW5kQ29ubmVjdGlvbkVz dGFibGlzaGVkKFs9XSB7CisgICAgICAgIG1fZnJvbnRlbmRDb25uZWN0aW9uLT5zZW5kKE1lc3Nh Z2VzOjpXZWJJbnNwZWN0b3JVSTo6U3RvcFBhZ2VQcm9maWxpbmcoKSwgMCk7CisgICAgfSk7CiB9 CiAKIHZvaWQgV2ViSW5zcGVjdG9yOjpzdGFydEVsZW1lbnRTZWxlY3Rpb24oKQpAQCAtMjMyLDcg KzI2NCw5IEBAIHZvaWQgV2ViSW5zcGVjdG9yOjpzdGFydEVsZW1lbnRTZWxlY3Rpb24oKQogICAg IGlmICghbV9wYWdlLT5jb3JlUGFnZSgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBtX2Zyb250 ZW5kQ29ubmVjdGlvbi0+c2VuZChNZXNzYWdlczo6V2ViSW5zcGVjdG9yVUk6OlN0YXJ0RWxlbWVu dFNlbGVjdGlvbigpLCAwKTsKKyAgICB3aGVuRnJvbnRlbmRDb25uZWN0aW9uRXN0YWJsaXNoZWQo Wz1dIHsKKyAgICAgICAgbV9mcm9udGVuZENvbm5lY3Rpb24tPnNlbmQoTWVzc2FnZXM6OldlYklu c3BlY3RvclVJOjpTdGFydEVsZW1lbnRTZWxlY3Rpb24oKSwgMCk7CisgICAgfSk7CiB9CiAKIHZv aWQgV2ViSW5zcGVjdG9yOjpzdG9wRWxlbWVudFNlbGVjdGlvbigpCkBAIC0yNDAsNyArMjc0LDkg QEAgdm9pZCBXZWJJbnNwZWN0b3I6OnN0b3BFbGVtZW50U2VsZWN0aW9uKCkKICAgICBpZiAoIW1f cGFnZS0+Y29yZVBhZ2UoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgbV9mcm9udGVuZENvbm5l Y3Rpb24tPnNlbmQoTWVzc2FnZXM6OldlYkluc3BlY3RvclVJOjpTdG9wRWxlbWVudFNlbGVjdGlv bigpLCAwKTsKKyAgICB3aGVuRnJvbnRlbmRDb25uZWN0aW9uRXN0YWJsaXNoZWQoWz1dIHsKKyAg ICAgICAgbV9mcm9udGVuZENvbm5lY3Rpb24tPnNlbmQoTWVzc2FnZXM6OldlYkluc3BlY3RvclVJ OjpTdG9wRWxlbWVudFNlbGVjdGlvbigpLCAwKTsKKyAgICB9KTsKIH0KIAogdm9pZCBXZWJJbnNw ZWN0b3I6OmVsZW1lbnRTZWxlY3Rpb25DaGFuZ2VkKGJvb2wgYWN0aXZlKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViSW5zcGVjdG9yLmggYi9Tb3VyY2Uv V2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJJbnNwZWN0b3IuaAppbmRleCBlNTAzOTZkNWM1 Ni4uNjkwMjllYjlhODQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQ YWdlL1dlYkluc3BlY3Rvci5oCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQYWdl L1dlYkluc3BlY3Rvci5oCkBAIC05Miw5ICs5MiwxMiBAQCBwcml2YXRlOgogCiAgICAgdm9pZCBi cmluZ1RvRnJvbnQoKTsKIAorICAgIHZvaWQgd2hlbkZyb250ZW5kQ29ubmVjdGlvbkVzdGFibGlz aGVkKEZ1bmN0aW9uPHZvaWQoKT4mJik7CisKICAgICBXZWJQYWdlKiBtX3BhZ2U7CiAKICAgICBS ZWZQdHI8SVBDOjpDb25uZWN0aW9uPiBtX2Zyb250ZW5kQ29ubmVjdGlvbjsKKyAgICBWZWN0b3I8 RnVuY3Rpb248dm9pZCgpPj4gbV9mcm9udGVuZENvbm5lY3Rpb25BY3Rpb25zOwogCiAgICAgYm9v bCBtX2F0dGFjaGVkIHsgZmFsc2UgfTsKICAgICBib29sIG1fcHJldmlvdXNDYW5BdHRhY2ggeyBm YWxzZSB9Owo=