63081 2011-06-21 11:23:58 -0700 [GTK] [WK2] Fix for getting editor client commands. 2011-07-17 22:33:31 -0700 1 1 1 Unclassified WebKit WebKitGTK 528+ (Nightly build) All Linux RESOLVED FIXED P2 Normal --- 0 l.slachciak webkit-unassigned amruthraj cgarcia mrobinson ravi.kasibhatla webkit.review.bot oldest_to_newest 424588 0 l.slachciak 2011-06-21 11:23:58 -0700 In WebKit2 GTK keyboard event type was always set as KeyDown for command list. Additionally removed incorrect ASSERT causing build break on the WebKit2 Gtk debug build. Please check attached patch. 424593 1 98017 l.slachciak 2011-06-21 11:27:48 -0700 Created attachment 98017 Keyboard event patch 1 424598 2 l.slachciak 2011-06-21 11:30:41 -0700 Martin, I subscribed you because git says me that you are author of original code. Please take a look on this simple patch. 424613 3 98017 mrobinson 2011-06-21 11:41:18 -0700 Comment on attachment 98017 Keyboard event patch 1 Just removing the ASSERT is incorrect here. What type of events are passed to this function? If it's only KeyDown and KeyUp we need a comment explaining why a native KeyUp event is equivalent to a DOM keypress event. The ASSERT should be updated, since the following line only handles two types of events. 424631 4 l.slachciak 2011-06-21 11:52:34 -0700 As my checks show only key down are passed. Trying to find why key up are not passed too. I'll investigate it more and update ASSERT. 427510 5 l.slachciak 2011-06-26 06:44:31 -0700 After some investigation I get why GTK port tries to interpret commands only for KeyDown event. This is because whole command interpretation is done at UIProcess site. But e.g in Qt port it is done at WebProcess site. But let\s start from the beginning: exemplary execution log is following: (I'm putting "d" with keyboard in google search box) webkitWebViewBaseKeyPressEvent WebPageProxy::handleKeyboardEvent: KeyDown WebEditorClient::handleKeyboardEvent: keydown WebEditorClient::getEditorCommandsForKeyEvent: keydown (message sync) WebPageProxy::getEditorCommandsForKeyEvent - commandsList PageClientImpl::getEditorCommandsForKeyEvent: KeyDown WebEditorClient::handleKeyboardEvent: keypress WebEditorClient::getEditorCommandsForKeyEvent: keypress (message sync) WebPageProxy::getEditorCommandsForKeyEvent - commandsList PageClientImpl::getEditorCommandsForKeyEvent: KeyDown WebEditorClient::handleKeyboardEvent inserting text d WebPageProxy::didReceiveEvent: KeyDown webkitWebViewBaseKeyReleaseEvent WebPageProxy::handleKeyboardEvent: KeyUp WebPageProxy::didReceiveEvent: KeyUp As you can see for original KeyPress event, two events are generated by WebPageProxy::handleKeyboardEvent: KeyDown In fact it is EventHandler::keyEvent who do this. For KeyDown event it generates two events: keydown and keypress which are handled by WebEditorClient::handleKeyboardEvent. When WebEditorClient sends sync message to UI process (Messages::WebPageProxy::GetEditorCommandsForKeyEvent()) it expects that he will get those commands for current event. In the first communication it is not problem. WebPageProxy takes first event from m_keyEventQueue (KeyDown) and calls PageClientImpl::getEditorCommandsForKeyEvent. But in the second case, after artificially genereated keypress event by EventHandler::keyEvent WebPageProxy doesn't know about it. He will take first event from the queue m_keyEventQueue (KeyDown). In short words: 1. UIProcess gets KeyDown 2. WebProces handles calling EventHandler in WebCore 3. WebCore generates two event keydown and key press 4. Both events are handled by WebProcess 5. For each event WebProcess asks to interpret commands UIProcess. 6. WebProcess for command interpretation uses current event stored in m_keyEventQueue (which is KeyDown in both cases) AND THIS IS A PROBLEM 7. UIProcess gets KeyUp 8. For KeyUp event EventHandler::keyEvent says that he will not handle it. As for the patch I can add ASSERT checking if events are KeyDown or KeyPress but as I described logic above KeyPress will never be passed to PageClientImpl::getEditorCommandsForKeyEvent. 427524 6 mrobinson 2011-06-26 08:37:02 -0700 (In reply to comment #5) > As for the patch I can add ASSERT checking if events are > KeyDown or KeyPress > but as I described logic above KeyPress will never be passed to PageClientImpl::getEditorCommandsForKeyEvent. So it looks like this code is buggy. I imagine that we need to pass the actual DOM event through to the UIProcess for it to work properly. 427565 7 l.slachciak 2011-06-26 12:49:54 -0700 I agree. I'm thinking about adding new parameter to WebPageProxy::getEditorCommandsForKeyEvent(Vector<WTF::String>& commandsList) Let's say: WebPageProxy::getEditorCommandsForKeyEvent(const KeyEvent& keyEvent, Vector<WTF::String>& commandsList) WebEditorClient::getEditorCommandsForKeyEvent will send sync message: Messages::WebPageProxy::GetEditorCommandsForKeyEvent(event), Messages::WebPageProxy::GetEditorCommandsForKeyEvent::Reply(pendingEditorCommands), key event will be received by WebPageProxy::getEditorCommandsForKeyEvent and it will call PageClientImpl::getEditorCommandsForKeyEvent I'll prepare patch for all of these. 429608 8 l.slachciak 2011-06-29 08:02:12 -0700 I was thinking about it and tried some different implementations. I ended up with conclusion: Why we really need to push this KeyboardEvent from WebProcess to UIProcess (in sync, blocking way)? What if we could interpret this event just in WebEditorClient::getEditorCommandsForKeyEvent. As I see in code Qt port also make this interpretation at WebProcess site (see WebPage::handleEditingKeyboardEvent) Advantages: - correct KeyboardEvents generated at WebCore site will be processed (not KeyDown NativeWebKeyboardEvent stored in the m_keyEventQueue) - no need to push KeyboardEvent between processes (and write KeyboardEvent coder/encoder for IPC) - no communication overhead 429748 9 mrobinson 2011-06-29 11:43:21 -0700 (In reply to comment #8) > I ended up with conclusion: > Why we really need to push this KeyboardEvent from WebProcess to UIProcess (in sync, blocking way)? We want to avoid instantiating a GtkWidget in the WebProcess. 429779 10 l.slachciak 2011-06-29 12:17:39 -0700 Thx Martin for comment. I think that I have finally found optimal solution. I'll pass from WebProcess to UIProcess eventType. In fact this is what we are missing. We still need to base on the NativeWebKeyboardEvent but for the type which is passed to KeyBindingTranslator we should use KeyboardEvent type obtained from WebProcess. 429807 11 99132 l.slachciak 2011-06-29 13:04:11 -0700 Created attachment 99132 KeyboardEvent type patch This patch implements passing KeyboardEvent type from WebProcess to UIProcess 432652 12 cgarcia 2011-07-05 23:56:55 -0700 *** Bug 62802 has been marked as a duplicate of this bug. *** 438297 13 mrobinson 2011-07-17 10:31:32 -0700 *** Bug 64666 has been marked as a duplicate of this bug. *** 438317 14 99132 mrobinson 2011-07-17 17:50:09 -0700 Comment on attachment 99132 KeyboardEvent type patch Looks good! 438320 15 99132 webkit.review.bot 2011-07-17 18:47:41 -0700 Comment on attachment 99132 KeyboardEvent type patch Clearing flags on attachment: 99132 Committed r91169: <http://trac.webkit.org/changeset/91169> 438321 16 webkit.review.bot 2011-07-17 18:47:47 -0700 All reviewed patches have been landed. Closing bug. 438339 17 mrobinson 2011-07-17 22:33:31 -0700 *** Bug 64667 has been marked as a duplicate of this bug. *** 98017 2011-06-21 11:27:48 -0700 2011-06-29 13:04:11 -0700 Keyboard event patch 1 kb1.patch text/plain 1738 l.slachciak ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCAzNmU1ODYyLi5mNmQ4YmZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDUgKzEsMTgg QEAKIDIwMTEtMDYtMjEgIEx1a2FzeiBTbGFjaGNpYWsgIDxsLnNsYWNoY2lha0BzYW1zdW5nLmNv bT4KIAorICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBbR1RL XSBbV0syXSBGaXggZm9yIGdldHRpbmcgZWRpdG9yIGNsaWVudCBjb21tYW5kcy4KKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTYzMDgxCisKKyAgICAgICAg SW4gV2ViS2l0MiBHVEsgS2V5Ym9hcmQgZXZlbnQgdHlwZSB3YXMgYWx3YXlzIHNldCBhcyBLZXlE b3duIGZvciBjb21tYW5kTGlzdC4KKyAgICAgICAgQWRkaXRpb25hbGx5IHJlbW92ZWQgaW5jb3Jy ZWN0IEFTU0VSVCBjYXVzaW5nIGJ1aWxkIGJyZWFrIG9uIHRoZSBXZWJLaXQyIEd0ayBkZWJ1ZyBi dWlsZC4KKworICAgICAgICAqIFVJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcDoK KyAgICAgICAgKFdlYktpdDo6UGFnZUNsaWVudEltcGw6OmdldEVkaXRvckNvbW1hbmRzRm9yS2V5 RXZlbnQpOiBBc3NlcnQgYW5kIEV2ZW50VHlwZSBmaXguCisKKzIwMTEtMDYtMjEgIEx1a2FzeiBT bGFjaGNpYWsgIDxsLnNsYWNoY2lha0BzYW1zdW5nLmNvbT4KKwogICAgICAgICBSZXZpZXdlZCBi eSBTYW0gV2VpbmlnLgogCiAgICAgICAgIFtHVEtdIFtXSzJdIFdlYktpdDIgYnVpbGQgYnJlYWsg Zml4ZXMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdl Q2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xp ZW50SW1wbC5jcHAKaW5kZXggYWI1NjQ2Zi4uNzQwNWZmYiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9X ZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcApAQCAtNTcsOCArNTcs NyBAQCBQYWdlQ2xpZW50SW1wbDo6flBhZ2VDbGllbnRJbXBsKCkKIAogdm9pZCBQYWdlQ2xpZW50 SW1wbDo6Z2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2Fy ZEV2ZW50JiBldmVudCwgVmVjdG9yPFdURjo6U3RyaW5nPiYgY29tbWFuZExpc3QpCiB7Ci0gICAg QVNTRVJUKGV2ZW50LnR5cGUgPT0gV2ViRXZlbnQ6OktleURvd24gfHwgZXZlbnQudHlwZSA9PSBX ZWJFdmVudC5LZXlQcmVzcyk7Ci0gICAgS2V5QmluZGluZ1RyYW5zbGF0b3I6OkV2ZW50VHlwZSB0 eXBlID0gV2ViRXZlbnQ6OktleURvd24gPyAKKyAgICBLZXlCaW5kaW5nVHJhbnNsYXRvcjo6RXZl bnRUeXBlIHR5cGUgPSBldmVudC50eXBlKCkgPT0gV2ViRXZlbnQ6OktleURvd24gPwogICAgICAg ICBLZXlCaW5kaW5nVHJhbnNsYXRvcjo6S2V5RG93biA6IEtleUJpbmRpbmdUcmFuc2xhdG9yOjpL ZXlQcmVzczsKICAgICBtX2tleUJpbmRpbmdUcmFuc2xhdG9yLmdldEVkaXRvckNvbW1hbmRzRm9y S2V5RXZlbnQoY29uc3RfY2FzdDxHZGtFdmVudEtleSo+KCZldmVudC5uYXRpdmVFdmVudCgpLT5r ZXkpLCB0eXBlLCBjb21tYW5kTGlzdCk7CiB9Cg== 99132 2011-06-29 13:04:11 -0700 2011-07-17 18:47:41 -0700 KeyboardEvent type patch eventtype.patch text/plain 7716 l.slachciak ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQyL0No YW5nZUxvZwppbmRleCBmMTNmNGEyLi5iYWU3MzRmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 Mi9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcg QEAKKzIwMTEtMDYtMjkgIEx1a2FzeiBTbGFjaGNpYWsgIDxsLnNsYWNoY2lha0BzYW1zdW5nLmNv bT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAgW0dU S10gW1dLMl0gRml4IGZvciBnZXR0aW5nIGVkaXRvciBjbGllbnQgY29tbWFuZHMuCisgICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NjMwODEKKworICAgICAg ICAgRWRpdG9yIGNsaWVudCBjb21tYW5kcyBpbnRlcHJldGF0aW9uIHdhcyBpbmNvcnJlY3QuIEl0 IHdhcyBiYXNlZCBvbiB0aGUgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCBvbmx5LgorICAgICAgICAg SW4gZmFjdCBFdmVudEhhbmRsZXIgaXMgZ2VuZXJhdGluZyBpbnRlcnByZXRlZCBldmVudHMgLSBr ZXlwcmVzcyBhbmQga2V5ZG93bi4gVGhlc2UgZXZlbnQgdHlwZXMKKyAgICAgICAgIGFyZSBub3cg cGFzc2VkIGZyb20gVUlQcm9jZXNzIHRvIFdlYlByb2Nlc3Mgc28gS2V5QmluZGluZ1RyYW5zbGF0 b3IgY2FuIGNvcnJlY3RseSBmaW5kIGVkaXRvciBjb21tYW5kcy4KKyAgICAgICAgIEFsc28gYnVp bGQgYnJlYWsgZm9yIERlYnVnIGJ1aWxkIHdhcyBmaXhlZC4KKworICAgICAgICAqIFVJUHJvY2Vz cy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmNwcDogS2V5Ym9hcmRFdmVudCB0eXBlIGlzIHVzZWQg Zm9yIEtleUJpbmRpbmdUcmFuc2xhdG9yLgorICAgICAgICAoV2ViS2l0OjpQYWdlQ2xpZW50SW1w bDo6Z2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudCk6IGdldEVkaXRvckNvbW1hbmRzRm9yS2V5 RXZlbnQgbm93IGhhcyBhZGRpdGlvbmFsCisgICAgICAgIHBhcmFtZXRlciBkZXNjcmliaW5nIEtl eWJvYXJkRXZlbnQgdHlwZS4KKyAgICAgICAgKiBVSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50 SW1wbC5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9QYWdlQ2xpZW50Lmg6CisgICAgICAgICogVUlQ cm9jZXNzL1dlYlBhZ2VQcm94eS5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQYWdlUHJveHku bWVzc2FnZXMuaW46CisgICAgICAgICogVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3Bw OgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmdldEVkaXRvckNvbW1hbmRzRm9yS2V5 RXZlbnQpOiBLZXlib2FyZEV2ZW50IHR5cGUgcGFzc2VkIHRvIFBhZ2VDbGllbnQuCisgICAgICAg ICogV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9ndGsvV2ViRWRpdG9yQ2xpZW50R3RrLmNwcDoK KyAgICAgICAgKFdlYktpdDo6V2ViRWRpdG9yQ2xpZW50OjpnZXRFZGl0b3JDb21tYW5kc0Zvcktl eUV2ZW50KTogU3luYyBtZXNzYWdlIHNlbmQgd2l0aCBLZXlib2FyZEV2ZW50IHR5cGUuCisKIDIw MTEtMDYtMjQgIEFuZGVycyBDYXJsc3NvbiAgPGFuZGVyc2NhQGFwcGxlLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBKb2huIFN1bGxpdmFuLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdDIvVUlQ cm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuY3BwCmluZGV4IGFiNTY0NmYuLjZhNTYwZjEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJ bXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50 SW1wbC5jcHAKQEAgLTU1LDEwICs1NSwxMSBAQCBQYWdlQ2xpZW50SW1wbDo6flBhZ2VDbGllbnRJ bXBsKCkKIHsKIH0KIAotdm9pZCBQYWdlQ2xpZW50SW1wbDo6Z2V0RWRpdG9yQ29tbWFuZHNGb3JL ZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiBldmVudCwgVmVjdG9yPFdURjo6 U3RyaW5nPiYgY29tbWFuZExpc3QpCit2b2lkIFBhZ2VDbGllbnRJbXBsOjpnZXRFZGl0b3JDb21t YW5kc0ZvcktleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50LCBjb25z dCBBdG9taWNTdHJpbmcmIGV2ZW50VHlwZSwgVmVjdG9yPFdURjo6U3RyaW5nPiYgY29tbWFuZExp c3QpCiB7Ci0gICAgQVNTRVJUKGV2ZW50LnR5cGUgPT0gV2ViRXZlbnQ6OktleURvd24gfHwgZXZl bnQudHlwZSA9PSBXZWJFdmVudC5LZXlQcmVzcyk7Ci0gICAgS2V5QmluZGluZ1RyYW5zbGF0b3I6 OkV2ZW50VHlwZSB0eXBlID0gV2ViRXZlbnQ6OktleURvd24gPyAKKyAgICBBU1NFUlQoZXZlbnRU eXBlID09IGV2ZW50TmFtZXMoKS5rZXlkb3duRXZlbnQgfHwgZXZlbnRUeXBlID09IGV2ZW50TmFt ZXMoKS5rZXlwcmVzc0V2ZW50KTsKKworICAgIEtleUJpbmRpbmdUcmFuc2xhdG9yOjpFdmVudFR5 cGUgdHlwZSA9IGV2ZW50VHlwZSA9PSBldmVudE5hbWVzKCkua2V5ZG93bkV2ZW50ID8KICAgICAg ICAgS2V5QmluZGluZ1RyYW5zbGF0b3I6OktleURvd24gOiBLZXlCaW5kaW5nVHJhbnNsYXRvcjo6 S2V5UHJlc3M7CiAgICAgbV9rZXlCaW5kaW5nVHJhbnNsYXRvci5nZXRFZGl0b3JDb21tYW5kc0Zv cktleUV2ZW50KGNvbnN0X2Nhc3Q8R2RrRXZlbnRLZXkqPigmZXZlbnQubmF0aXZlRXZlbnQoKS0+ a2V5KSwgdHlwZSwgY29tbWFuZExpc3QpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9BUEkvZ3RrL1BhZ2VDbGllbnRJbXBsLmgKaW5kZXggZWE1NDg0My4uYmZiZjQ5NyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL0FQSS9ndGsvUGFnZUNsaWVudEltcGwu aAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvQVBJL2d0ay9QYWdlQ2xpZW50SW1wbC5o CkBAIC04Niw3ICs4Niw3IEBAIHByaXZhdGU6CiAgICAgdmlydHVhbCB2b2lkIGRpZENoYW5nZVNj cm9sbGJhcnNGb3JNYWluRnJhbWUoKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgZmxhc2hCYWNr aW5nU3RvcmVVcGRhdGVzKGNvbnN0IFZlY3RvcjxXZWJDb3JlOjpJbnRSZWN0PiYgdXBkYXRlUmVj dHMpOwogICAgIHZpcnR1YWwgZmxvYXQgdXNlclNwYWNlU2NhbGVGYWN0b3IoKSBjb25zdCB7IHJl dHVybiAxOyB9Ci0gICAgdmlydHVhbCB2b2lkIGdldEVkaXRvckNvbW1hbmRzRm9yS2V5RXZlbnQo Y29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIFZlY3RvcjxXVEY6OlN0cmluZz4mKTsKKyAg ICB2aXJ0dWFsIHZvaWQgZ2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBOYXRpdmVX ZWJLZXlib2FyZEV2ZW50JiwgY29uc3QgQXRvbWljU3RyaW5nJiwgVmVjdG9yPFdURjo6U3RyaW5n PiYpOwogICAgIHZpcnR1YWwgdm9pZCBmaW5kU3RyaW5nSW5DdXN0b21SZXByZXNlbnRhdGlvbihj b25zdCBTdHJpbmcmLCBGaW5kT3B0aW9ucywgdW5zaWduZWQpOwogICAgIHZpcnR1YWwgdm9pZCBj b3VudFN0cmluZ01hdGNoZXNJbkN1c3RvbVJlcHJlc2VudGF0aW9uKGNvbnN0IFN0cmluZyYsIEZp bmRPcHRpb25zLCB1bnNpZ25lZCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9QYWdlQ2xpZW50LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvUGFnZUNsaWVudC5o CmluZGV4IGY3YmRjMmEuLjZlMzZmMzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9QYWdlQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1BhZ2VDbGll bnQuaApAQCAtMTI5LDcgKzEyOSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgY29tcG9z aXRpb25TZWxlY3Rpb25DaGFuZ2VkKGJvb2wpID0gMDsKICNlbmRpZgogI2lmIFBMQVRGT1JNKEdU SykKLSAgICB2aXJ0dWFsIHZvaWQgZ2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBO YXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgVmVjdG9yPFdURjo6U3RyaW5nPiYpID0gMDsKKyAgICB2 aXJ0dWFsIHZvaWQgZ2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBOYXRpdmVXZWJL ZXlib2FyZEV2ZW50JiwgY29uc3QgQXRvbWljU3RyaW5nJiwgVmVjdG9yPFdURjo6U3RyaW5nPiYp ID0gMDsKICNlbmRpZgogICAgIHZpcnR1YWwgV2ViQ29yZTo6RmxvYXRSZWN0IGNvbnZlcnRUb0Rl dmljZVNwYWNlKGNvbnN0IFdlYkNvcmU6OkZsb2F0UmVjdCYpID0gMDsKICAgICB2aXJ0dWFsIFdl YkNvcmU6OkZsb2F0UmVjdCBjb252ZXJ0VG9Vc2VyU3BhY2UoY29uc3QgV2ViQ29yZTo6RmxvYXRS ZWN0JikgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCmluZGV4IDI2 MTJkOWEuLjUzMDBkYWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQ YWdlUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgK QEAgLTY3MCw3ICs2NzAsMTAgQEAgcHJpdmF0ZToKICAgICB2b2lkIGV4ZWN1dGVTYXZlZENvbW1h bmRCeVNlbGVjdG9yKGNvbnN0IFN0cmluZyYgc2VsZWN0b3IsIGJvb2wmIGhhbmRsZWQpOwogI2Vu ZGlmCiAKLSNpZiBQTEFURk9STShHVEspIHx8IFBMQVRGT1JNKEVGTCkKKyNpZiBQTEFURk9STShH VEspCisgICAgdm9pZCBnZXRFZGl0b3JDb21tYW5kc0ZvcktleUV2ZW50KGNvbnN0IEF0b21pY1N0 cmluZyYsIFZlY3RvcjxTdHJpbmc+Jik7CisjZW5kaWYKKyNpZiBQTEFURk9STShFRkwpCiAgICAg dm9pZCBnZXRFZGl0b3JDb21tYW5kc0ZvcktleUV2ZW50KFZlY3RvcjxTdHJpbmc+Jik7CiAjZW5k aWYKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5t ZXNzYWdlcy5pbiBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkubWVzc2Fn ZXMuaW4KaW5kZXggN2QwZmQ5OC4uMjA2NDI4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5tZXNzYWdlcy5pbgorKysgYi9Tb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5Lm1lc3NhZ2VzLmluCkBAIC0xMzUsNyArMTM1LDcgQEAgbWVz c2FnZXMgLT4gV2ViUGFnZVByb3h5IHsKIAogI2lmIFBMQVRGT1JNKEdUSykKICAgICAjIFN1cHBv cnQgZm9yIEdUSysgcGxhdGZvcm0ga2V5YmluZGluZ3MKLSAgICBHZXRFZGl0b3JDb21tYW5kc0Zv cktleUV2ZW50KCkgLT4gKFZlY3RvcjxXVEY6OlN0cmluZz4gY29tbWFuZHNMaXN0KQorICAgIEdl dEVkaXRvckNvbW1hbmRzRm9yS2V5RXZlbnQoQXRvbWljU3RyaW5nIGV2ZW50VHlwZSkgLT4gKFZl Y3RvcjxXVEY6OlN0cmluZz4gY29tbWFuZHNMaXN0KQogI2VuZGlmCiAKICAgICAjIEJhY2tGb3J3 YXJkIG1lc3NhZ2VzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dl YlBhZ2VQcm94eUd0ay5jcHAgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvZ3RrL1dlYlBhZ2VQ cm94eUd0ay5jcHAKaW5kZXggMzkzYjRjNy4uMTEyN2RkZSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL2d0ay9XZWJQYWdlUHJveHlHdGsuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9ndGsvV2ViUGFnZVByb3h5R3RrLmNwcApAQCAtNDQsOSArNDQsOSBAQCBT dHJpbmcgV2ViUGFnZVByb3h5OjpzdGFuZGFyZFVzZXJBZ2VudChjb25zdCBTdHJpbmcmIGFwcGxp Y2F0aW9uTmFtZUZvclVzZXJBZ2VudAogICAgIHJldHVybiAiTW96aWxsYS81LjAgKFgxMTsgTGlu dXggaTY4NikgQXBwbGVXZWJLaXQvNTM0LjcgKEtIVE1MLCBsaWtlIEdlY2tvKSBWZXJzaW9uLzUu MCBTYWZhcmkvNTM0LjciOwogfQogCi12b2lkIFdlYlBhZ2VQcm94eTo6Z2V0RWRpdG9yQ29tbWFu ZHNGb3JLZXlFdmVudChWZWN0b3I8V1RGOjpTdHJpbmc+JiBjb21tYW5kc0xpc3QpCit2b2lkIFdl YlBhZ2VQcm94eTo6Z2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBBdG9taWNTdHJp bmcmIGV2ZW50VHlwZSwgVmVjdG9yPFdURjo6U3RyaW5nPiYgY29tbWFuZHNMaXN0KQogewotICAg IG1fcGFnZUNsaWVudC0+Z2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChtX2tleUV2ZW50UXVl dWUuZmlyc3QoKSwgY29tbWFuZHNMaXN0KTsKKyAgICBtX3BhZ2VDbGllbnQtPmdldEVkaXRvckNv bW1hbmRzRm9yS2V5RXZlbnQobV9rZXlFdmVudFF1ZXVlLmZpcnN0KCksIGV2ZW50VHlwZSwgY29t bWFuZHNMaXN0KTsKIH0KIAogdm9pZCBXZWJQYWdlUHJveHk6OnNhdmVSZWNlbnRTZWFyY2hlcyhj b25zdCBTdHJpbmcmLCBjb25zdCBWZWN0b3I8U3RyaW5nPiYpCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L2d0ay9XZWJFZGl0b3JDbGllbnRHdGsu Y3BwIGIvU291cmNlL1dlYktpdDIvV2ViUHJvY2Vzcy9XZWJDb3JlU3VwcG9ydC9ndGsvV2ViRWRp dG9yQ2xpZW50R3RrLmNwcAppbmRleCBjMDU1ODliLi40MWM3ZTQ2IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViS2l0Mi9XZWJQcm9jZXNzL1dlYkNvcmVTdXBwb3J0L2d0ay9XZWJFZGl0b3JDbGllbnRH dGsuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQyL1dlYlByb2Nlc3MvV2ViQ29yZVN1cHBvcnQvZ3Rr L1dlYkVkaXRvckNsaWVudEd0ay5jcHAKQEAgLTM2LDggKzM2LDkgQEAgdm9pZCBXZWJFZGl0b3JD bGllbnQ6OmdldEVkaXRvckNvbW1hbmRzRm9yS2V5RXZlbnQoY29uc3QgS2V5Ym9hcmRFdmVudCog ZXZlbnQsIFYKIHsKICAgICBBU1NFUlQoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkua2V5 ZG93bkV2ZW50IHx8IGV2ZW50LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleXByZXNzRXZlbnQp OwogCi0gICAgLy8gRmlyc3QgdHJ5IHRvIGludGVycHJldCB0aGUgY29tbWFuZCBpbiB0aGUgVUkg YW5kIGdldCB0aGUgY29tbWFuZHMuCi0gICAgV2ViUHJvY2Vzczo6c2hhcmVkKCkuY29ubmVjdGlv bigpLT5zZW5kU3luYyhNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpHZXRFZGl0b3JDb21tYW5kc0Zv cktleUV2ZW50KCksCisgICAgLyogRmlyc3QgdHJ5IHRvIGludGVycHJldCB0aGUgY29tbWFuZCBp biB0aGUgVUkgYW5kIGdldCB0aGUgY29tbWFuZHMuCisgICAgICAgVUkgbmVlZHMgdG8gcmVjZWl2 ZSBldmVudCB0eXBlIGJlY2F1c2Ugb25seSBrbm93cyBjdXJyZW50IE5hdGl2ZVdlYktleWJvYXJk RXZlbnQuKi8KKyAgICBXZWJQcm9jZXNzOjpzaGFyZWQoKS5jb25uZWN0aW9uKCktPnNlbmRTeW5j KE1lc3NhZ2VzOjpXZWJQYWdlUHJveHk6OkdldEVkaXRvckNvbW1hbmRzRm9yS2V5RXZlbnQoZXZl bnQtPnR5cGUoKSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBNZXNzYWdlczo6V2ViUGFnZVByb3h5OjpHZXRFZGl0b3JDb21tYW5kc0ZvcktleUV2ZW50 OjpSZXBseShwZW5kaW5nRWRpdG9yQ29tbWFuZHMpLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgbV9wYWdlLT5wYWdlSUQoKSwgQ29yZUlQQzo6Q29ubmVj dGlvbjo6Tm9UaW1lb3V0KTsKIH0K