58374 2011-04-12 13:56:25 -0700 WebKit2: Clients have to know not to call TranslateMessage() on key messages destined for WebKit2 web views 2014-01-28 20:17:45 -0800 1 1 1 Unclassified WebKit WebKit2 528+ (Nightly build) PC Windows 7 RESOLVED INVALID InRadar P2 Normal --- 1 jeffm jeffm andersca ap aroben jeffm webkit.review.bot oldest_to_newest 384337 0 jeffm 2011-04-12 13:56:25 -0700 As described in bug 56020, Windows clients of WebKit2 have to know not to call TranslateMessage() on key messages destined for WebKit2 web views. This is because WebKit2 handles messages asynchronously in the web process, and we don't want to call TranslateMessage() if the WM_KEYDOWN was actually handled by WebKit2 so things like pressing tab in the Web Inspector's console cycles through completion options (as opposed to inserting a tab because TranslateMessage() generates a WM_CHAR message from the WM_KEYDOWN). If the client installs a WKPageUIClient, it's didNotHandleKeyEvent callback gets called in this case, but things like the Web Inspector typically won't have a WKPageUIClient installed. The fact that clients have to know not to call TranslateMessage() seems prone to error, we should figure out a better solution to this. 384407 1 jeffm 2011-04-12 14:56:06 -0700 <rdar://problem/9274510> 407324 2 jeffm 2011-05-20 14:23:51 -0700 One reason we need to fix this is that client apps can't really control whether TranslateMessage() is called in all cases. For example, when Windows pumps messages during MessageBox() and DialogBox(), TranslateMessage() will always be called. It's also possible for non-application code (e.g. a third-party DLL) to pump messages in the application's process, which is out of the application's control. 407325 3 jeffm 2011-05-20 14:25:06 -0700 The net result is that TranslateMessage() could be called multiple times for the same WM_KEYDOWN, which generates duplicate WM_CHAR messages and leads to symptoms like a character being typed twice in an edit field. 407691 4 94351 jeffm 2011-05-22 12:01:05 -0700 Created attachment 94351 Patch 407693 5 jeffm 2011-05-22 12:28:24 -0700 Hmm, I just realized I need to at least make sure that the WM_CHAR message is for the same HWND as the WM_KEYDOWN, so this patch should probably be r-'d. However, I'm still interested in feedback about this design in general. 407700 6 ap 2011-05-22 13:48:07 -0700 It is very suspicious that WM_UNICHAR messages aren't handled here. I don't really know when these are dispatched in practice, but they probably are? 407705 7 jeffm 2011-05-22 14:26:17 -0700 (In reply to comment #6) > It is very suspicious that WM_UNICHAR messages aren't handled here. I don't really know when these are dispatched in practice, but they probably are? <http://msdn.microsoft.com/en-us/library/ms646288(v=vs.85).aspx> says that WM_UNICHAR messages can be posted by TranslateMessage(). However, note that this code deals with WebEvents, not Windows messages. Specifically, WebEvent::Char events are generated from WM_CHAR, WM_SYSCHAR, and WM_IME_CHAR messages by WebEventFactory. I don't know if the fact that WebEventFactory doesn't handle WM_UNICHAR is a bug or not, but that's a separate issue. Since this code deals with WebEvents, and Windows message that's encapsulated by a WebEvent::Char event will be handled. 407706 8 jeffm 2011-05-22 14:31:12 -0700 (In reply to comment #7) > (In reply to comment #6) > > It is very suspicious that WM_UNICHAR messages aren't handled here. I don't really know when these are dispatched in practice, but they probably are? > > <http://msdn.microsoft.com/en-us/library/ms646288(v=vs.85).aspx> says that WM_UNICHAR messages can be posted by TranslateMessage(). However, note that this code deals with WebEvents, not Windows messages. Specifically, WebEvent::Char events are generated from WM_CHAR, WM_SYSCHAR, and WM_IME_CHAR messages by WebEventFactory. I don't know if the fact that WebEventFactory doesn't handle WM_UNICHAR is a bug or not, but that's a separate issue. Since this code deals with WebEvents, and Windows message that's encapsulated by a WebEvent::Char event will be handled. Now that I look more closely, it looks like WebView::wndProc() doesn't handle WM_UNICHAR messages, which means there is no infrastructure in WK2 for notifying the web process about these. There should probably be a separate bug on this. 408098 9 aroben 2011-05-23 11:18:43 -0700 (In reply to comment #8) > (In reply to comment #7) > > (In reply to comment #6) > > > It is very suspicious that WM_UNICHAR messages aren't handled here. I don't really know when these are dispatched in practice, but they probably are? > > > > <http://msdn.microsoft.com/en-us/library/ms646288(v=vs.85).aspx> says that WM_UNICHAR messages can be posted by TranslateMessage(). However, note that this code deals with WebEvents, not Windows messages. Specifically, WebEvent::Char events are generated from WM_CHAR, WM_SYSCHAR, and WM_IME_CHAR messages by WebEventFactory. I don't know if the fact that WebEventFactory doesn't handle WM_UNICHAR is a bug or not, but that's a separate issue. Since this code deals with WebEvents, and Windows message that's encapsulated by a WebEvent::Char event will be handled. > > Now that I look more closely, it looks like WebView::wndProc() doesn't handle WM_UNICHAR messages, which means there is no infrastructure in WK2 for notifying the web process about these. There should probably be a separate bug on this. Some pages from a Google search for "WM_UNICHAR" make me think that WM_UNICHAR is never sent to windows created with ::CreateWindowExW. These windows are supposedly already Unicode-aware so just get Unicode characters through WM_CHAR. 408101 10 94351 aroben 2011-05-23 11:23:52 -0700 Comment on attachment 94351 Patch The general approach here seems fine. It took me a little while to understand the queue-of-queues, perhaps partly because m_unsentCharEventQueue sounds like it is itself a queue of Char events (when instead it is a queue of UnsentCharEvents). We could perhaps make this simpler by assigning a unique ID to every WebKeyboardEvent and recording which RawKeyDown event ID each Char event corresponds with. Then you'd only need a single queue that held all Char events. When you get a didReceiveEvent for a RawKeyDown event you would just dequeue Char events until they stop matching the RawKeyDown event's ID. 408102 11 jeffm 2011-05-23 11:25:06 -0700 (In reply to comment #10) > (From update of attachment 94351 [details]) > The general approach here seems fine. It took me a little while to understand the queue-of-queues, perhaps partly because m_unsentCharEventQueue sounds like it is itself a queue of Char events (when instead it is a queue of UnsentCharEvents). > > We could perhaps make this simpler by assigning a unique ID to every WebKeyboardEvent and recording which RawKeyDown event ID each Char event corresponds with. Then you'd only need a single queue that held all Char events. When you get a didReceiveEvent for a RawKeyDown event you would just dequeue Char events until they stop matching the RawKeyDown event's ID. Good idea, I'll see if I can do this. 408139 12 aroben 2011-05-23 12:22:16 -0700 (In reply to comment #10) > (From update of attachment 94351 [details]) > We could perhaps make this simpler by assigning a unique ID to every WebKeyboardEvent and recording which RawKeyDown event ID each Char event corresponds with. Then you'd only need a single queue that held all Char events. When you get a didReceiveEvent for a RawKeyDown event you would just dequeue Char events until they stop matching the RawKeyDown event's ID. An even simpler idea is to store the RawKeyDown events in the queue, too. Then you'd just dequeue until you hit a RawKeyDown. 408181 13 jeffm 2011-05-23 12:58:08 -0700 (In reply to comment #12) > (In reply to comment #10) > > (From update of attachment 94351 [details] [details]) > > We could perhaps make this simpler by assigning a unique ID to every WebKeyboardEvent and recording which RawKeyDown event ID each Char event corresponds with. Then you'd only need a single queue that held all Char events. When you get a didReceiveEvent for a RawKeyDown event you would just dequeue Char events until they stop matching the RawKeyDown event's ID. > > An even simpler idea is to store the RawKeyDown events in the queue, too. Then you'd just dequeue until you hit a RawKeyDown. This assumes an explicit ordering of RawKeyDown and Char events, but since there's no other way to associate a Char event with a RawKeyDown that's probably OK. We still need to keep track of whether the last RawKeyDown was handled when the queue was exhausted, since we could get called back from the web process in didReceiveKeyDown() for a RawKeyDown before handleKeyboardEvent() has been called for all the Char messages that correspond to the RawKeyDown. 408186 14 jeffm 2011-05-23 12:59:30 -0700 (In reply to comment #5) > Hmm, I just realized I need to at least make sure that the WM_CHAR message is for the same HWND as the WM_KEYDOWN, so this patch should probably be r-'d. However, I'm still interested in feedback about this design in general. Strike that, since the WebPageProxy is tied to a specific HWND, any Windows messages it processes are always going to be for the same window. 408189 15 jeffm 2011-05-23 13:03:30 -0700 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > (In reply to comment #6) > > > > It is very suspicious that WM_UNICHAR messages aren't handled here. I don't really know when these are dispatched in practice, but they probably are? > > > > > > <http://msdn.microsoft.com/en-us/library/ms646288(v=vs.85).aspx> says that WM_UNICHAR messages can be posted by TranslateMessage(). However, note that this code deals with WebEvents, not Windows messages. Specifically, WebEvent::Char events are generated from WM_CHAR, WM_SYSCHAR, and WM_IME_CHAR messages by WebEventFactory. I don't know if the fact that WebEventFactory doesn't handle WM_UNICHAR is a bug or not, but that's a separate issue. Since this code deals with WebEvents, and Windows message that's encapsulated by a WebEvent::Char event will be handled. > > > > Now that I look more closely, it looks like WebView::wndProc() doesn't handle WM_UNICHAR messages, which means there is no infrastructure in WK2 for notifying the web process about these. There should probably be a separate bug on this. > > Some pages from a Google search for "WM_UNICHAR" make me think that WM_UNICHAR is never sent to windows created with ::CreateWindowExW. These windows are supposedly already Unicode-aware so just get Unicode characters through WM_CHAR. I tested my patch using a Chinese input method to fill in a form field, which works, but interestingly WebPageProxy::handleKeyboardEvent() is never called with a Char event when the IME composition is committed. I'm not sure how this is working. 408195 16 ap 2011-05-23 13:10:42 -0700 Besides supporting ANSI windows, WM_UNICHAR is documented to use UTF-32. So, (1) WM_CHAR cannot always be used even in Unicode applications, since it's limited to 16 bits, and (2) you'd need a keyboard layout that generates characters from Unicode Supplementary Plane to test WM_UNICHAR. Inline input uses a different set of messages (composition ones), so it's expected that WM_CHAR wasn't sent for Chinese. 408198 17 ap 2011-05-23 13:14:34 -0700 This looks like a must read document (which I didn't see before): <http://seit.unsw.adfa.edu.au/staff/sites/hrp/personal/Sanskrit-External/Unicode-KbdsonWindows.pdf>. 408200 18 jeffm 2011-05-23 13:16:24 -0700 (In reply to comment #16) > Besides supporting ANSI windows, WM_UNICHAR is documented to use UTF-32. So, > (1) WM_CHAR cannot always be used even in Unicode applications, since it's limited to 16 bits, > and (2) you'd need a keyboard layout that generates characters from Unicode Supplementary Plane to test WM_UNICHAR. > > Inline input uses a different set of messages (composition ones), so it's expected that WM_CHAR wasn't sent for Chinese. D'oh, I knew that. Yes, IME composition is being handled by the WebView itself, e.g. WebView::onIMEEndComposition(). Thanks for the additional information on WM_UNICHAR. Based on a FIXME comment in the WK1 version of WebView::WebViewWndProc() (which unfortunately doesn't mention a bug number), it appears that WM_UNICHAR has never been handled, even in WK1. 411035 19 jeffm 2011-05-26 17:12:22 -0700 I wrote up bug 61588 to cover adding a key handling logging channel, which will help with this bug. 415049 20 95937 jeffm 2011-06-03 11:49:52 -0700 Created attachment 95937 Queue key events until we know whether the RawKeyDown was processed by WebKit 415051 21 95938 jeffm 2011-06-03 11:50:51 -0700 Created attachment 95938 Remove old key handling test and add a new one, and update MiniBrowser to always call TranslateMessage() again 415054 22 webkit.review.bot 2011-06-03 11:52:31 -0700 Attachment 95937 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebKit2/ChangeLog', u'Source/WebKit..." exit_code: 1 Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:47: Should have only a single space after a punctuation in a comment. [whitespace/comments] [5] Total errors found: 1 in 4 files If any of these errors are false positives, please file a bug against check-webkit-style. 415056 23 jeffm 2011-06-03 11:54:37 -0700 (In reply to comment #22) > Attachment 95937 [details] did not pass style-queue: > > Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebKit2/ChangeLog', u'Source/WebKit..." exit_code: 1 > > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:47: Should have only a single space after a punctuation in a comment. [whitespace/comments] [5] > Total errors found: 1 in 4 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. I'll fix this before landing. 440692 24 95937 aroben 2011-07-21 16:02:10 -0700 Comment on attachment 95937 Queue key events until we know whether the RawKeyDown was processed by WebKit View in context: https://bugs.webkit.org/attachment.cgi?id=95937&action=review I think we might be able to simplify some of the logic. Here's one possibility: UI process receives a key event: add it to the queue, then call a function to send events from the queue to the web process if needed UI process is told web process is finished with an event: remove events from the queue as needed, then call the same send-events function Does that seem like it would work? The send-events and remove-events functions would need a little bit of platform-specific logic, but the higher-level logic could all be shared between all platforms. This would result in non-Windows platforms queueing events and then immediately dequeueing them, but that would likely be OK. I'm not sure if this is the right trade-off, but it might help clean things up. > Source/WebKit2/ChangeLog:24 > + Our current design of making WebKit clients on Windows wait to call TranslateMessage() until they know that > + WebKit didn't handle the key down is untenable, since clients don't always have control over when TranslateMessage() > + is called (e.g. when Windows pumps messages in DialogBox() or MessageBox()). Instead, WebKit now assumes that clients > + always call TranslateMessage() immediately. > + > + This means that WebPageProxy in the UI process needs to queue up key events that follow a RawKeyDown event > + (the equivalent of a WM_KEYDOWN message) until the web process informs it whether the RawKeyDown event was handled. > + If WebKit handled the event, WebPageProxy drops any Char events that were received after the RawKeyDown. > + If WebKit didn't handle the event, WebPageProxy sends any queued Char events for the RawKeyDown to the web process. > + In either case, it always sends any KeyUp events. Finally, if an additional RawKeyDown event was received while the current > + RawKeyDown was in process, it sends that event as well. > + > + Unfortunately, there's no way to determine that a WM_CHAR message was generated from calling TranslateMessage() with a > + specific WM_KEYDOWN message. We just associate any Char event that's received with the last unprocessed RawKeyDown we've seen. > + Generally, any RawKeyDown event should eventually be followed by a KeyUp event, but while we can use this as a hint that > + the transaction is complete, there's no guarantee that a KeyUp will always be sent. This explanation is great! > Source/WebKit2/ChangeLog:28 > + In theory, someone could artificially send a WM_CHAR message to the web view without a WM_KEYDOWN, so I tried to account for this > + possibility as well by limiting the amount of time we swallow Char events when the last RawKeyDown was handled by WebKit to 1 second. > + If we get a KeyUp event, which is what typically happens, this timeout isn't necessary. Is this just trying to account for artificially-generated events, or do we think this situation can arise in actual use? If it's just the former, I'm not sure how necessary it is. (We could always add it later if we found it really was necessary.) Even if we do really want the timeout now, it might be clearer to add it in a separate patch. > Source/WebKit2/UIProcess/WebPageProxy.cpp:2773 > if (m_uiClient.implementsDidNotHandleKeyEvent()) > m_uiClient.didNotHandleKeyEvent(this, event); Do we still need didNotHandleKeyEvent? > Source/WebKit2/UIProcess/WebPageProxy.h:663 > + void doneWithKeyEvent(const NativeWebKeyboardEvent&, bool); > + void processKeyEvents(bool); Should we use enums instead of booleans? 440701 25 aroben 2011-07-21 16:08:56 -0700 (In reply to comment #24) > (From update of attachment 95937 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=95937&action=review > > I think we might be able to simplify some of the logic. Here's one possibility: > > UI process receives a key event: add it to the queue, then call a function to send events from the queue to the web process if needed > UI process is told web process is finished with an event: remove events from the queue as needed, then call the same send-events function > > Does that seem like it would work? The send-events and remove-events functions would need a little bit of platform-specific logic, but the higher-level logic could all be shared between all platforms. This would result in non-Windows platforms queueing events and then immediately dequeueing them, but that would likely be OK. I'm not sure if this is the right trade-off, but it might help clean things up. Here's a better way of phrasing this: On all platforms, key event dispatch follow this pattern: 1. Key event enters the UI process 2. The UI process queues the event 3. The UI process sends all appropriate queued events to the web process 4. The web process tells the UI process it is finished with an event 5. The UI process sends all appropriate queued events to the web process The only Windows-specific bits would be in steps 2 and 5. In step 2, on Windows we'd sometimes decide not to send certain events to the web process yet. In step 5, we'd sometimes decide to remove some events from the queue without sending them to the web process. 440981 26 95937 jeffm 2011-07-22 10:03:09 -0700 Comment on attachment 95937 Queue key events until we know whether the RawKeyDown was processed by WebKit View in context: https://bugs.webkit.org/attachment.cgi?id=95937&action=review >> Source/WebKit2/ChangeLog:28 >> + If we get a KeyUp event, which is what typically happens, this timeout isn't necessary. > > Is this just trying to account for artificially-generated events, or do we think this situation can arise in actual use? If it's just the former, I'm not sure how necessary it is. (We could always add it later if we found it really was necessary.) Even if we do really want the timeout now, it might be clearer to add it in a separate patch. It is the former, certainly with Safari as a client this isn't necessary. I will remove this (along with the test I added to simulate this situation). As you said, we can always add it later if it turns out to be necessary. >> Source/WebKit2/UIProcess/WebPageProxy.cpp:2773 >> m_uiClient.didNotHandleKeyEvent(this, event); > > Do we still need didNotHandleKeyEvent? No, we don't. I was concerned about compatibility with Safari 5.1 if I removed this, but after talking to you and Anders it appears there is a way to do this while continuing to allow Safari 5.1 to work with WebKit nightlies. In any case, that change merits a separate bug, which I'll file after landing this patch. >> Source/WebKit2/UIProcess/WebPageProxy.h:663 >> + void processKeyEvents(bool); > > Should we use enums instead of booleans? Good point, I will change this. >> Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:47 >> +// Normally, a Char event will be generated from a RawKeyDown event, and will arrive close to the RawKeyDown event. However, just in case > > Should have only a single space after a punctuation in a comment. [whitespace/comments] [5] Fixed. 440982 27 jeffm 2011-07-22 10:04:34 -0700 (In reply to comment #25) > (In reply to comment #24) > > (From update of attachment 95937 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=95937&action=review > > > > I think we might be able to simplify some of the logic. Here's one possibility: > > > > UI process receives a key event: add it to the queue, then call a function to send events from the queue to the web process if needed > > UI process is told web process is finished with an event: remove events from the queue as needed, then call the same send-events function > > > > Does that seem like it would work? The send-events and remove-events functions would need a little bit of platform-specific logic, but the higher-level logic could all be shared between all platforms. This would result in non-Windows platforms queueing events and then immediately dequeueing them, but that would likely be OK. I'm not sure if this is the right trade-off, but it might help clean things up. > > Here's a better way of phrasing this: > > On all platforms, key event dispatch follow this pattern: > 1. Key event enters the UI process > 2. The UI process queues the event > 3. The UI process sends all appropriate queued events to the web process > 4. The web process tells the UI process it is finished with an event > 5. The UI process sends all appropriate queued events to the web process > > The only Windows-specific bits would be in steps 2 and 5. In step 2, on Windows we'd sometimes decide not to send certain events to the web process yet. In step 5, we'd sometimes decide to remove some events from the queue without sending them to the web process. Adam and I discussed this offline, and I think I understand his proposal. I will submit a new patch, along with the other changes noted in my last comment. 440993 28 ap 2011-07-22 10:35:06 -0700 Can TranslateMessage change application state, or does it only dispatch a translated message? I'm worried about state such as dead keys being changed even if keydown event is canceled by DOM. 441040 29 aroben 2011-07-22 11:17:01 -0700 (In reply to comment #28) > Can TranslateMessage change application state, or does it only dispatch a translated message? I'm worried about state such as dead keys being changed even if keydown event is canceled by DOM. I think it only dispatches a translated message. I believe key state is handled at a lower level that is not affected by TranslateMessage. But we should definitely test dead keys and anything else we can think of after this change. 441268 30 101790 jeffm 2011-07-22 16:44:35 -0700 Created attachment 101790 Take 2: Queue key events until we know whether the RawKeyDown was processed by WebKit 441270 31 101792 jeffm 2011-07-22 16:45:25 -0700 Created attachment 101792 Take 2: Remove old key handling test and add a new one, and update MiniBrowser to always call TranslateMessage() again 441273 32 webkit.review.bot 2011-07-22 16:46:52 -0700 Attachment 101790 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebKit2/ChangeLog', u'Source/WebKit..." exit_code: 1 Source/WebKit2/UIProcess/WebPageProxy.h:710: The parameter name "type" adds no information, so it should be removed. [readability/parameter_name] [5] Total errors found: 1 in 5 files If any of these errors are false positives, please file a bug against check-webkit-style. 441278 33 jeffm 2011-07-22 16:50:12 -0700 (In reply to comment #32) > Attachment 101790 [details] did not pass style-queue: > > Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebKit2/ChangeLog', u'Source/WebKit..." exit_code: 1 > > Source/WebKit2/UIProcess/WebPageProxy.h:710: The parameter name "type" adds no information, so it should be removed. [readability/parameter_name] [5] > Total errors found: 1 in 5 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. Fixed. 441298 34 101790 aroben 2011-07-22 17:30:51 -0700 Comment on attachment 101790 Take 2: Queue key events until we know whether the RawKeyDown was processed by WebKit View in context: https://bugs.webkit.org/attachment.cgi?id=101790&action=review > Source/WebKit2/ChangeLog:36 > + (WebKit::WebPageProxy::didReceiveEvent): Move some code to doneWithKeyEvent(). > + (WebKit::WebPageProxy::doneWithKeyEvent): Added. Might be worth mentioning that the ::TranslateMessage() call was intentionally removed as part of this bug fix. Do we need to keep calling ::TranslateMessage() for Safari 5.1? Does it have any WKPageUIClients which don't implement didNotHandleKeyEvent? > Source/WebKit2/UIProcess/WebPageProxy.cpp:988 > +#if !LOG_DISABLED > + if (event.type() == WebEvent::Char) { > +#if PLATFORM(WIN) > + LOG(KeyHandling, "WebPageProxy::sendKeyEventToWebProcess: sending Char (%c)", event.nativeEvent()->wParam); > +#else > + LOG(KeyHandling, "WebPageProxy::sendKeyEventToWebProcess: sending Char"); > +#endif > + } else > + LOG(KeyHandling, "WebPageProxy::sendKeyEventToWebProcess: sending %s", webKeyboardEventTypeString(event.type())); > +#endif // !LOG_DISABLED You could enhance webKeyboardEventTypeString to include the character code, which would simplify this code quite a bit. (You'd probably want to rename that function, too.) > Source/WebKit2/UIProcess/WebPageProxy.h:907 > + bool m_assumeLastRawKeyDownEventWasHandledByWebKit; Maybe "WebPage" would be clearer than "WebKit". This code is part of WebKit, too, after all. Do we really need "assume" in the name? We know the answer for sure, right? We don't have to assume anything: m_webPageHandledLastRawKeyDown > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:88 > + ASSERT(event.type() != WebEvent::KeyDown); Could use ASSERT_ARG here. > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:92 > + // We know that a RawKeyDown is in-flight to the web process if there are any unsent > + // Char and KeyUp events, or if the last key event we sent to the web process was a RawKeyDown. > + bool keyDownIsInFlight = !m_unsentKeyEventQueue.isEmpty() || (!m_sentKeyEventQueue.isEmpty() && (m_sentKeyEventQueue.last().type() == WebEvent::RawKeyDown)); I'm not sure the !m_unsetKeyEventQueue.isEmpty() check is needed. Whenever the unsent queue is non-empty, the last sent event *must* be a RawKeyDown, right? So the second check should be sufficient (and the first could just become an assertion). It seems like the code below this would be quite a bit simpler if it just did something like: if (keyDownIsInFlight) { LOG(something); m_unsentKeyEventQueue.append(event); return false; } That way all the queueing would happen in one place, instead of in a couple. > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:109 > + if ((event.type() != WebEvent::Char) && (event.type() != WebEvent::KeyUp)) { > + ASSERT_NOT_REACHED(); > + return true; > + } We normally leave out the extra parentheses in cases like this, but I don't feel too strongly about it. It would be slightly nicer to put the condition in the assertion too. The assertion might not really be appropriate, though, given that any app on the system can send random messages to us. You could just log something (LOG_ERROR maybe) and bail. > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:112 > + // Queue up any Char or KeyUp events we receive before we know whether the web process has handled the > + // last RawKeyDown the we saw. I'd change "Queue up" to just "Queue" to avoid confusion with "KeyUp" :-) > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:119 > +#if !LOG_DISABLED > + if (event.type() == WebEvent::Char) > + LOG(KeyHandling, "WebPageProxy::shouldSendKeyEventToWebProcess: queueing Char (%c)", event.nativeEvent()->wParam); > + else > + LOG(KeyHandling, "WebPageProxy::shouldSendKeyEventToWebProcess: queueing KeyUp"); > +#endif Again, this could be simplified by enhancing webKeyboardEventTypeString. > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:141 > + // If we get a Char event after WebKit has processed all outstanding RawKeyDown events, we need to > + // drop it on the floor if WebKit handled the last RawKeyDown. In practice, this rarely happens. > + // Usually, we'll get an intervening KeyUp which will invalidate m_assumeLastRawKeyDownEventWasHandledByWebKit. > + if (!m_assumeLastRawKeyDownEventWasHandledByWebKit) { > + // There's no outstanding RawKeyDown, and WebKit didn't handle the last RawKeyDown, so it's OK to send the event. > +#if !LOG_DISABLED > + // It's extremely unusual to receive a Char event without an intervening RawKeyDown, so log this. > + if (m_assumeLastRawKeyDownEventWasHandledByWebKit) > + LOG(KeyHandling, "WebPageProxy::shouldSendKeyEventToWebProcess: received Char for last handled RawKeyDown"); > +#endif > + > + m_assumeLastRawKeyDownEventWasHandledByWebKit = false; > + return true; > + } It seems like this code just collapses to: if (!m_assumeLastRawKeyDownEventWasHandledByWebKit) return true; > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:174 > + if (event.type() != WebEvent::RawKeyDown) { > + // As soon as we get a key event that isn't a RawKeyDown or Char, we can reset m_assumeLastRawKeyDownEventWasHandledByWebKit. > + // In practice, the only other key event we should be generating on Windows is KeyUp. > + ASSERT(event.type() == WebEvent::KeyUp); > + m_assumeLastRawKeyDownEventWasHandledByWebKit = false; > + return; > + } > + > + if (handled) { > + LOG(KeyHandling, "WebPageProxy::platformDoneWithKeyEvent: RawKeyDown handled"); > + > + // Drop any Char events for this RawKeyDown on the floor (but send any KeyUp events). > + sendQueuedKeyEventsToWebProcess(DoNotSendQueuedCharEvents); > + > + // If we get further Char events, we want to drop them on the floor as well. > + m_assumeLastRawKeyDownEventWasHandledByWebKit = m_unsentKeyEventQueue.isEmpty() ? true : false; > + return; > + } > + > + // We didn't handle the RawKeyDown event, so send any Char and KeyUp events we received after the RawKeyDown. > + LOG(KeyHandling, "WebPageProxy::platformDoneWithKeyEvent: RawKeyDown not handled, sending queued key events"); > + sendQueuedKeyEventsToWebProcess(SendQueuedCharEvents); > + m_assumeLastRawKeyDownEventWasHandledByWebKit = false; As we talked about in person, the setting of m_assumeLastRawKeyDownEventWasHandledByWebKit here isn't quite right. Instead we should set it to true as soon as we find out a RawKeyDown was handled, and set it to false whenever a RawKeyDown is sent to the web process. > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:183 > + NativeWebKeyboardEvent event = m_unsentKeyEventQueue.first(); > + > + ASSERT((event.type() == WebEvent::RawKeyDown) || (event.type() == WebEvent::Char) || (event.type() == WebEvent::KeyUp)); > + m_unsentKeyEventQueue.removeFirst(); You can simplify this by using Deque::takeFirst(). > Source/WebKit2/UIProcess/win/WebPageProxyWin.cpp:185 > + if ((shouldSendQueuedCharEvents == SendQueuedCharEvents) || (event.type() != WebEvent::Char)) { This would be a bit clearer as an early-continue. But if you add code to platformDoneWithKeyEvent to pull out the Char events, you won't need this at all. 441310 35 101792 aroben 2011-07-22 18:15:18 -0700 Comment on attachment 101792 Take 2: Remove old key handling test and add a new one, and update MiniBrowser to always call TranslateMessage() again View in context: https://bugs.webkit.org/attachment.cgi?id=101792&action=review > Tools/TestWebKitAPI/Tests/WebKit2/win/key-event-handling.html:38 > + function loaded() > + { > + setFocusToField1(); > + } > + > + addEventListener("load", loaded); You might be able to use the autofocus attribute instead. > Tools/TestWebKitAPI/win/PlatformUtilitiesWin.cpp:59 > +void runUntil(double timeoutInMS) Usually we use double to represent time in seconds. (This is inherited from NS/CFTimeInterval/AbsoluteTime.) I think it would be good to do that here, too. > Tools/TestWebKitAPI/win/PlatformUtilitiesWin.cpp:68 > + DWORD result = ::MsgWaitForMultipleObjectsEx(0, 0, endTime-now, QS_ALLINPUT, MWMO_INPUTAVAILABLE); Missing spaces around '-'. 94351 2011-05-22 12:01:05 -0700 2011-05-23 11:25:27 -0700 Patch bug-58374-20110522120104.patch text/plain 34422 jeffm SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDg3MDM5KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsNTUgQEAKKzIwMTEtMDUtMjIgIEplZmYgTWls bGVyICA8amVmZm1AYXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFdlYktpdDI6IENsaWVudHMgaGF2ZSB0byBrbm93IG5vdCB0byBjYWxs IFRyYW5zbGF0ZU1lc3NhZ2UoKSBvbiBrZXkgbWVzc2FnZXMgZGVzdGluZWQgZm9yIFdlYktpdDIg d2ViIHZpZXdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01ODM3NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vOTI3NDUxMD4gKGFuZCBhbHNvIGZpeGVz IDxyZGFyOi8vcHJvYmxlbS85NDY5MTY1PikKKworICAgICAgICBPdXIgY3VycmVudCBkZXNpZ24g b2YgbWFraW5nIFdlYktpdCBjbGllbnRzIG9uIFdpbmRvd3Mgd2FpdCB0byBjYWxsIFRyYW5zbGF0 ZU1lc3NhZ2UoKSB1bnRpbCB0aGV5IGtub3cgdGhhdCBXZWJLaXQgZGlkbid0IGhhbmRsZSB0aGUg a2V5IGRvd24KKyAgICAgICAgaXMgdW50ZW5hYmxlLCBzaW5jZSBjbGllbnRzIGRvbid0IGFsd2F5 cyBoYXZlIGNvbnRyb2wgb3ZlciB3aGVuIFRyYW5zbGF0ZU1lc3NhZ2UoKSBpcyBjYWxsZWQgKGUu Zy4gd2hlbiBXaW5kb3dzIHB1bXBzIG1lc3NhZ2VzIGluIERpYWxvZ0JveCgpCisgICAgICAgIG9y IE1lc3NhZ2VCb3goKSkuIEluc3RlYWQsIFdlYktpdCBub3cgYXNzdW1lcyB0aGF0IGNsaWVudHMg YWx3YXlzIGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIGltbWVkaWF0ZWx5LgorICAgICAgICAKKyAg ICAgICAgVGhpcyBtZWFucyB0aGF0IFdlYlBhZ2VQcm94eSBpbiB0aGUgVUkgcHJvY2VzcyBuZWVk cyB0byBxdWV1ZSB1cCBXZWJFdmVudDo6Q2hhciBldmVudHMgKHRoZSBlcXVpdmFsZW50IG9mIFdN X0NIQVIgbWVzc2FnZXMpIHVudGlsIHRoZQorICAgICAgICB3ZWIgcHJvY2VzcyBpbmZvcm1zIGl0 IHdoZXRoZXIgdGhlIFdlYkV2ZW50OjpSYXdLZXlEb3duIGV2ZW50ICh0aGUgZXF1aXZhbGVudCBv ZiBhIFdNX0tFWURPV04gbWVzc2FnZSkgd2FzIGhhbmRsZWQuICBJZiBXZWJLaXQgaGFuZGxlZAor ICAgICAgICB0aGUgZXZlbnQsIFdlYlBhZ2VQcm94eSBkcm9wcyBhbnkgV2ViRXZlbnQ6Q2hhciBl dmVudHMgdGhhdCB3ZXJlIHJlY2VpdmVkIGFmdGVyIHRoZSBXZWJFdmVudDo6UmF3S2V5RG93biBv biB0aGUgZmxvb3IuICBJZiBXZWJLaXQgZGlkbid0CisgICAgICAgIGhhbmRsZSB0aGUgZXZlbnQs IFdlYlBhZ2VQcm94eSBzZW5kcyBhbnkgcXVldWVkIFdlYkV2ZW50OjpDaGFyIGV2ZW50cyBmb3Ig dGhlIFdlYkV2ZW50OjpSYXdLZXlEb3duIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAgCisg ICAgICAgIFVuZm9ydHVuYXRlbHksIHRoZXJlJ3Mgbm8gd2F5IHRvIGRldGVybWluZSB0aGF0IGEg V01fQ0hBUiBtZXNzYWdlIHdhcyBnZW5lcmF0ZWQgZnJvbSBjYWxsaW5nIFRyYW5zbGF0ZU1lc3Nh Z2UoKSBvbiBhIHNwZWNpZmljIFdNX0tFWURPV04KKyAgICAgICAgbWVzc2FnZS4gIFdlYktpdCBq dXN0IGFzc29jaWF0ZXMgYW55IFdNX0NIQVIgbWVzc2FnZSB0aGF0J3MgcmVjZWl2ZWQgd2l0aCB0 aGUgbGFzdCB1bnByb2Nlc3NlZCBXTV9LRVlET1dOIG1lc3NhZ2UgaXQncyBzZWVuLgorICAgICAg ICAKKyAgICAgICAgSSBhbHNvIGFkZGVkIGEgbmV3IEtleUhhbmRsaW5nIGxvZ2dpbmcgY2hhbm5l bCBmb3IgV2ViS2l0Mi4KKworICAgICAgICAqIFBsYXRmb3JtL0xvZ2dpbmcuY3BwOgorICAgICAg ICAoV2ViS2l0Ojppbml0aWFsaXplTG9nQ2hhbm5lbHNJZk5lY2Vzc2FyeSk6IEluaXRpYWxpemUg TG9nS2V5SGFuZGxpbmcgY2hhbm5lbC4KKyAgICAgICAgKiBQbGF0Zm9ybS9Mb2dnaW5nLmg6IEFk ZGVkIExvZ0tleUhhbmRsaW5nIGNoYW5uZWwuCisgICAgICAgIAorICAgICAgICAqIFNoYXJlZC9O YXRpdmVXZWJLZXlib2FyZEV2ZW50Lmg6IEFkZGVkIGNvcHkgY29uc3RydWN0b3IgZm9yIFdpbmRv d3MgdmVyc2lvbiBvZiBOYXRpdmVXZWJLZXlib2FyZEV2ZW50LgorICAgICAgICAqIFNoYXJlZC93 aW4vTmF0aXZlV2ViS2V5Ym9hcmRFdmVudFdpbi5jcHA6CisgICAgICAgIChXZWJLaXQ6Ok5hdGl2 ZVdlYktleWJvYXJkRXZlbnQ6Ok5hdGl2ZVdlYktleWJvYXJkRXZlbnQpOiBBZGRlZCBjb3B5IGNv bnN0cnVjdG9yLgorICAgICAgICAKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNw cDogRml4ZWQgbWlzc3BlbGxpbmcgb2YgY29hbGVzY2luZyBpbiBhIGNvbW1lbnQuCisgICAgICAg IChXZWJLaXQ6OndlYktleWJvYXJkRXZlbnRUeXBlU3RyaW5nKTogQWRkZWQgdG8gc3VwcG9ydCBs b2dnaW5nLgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OldlYlBhZ2VQcm94eSk6IElu aXRpYWxpemUgbV9hbHdheXNIYW5kbGVLZXlFdmVudCBhbmQgbV9sYXN0S2V5RG93bkV2ZW50V2Fz SGFuZGxlZEJ5V2ViS2l0IG9uIFdpbmRvd3MuCisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94 eTo6aGFuZGxlS2V5Ym9hcmRFdmVudCk6IEFkZGVkIGxvZ2dpbmcgYW5kIHN1cHBvcnQgZm9yIG5v dCBhbHdheXMgaGFuZGxpbmcga2V5Ym9hcmQgZXZlbnRzIG9uIFdpbmRvd3MuCisgICAgICAgIChX ZWJLaXQ6OldlYlBhZ2VQcm94eTo6ZGlkUmVjZWl2ZUV2ZW50KTogQWRkZWQgbG9nZ2luZywgY2Fs bCBkb25lV2l0aEtleUV2ZW50KCkgYW5kIHJlbW92ZSBjYWxsIHRvIFRyYW5zbGF0ZU1lc3NhZ2Uo KSBvbiBXaW5kb3dzLgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRD cmFzaCk6IENsZWFyIG1fdW5zZW50Q2hhckV2ZW50UXVldWUgYW5kIHJlc2V0IG1fbGFzdEtleURv d25FdmVudFdhc0hhbmRsZWRCeVdlYktpdCBvbiBXaW5kb3dzLgorICAgICAgICAqIFVJUHJvY2Vz cy9XZWJQYWdlUHJveHkuaDogQWRkZWQgc2hvdWxkSGFuZGxlS2V5Ym9hcmRFdmVudCgpLCBkb25l V2l0aEtleUV2ZW50KCksIG1fdW5zZW50Q2hhckV2ZW50UXVldWUsIG1fYWx3YXlzSGFuZGxlS2V5 RXZlbnQsIGFuZCBtX2xhc3RLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXQgb24gV2luZG93 cy4KKworICAgICAgICAqIFVJUHJvY2Vzcy93aW4vVW5zZW50Q2hhckV2ZW50cy5jcHA6IEFkZGVk LgorICAgICAgICAoV2ViS2l0OjpVbnNlbnRDaGFyRXZlbnRzOjpjcmVhdGVXaXRoUmF3S2V5RG93 bkV2ZW50KTogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OlVuc2VudENoYXJFdmVudHM6OlVuc2Vu dENoYXJFdmVudHMpOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdDo6VW5zZW50Q2hhckV2ZW50czo6 YXBwZW5kQ2hhckV2ZW50KTogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OlVuc2VudENoYXJFdmVu dHM6OnNlbmRRdWV1ZWRDaGFyRXZlbnRzKTogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OlVuc2Vu dENoYXJFdmVudHM6OmlzU2FtZVJhd0tleURvd25FdmVudCk6IEFkZGVkLCBvbmx5IHVzZWQgZm9y IGFzc2VydGlvbiBwdXJwb3Nlcy4KKyAgICAgICAgKiBVSVByb2Nlc3Mvd2luL1Vuc2VudENoYXJF dmVudHMuaDogQWRkZWQuCisgICAgICAgIAorICAgICAgICAqIFVJUHJvY2Vzcy93aW4vV2ViUGFn ZVByb3h5V2luLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpzaG91bGRIYW5k bGVLZXlib2FyZEV2ZW50KTogQWRkZWQsIGNyZWF0ZXMgYSBuZXcgVW5zZW50Q2hhckV2ZW50cyBv YmplY3Qgd2hlbiBhIFJhd0tleURvd24gaXMgcmVjZWl2ZWQsIGFuZCBxdWV1ZXMgdXAgQ2hhciBl dmVudHMgYXMgbmVjZXNzYXJ5LgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmRvbmVX aXRoS2V5RXZlbnQpOiBBZGRlZCwgc2VuZHMgYW55IHF1ZXVlZCBDaGFyIGV2ZW50cyB3aGVuIHRo ZSB3ZWIgcHJvY2VzcyBkb2Vzbid0IGhhbmRsZSBhIFJhd0tleURvd24uCisKKyAgICAgICAgKiB3 aW4vV2ViS2l0Mi52Y3Byb2o6IEFkZGVkIFVuc2VudENoYXJFdmVudHMuY3BwIGFuZCBVbnNlbnRD aGFyRXZlbnRzLmguCisKIDIwMTEtMDUtMjIgIEplZmYgTWlsbGVyICA8amVmZm1AYXBwbGUuY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgpJbmRleDogU291cmNlL1dlYktp dDIvUGxhdGZvcm0vTG9nZ2luZy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvUGxh dGZvcm0vTG9nZ2luZy5jcHAJKHJldmlzaW9uIDg3MDM5KQorKysgU291cmNlL1dlYktpdDIvUGxh dGZvcm0vTG9nZ2luZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTM1LDYgKzM1LDcgQEAgV1RGTG9n Q2hhbm5lbCBMb2dDb250ZXh0TWVudSAgPSB7IDB4MDAwMAogV1RGTG9nQ2hhbm5lbCBMb2dUZXh0 SW5wdXQgICAgPSB7IDB4MDAwMDAwMDQsICJXZWJLaXQyTG9nTGV2ZWwiLCBXVEZMb2dDaGFubmVs T2ZmIH07CiBXVEZMb2dDaGFubmVsIExvZ1ZpZXcgICAgICAgICA9IHsgMHgwMDAwMDAwOCwgIldl YktpdDJMb2dMZXZlbCIsIFdURkxvZ0NoYW5uZWxPZmYgfTsKIFdURkxvZ0NoYW5uZWwgTG9nSWNv bkRhdGFiYXNlID0geyAweDAwMDAwMDEwLCAiV2ViS2l0MkxvZ0xldmVsIiwgV1RGTG9nQ2hhbm5l bE9mZiB9OworV1RGTG9nQ2hhbm5lbCBMb2dLZXlIYW5kbGluZyAgPSB7IDB4MDAwMDAwMjAsICJX ZWJLaXQyTG9nTGV2ZWwiLCBXVEZMb2dDaGFubmVsT2ZmIH07CiAKICNpZiAhUExBVEZPUk0oTUFD KQogdm9pZCBpbml0aWFsaXplTG9nQ2hhbm5lbChXVEZMb2dDaGFubmVsKiBjaGFubmVsKQpAQCAt NTIsNiArNTMsNyBAQCB2b2lkIGluaXRpYWxpemVMb2dDaGFubmVsc0lmTmVjZXNzYXJ5KCkKIAog ICAgIGluaXRpYWxpemVMb2dDaGFubmVsKCZMb2dDb250ZXh0TWVudSk7CiAgICAgaW5pdGlhbGl6 ZUxvZ0NoYW5uZWwoJkxvZ0ljb25EYXRhYmFzZSk7CisgICAgaW5pdGlhbGl6ZUxvZ0NoYW5uZWwo JkxvZ0tleUhhbmRsaW5nKTsKICAgICBpbml0aWFsaXplTG9nQ2hhbm5lbCgmTG9nU2Vzc2lvblN0 YXRlKTsKICAgICBpbml0aWFsaXplTG9nQ2hhbm5lbCgmTG9nVGV4dElucHV0KTsKICAgICBpbml0 aWFsaXplTG9nQ2hhbm5lbCgmTG9nVmlldyk7CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9QbGF0Zm9y bS9Mb2dnaW5nLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvUGxhdGZvcm0vTG9nZ2lu Zy5oCShyZXZpc2lvbiA4NzAzOSkKKysrIFNvdXJjZS9XZWJLaXQyL1BsYXRmb3JtL0xvZ2dpbmcu aAkod29ya2luZyBjb3B5KQpAQCAtMzgsNiArMzgsNyBAQCBuYW1lc3BhY2UgV2ViS2l0IHsKIAog ZXh0ZXJuIFdURkxvZ0NoYW5uZWwgTG9nQ29udGV4dE1lbnU7CiBleHRlcm4gV1RGTG9nQ2hhbm5l bCBMb2dJY29uRGF0YWJhc2U7CitleHRlcm4gV1RGTG9nQ2hhbm5lbCBMb2dLZXlIYW5kbGluZzsK IGV4dGVybiBXVEZMb2dDaGFubmVsIExvZ1Nlc3Npb25TdGF0ZTsKIGV4dGVybiBXVEZMb2dDaGFu bmVsIExvZ1RleHRJbnB1dDsKIGV4dGVybiBXVEZMb2dDaGFubmVsIExvZ1ZpZXc7CkluZGV4OiBT b3VyY2UvV2ViS2l0Mi9TaGFyZWQvTmF0aXZlV2ViS2V5Ym9hcmRFdmVudC5oCj09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0K LS0tIFNvdXJjZS9XZWJLaXQyL1NoYXJlZC9OYXRpdmVXZWJLZXlib2FyZEV2ZW50LmgJKHJldmlz aW9uIDg3MDM5KQorKysgU291cmNlL1dlYktpdDIvU2hhcmVkL05hdGl2ZVdlYktleWJvYXJkRXZl bnQuaAkod29ya2luZyBjb3B5KQpAQCAtNDcsNiArNDcsNyBAQCBwdWJsaWM6CiAjaWYgUExBVEZP Uk0oTUFDKQogICAgIE5hdGl2ZVdlYktleWJvYXJkRXZlbnQoTlNFdmVudCAqLCBOU1ZpZXcgKik7 CiAjZWxpZiBQTEFURk9STShXSU4pCisgICAgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudChjb25zdCBO YXRpdmVXZWJLZXlib2FyZEV2ZW50Jik7CiAgICAgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudChIV05E LCBVSU5UIG1lc3NhZ2UsIFdQQVJBTSwgTFBBUkFNKTsKICNlbGlmIFBMQVRGT1JNKFFUKQogICAg IGV4cGxpY2l0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQoUUtleUV2ZW50Kik7CkluZGV4OiBTb3Vy Y2UvV2ViS2l0Mi9TaGFyZWQvd2luL05hdGl2ZVdlYktleWJvYXJkRXZlbnRXaW4uY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1NoYXJlZC93aW4vTmF0aXZlV2ViS2V5Ym9hcmRFdmVu dFdpbi5jcHAJKHJldmlzaW9uIDg3MDM5KQorKysgU291cmNlL1dlYktpdDIvU2hhcmVkL3dpbi9O YXRpdmVXZWJLZXlib2FyZEV2ZW50V2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDAsNCArNDAs MTQgQEAgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudDo6TmF0aXZlV2ViS2V5Ym9hcgogICAgIG1fbmF0 aXZlRXZlbnQubFBhcmFtID0gbFBhcmFtOwogfQogCitOYXRpdmVXZWJLZXlib2FyZEV2ZW50OjpO YXRpdmVXZWJLZXlib2FyZEV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50 KQorICAgIDogV2ViS2V5Ym9hcmRFdmVudChXZWJFdmVudEZhY3Rvcnk6OmNyZWF0ZVdlYktleWJv YXJkRXZlbnQoZXZlbnQubV9uYXRpdmVFdmVudC5od25kLCBldmVudC5tX25hdGl2ZUV2ZW50Lm1l c3NhZ2UsIGV2ZW50Lm1fbmF0aXZlRXZlbnQud1BhcmFtLCBldmVudC5tX25hdGl2ZUV2ZW50LmxQ YXJhbSkpCisgICAgLCBtX25hdGl2ZUV2ZW50KCkKK3sKKyAgICBtX25hdGl2ZUV2ZW50Lmh3bmQg PSBldmVudC5tX25hdGl2ZUV2ZW50Lmh3bmQ7CisgICAgbV9uYXRpdmVFdmVudC5tZXNzYWdlID0g ZXZlbnQubV9uYXRpdmVFdmVudC5tZXNzYWdlOworICAgIG1fbmF0aXZlRXZlbnQud1BhcmFtID0g ZXZlbnQubV9uYXRpdmVFdmVudC53UGFyYW07CisgICAgbV9uYXRpdmVFdmVudC5sUGFyYW0gPSBl dmVudC5tX25hdGl2ZUV2ZW50LmxQYXJhbTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0Cklu ZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAkocmV2aXNpb24g ODcwMzkpCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAkod29y a2luZyBjb3B5KQpAQCAtMzIsNiArMzIsNyBAQAogI2luY2x1ZGUgIkRvd25sb2FkUHJveHkuaCIK ICNpbmNsdWRlICJEcmF3aW5nQXJlYVByb3h5LmgiCiAjaW5jbHVkZSAiRmluZEluZGljYXRvci5o IgorI2luY2x1ZGUgIkxvZ2dpbmcuaCIKICNpbmNsdWRlICJNZXNzYWdlSUQuaCIKICNpbmNsdWRl ICJOYXRpdmVXZWJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAiTmF0aXZlV2ViTW91c2VFdmVu dC5oIgpAQCAtNzgsNiArNzksNyBAQAogI2luY2x1ZGUgPHN0ZGlvLmg+CiAKICNpZiBQTEFURk9S TShXSU4pCisjaW5jbHVkZSAiVW5zZW50Q2hhckV2ZW50cy5oIgogI2luY2x1ZGUgIldlYkRyYWdT b3VyY2UuaCIKICNpbmNsdWRlIDxXZWJDb3JlL0JpdG1hcEluZm8uaD4KICNpbmNsdWRlIDxXZWJD b3JlL0NsaXBib2FyZFV0aWxpdGllc1dpbi5oPgpAQCAtOTAsNyArOTIsNyBAQAogI2luY2x1ZGUg PHd0Zi9SZWZDb3VudGVkTGVha0NvdW50ZXIuaD4KICNlbmRpZgogCi0vLyBUaGlzIGNvbnRyb2xz IHdoYXQgc3RyYXRlZ3kgd2UgdXNlIGZvciBtb3VzZSB3aGVlbCBjb2FsZXNpbmcuCisvLyBUaGlz IGNvbnRyb2xzIHdoYXQgc3RyYXRlZ3kgd2UgdXNlIGZvciBtb3VzZSB3aGVlbCBjb2FsZXNjaW5n LgogI2RlZmluZSBNRVJHRV9XSEVFTF9FVkVOVFMgMAogCiAjZGVmaW5lIE1FU1NBR0VfQ0hFQ0so YXNzZXJ0aW9uKSBNRVNTQUdFX0NIRUNLX0JBU0UoYXNzZXJ0aW9uLCBwcm9jZXNzKCktPmNvbm5l Y3Rpb24oKSkKQEAgLTEwNSw2ICsxMDcsMjkgQEAgV0tQYWdlRGVidWdQYWludEZsYWdzIFdlYlBh Z2VQcm94eTo6c19kZQogc3RhdGljIFdURjo6UmVmQ291bnRlZExlYWtDb3VudGVyIHdlYlBhZ2VQ cm94eUNvdW50ZXIoIldlYlBhZ2VQcm94eSIpOwogI2VuZGlmCiAKKyNpZiAhTE9HX0RJU0FCTEVE CitzdGF0aWMgY29uc3QgY2hhciogd2ViS2V5Ym9hcmRFdmVudFR5cGVTdHJpbmcoV2ViRXZlbnQ6 OlR5cGUgdHlwZSkKK3sKKyAgICBzd2l0Y2ggKHR5cGUpIHsKKyAgICBjYXNlIFdlYkV2ZW50OjpL ZXlEb3duOgorICAgICAgICByZXR1cm4gIktleURvd24iOworICAgIAorICAgIGNhc2UgV2ViRXZl bnQ6OktleVVwOgorICAgICAgICByZXR1cm4gIktleVVwIjsKKyAgICAKKyAgICBjYXNlIFdlYkV2 ZW50OjpSYXdLZXlEb3duOgorICAgICAgICByZXR1cm4gIlJhd0tleURvd24iOworICAgIAorICAg IGNhc2UgV2ViRXZlbnQ6OkNoYXI6CisgICAgICAgIHJldHVybiAiQ2hhciI7CisgICAgCisgICAg ZGVmYXVsdDoKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJldHVybiAi PHVua25vd24+IjsKKyAgICB9Cit9CisjZW5kaWYgLy8gIUxPR19ESVNBQkxFRAorCiBQYXNzUmVm UHRyPFdlYlBhZ2VQcm94eT4gV2ViUGFnZVByb3h5OjpjcmVhdGUoUGFnZUNsaWVudCogcGFnZUNs aWVudCwgUGFzc1JlZlB0cjxXZWJQcm9jZXNzUHJveHk+IHByb2Nlc3MsIFdlYlBhZ2VHcm91cCog cGFnZUdyb3VwLCB1aW50NjRfdCBwYWdlSUQpCiB7CiAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBX ZWJQYWdlUHJveHkocGFnZUNsaWVudCwgcHJvY2VzcywgcGFnZUdyb3VwLCBwYWdlSUQpKTsKQEAg LTE0MCw2ICsxNjUsMTAgQEAgV2ViUGFnZVByb3h5OjpXZWJQYWdlUHJveHkoUGFnZUNsaWVudCog cAogICAgICwgbV9zeW5jTmF2aWdhdGlvbkFjdGlvblBvbGljeUFjdGlvbklzVmFsaWQoZmFsc2Up CiAgICAgLCBtX3N5bmNOYXZpZ2F0aW9uQWN0aW9uUG9saWN5QWN0aW9uKFBvbGljeVVzZSkKICAg ICAsIG1fc3luY05hdmlnYXRpb25BY3Rpb25Qb2xpY3lEb3dubG9hZElEKDApCisjaWYgUExBVEZP Uk0oV0lOKQorICAgICwgbV9hbHdheXNIYW5kbGVLZXlFdmVudChmYWxzZSkKKyAgICAsIG1fbGFz dEtleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdChmYWxzZSkKKyNlbmRpZgogICAgICwgbV9w cm9jZXNzaW5nTW91c2VNb3ZlRXZlbnQoZmFsc2UpCiAgICAgLCBtX3BhZ2VJRChwYWdlSUQpCiAj aWYgUExBVEZPUk0oTUFDKQpAQCAtOTAxLDYgKzkzMCwxMyBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6 aGFuZGxlS2V5Ym9hcmRFdmVudChjCiB7CiAgICAgaWYgKCFpc1ZhbGlkKCkpCiAgICAgICAgIHJl dHVybjsKKyAgICAKKyAgICBMT0coS2V5SGFuZGxpbmcsICIlV2ViUGFnZVByb3h5OjpoYW5kbGVL ZXlib2FyZEV2ZW50OiAlcyIsIHdlYktleWJvYXJkRXZlbnRUeXBlU3RyaW5nKGV2ZW50LnR5cGUo KSkpOworCisjaWYgUExBVEZPUk0oV0lOKQorICAgIGlmICghbV9hbHdheXNIYW5kbGVLZXlFdmVu dCAmJiAhc2hvdWxkSGFuZGxlS2V5Ym9hcmRFdmVudChldmVudCkpCisgICAgICAgIHJldHVybjsK KyNlbmRpZgogCiAgICAgbV9rZXlFdmVudFF1ZXVlLmFwcGVuZChldmVudCk7CiAKQEAgLTI3MDMs NiArMjczOSw4IEBAIHZvaWQgV2ViUGFnZVByb3h5OjpkaWRSZWNlaXZlRXZlbnQodWludDMKICAg ICBjYXNlIFdlYkV2ZW50OjpLZXlVcDoKICAgICBjYXNlIFdlYkV2ZW50OjpSYXdLZXlEb3duOgog ICAgIGNhc2UgV2ViRXZlbnQ6OkNoYXI6IHsKKyAgICAgICAgTE9HKEtleUhhbmRsaW5nLCAiJVdl YlBhZ2VQcm94eTo6ZGlkUmVjZWl2ZUV2ZW50OiAlcyIsIHdlYktleWJvYXJkRXZlbnRUeXBlU3Ry aW5nKHR5cGUpKTsKKwogICAgICAgICBOYXRpdmVXZWJLZXlib2FyZEV2ZW50IGV2ZW50ID0gbV9r ZXlFdmVudFF1ZXVlLmZpcnN0KCk7CiAgICAgICAgIE1FU1NBR0VfQ0hFQ0sodHlwZSA9PSBldmVu dC50eXBlKCkpOwogCkBAIC0yNzEwLDE1ICsyNzQ4LDE1IEBAIHZvaWQgV2ViUGFnZVByb3h5Ojpk aWRSZWNlaXZlRXZlbnQodWludDMKIAogICAgICAgICBtX3BhZ2VDbGllbnQtPmRvbmVXaXRoS2V5 RXZlbnQoZXZlbnQsIGhhbmRsZWQpOwogCisjaWYgUExBVEZPUk0oV0lOKQorICAgICAgICBkb25l V2l0aEtleUV2ZW50KGV2ZW50LCBoYW5kbGVkKTsKKyNlbmRpZgorCiAgICAgICAgIGlmIChoYW5k bGVkKQogICAgICAgICAgICAgYnJlYWs7CiAKICAgICAgICAgaWYgKG1fdWlDbGllbnQuaW1wbGVt ZW50c0RpZE5vdEhhbmRsZUtleUV2ZW50KCkpCiAgICAgICAgICAgICBtX3VpQ2xpZW50LmRpZE5v dEhhbmRsZUtleUV2ZW50KHRoaXMsIGV2ZW50KTsKLSNpZiBQTEFURk9STShXSU4pCi0gICAgICAg IGVsc2UKLSAgICAgICAgICAgIDo6VHJhbnNsYXRlTWVzc2FnZShldmVudC5uYXRpdmVFdmVudCgp KTsKLSNlbmRpZgogICAgICAgICBicmVhazsKICAgICB9CiAgICAgfQpAQCAtMjkwOSw2ICsyOTQ3 LDExIEBAIHZvaWQgV2ViUGFnZVByb3h5Ojpwcm9jZXNzRGlkQ3Jhc2goKQogICAgIC8vIENhbid0 IGV4cGVjdCBEaWRSZWNlaXZlRXZlbnQgbm90aWZpY2F0aW9ucyBmcm9tIGEgY3Jhc2hlZCB3ZWIg cHJvY2Vzcy4KICAgICBtX2tleUV2ZW50UXVldWUuY2xlYXIoKTsKICAgICAKKyNpZiBQTEFURk9S TShXSU4pCisgICAgbV91bnNlbnRDaGFyRXZlbnRRdWV1ZS5jbGVhcigpOworICAgIG1fbGFzdEtl eURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdCA9IGZhbHNlOworI2VuZGlmCisgICAgCiAgICAg bV93aGVlbEV2ZW50UXVldWUuY2xlYXIoKTsKICAgICBtX2N1cnJlbnRseVByb2Nlc3NlZFdoZWVs RXZlbnRzLmNsZWFyKCk7CiAKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdl UHJveHkuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVBy b3h5LmgJKHJldmlzaW9uIDg3MDM5KQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBh Z2VQcm94eS5oCSh3b3JraW5nIGNvcHkpCkBAIC0xMTQsNiArMTE0LDcgQEAgc3RydWN0IFdlYlBh Z2VDcmVhdGlvblBhcmFtZXRlcnM7CiBzdHJ1Y3QgV2ViUG9wdXBJdGVtOwogCiAjaWYgUExBVEZP Uk0oV0lOKQorY2xhc3MgVW5zZW50Q2hhckV2ZW50czsKIHN0cnVjdCBXaW5kb3dHZW9tZXRyeTsK ICNlbmRpZgogCkBAIC02NTUsNiArNjU2LDExIEBAIHByaXZhdGU6CiAgICAgdm9pZCBleGVjdXRl U2F2ZWRDb21tYW5kQnlTZWxlY3Rvcihjb25zdCBTdHJpbmcmIHNlbGVjdG9yLCBib29sJiBoYW5k bGVkKTsKICNlbmRpZgogCisjaWYgUExBVEZPUk0oV0lOKQorICAgIGJvb2wgc2hvdWxkSGFuZGxl S2V5Ym9hcmRFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50Jik7CisgICAgdm9pZCBk b25lV2l0aEtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmLCBib29sKTsKKyNl bmRpZgorCiAjaWYgUExBVEZPUk0oR1RLKQogICAgIHZvaWQgZ2V0RWRpdG9yQ29tbWFuZHNGb3JL ZXlFdmVudChWZWN0b3I8U3RyaW5nPiYpOwogI2VuZGlmCkBAIC04NTAsNiArODU2LDEyIEBAIHBy aXZhdGU6CiAgICAgdWludDY0X3QgbV9zeW5jTmF2aWdhdGlvbkFjdGlvblBvbGljeURvd25sb2Fk SUQ7CiAKICAgICBEZXF1ZTxOYXRpdmVXZWJLZXlib2FyZEV2ZW50PiBtX2tleUV2ZW50UXVldWU7 CisgCisjaWYgUExBVEZPUk0oV0lOKQorICAgIERlcXVlPFVuc2VudENoYXJFdmVudHM+IG1fdW5z ZW50Q2hhckV2ZW50UXVldWU7CisgICAgYm9vbCBtX2Fsd2F5c0hhbmRsZUtleUV2ZW50OworICAg IGJvb2wgbV9sYXN0S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0OworI2VuZGlmCiAKICAg ICBEZXF1ZTxOYXRpdmVXZWJXaGVlbEV2ZW50PiBtX3doZWVsRXZlbnRRdWV1ZTsKICAgICBWZWN0 b3I8TmF0aXZlV2ViV2hlZWxFdmVudD4gbV9jdXJyZW50bHlQcm9jZXNzZWRXaGVlbEV2ZW50czsK SW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy93aW4vVW5zZW50Q2hhckV2ZW50cy5jcHAK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL3dpbi9VbnNlbnRDaGFyRXZl bnRzLmNwcAkocmV2aXNpb24gMCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy93aW4vVW5z ZW50Q2hhckV2ZW50cy5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsNzIgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRT IENPTlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdB UlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQg V0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxB UgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5D LiBPUiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElS RUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFM IERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgor ICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBS T0ZJVFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBP TiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklD VCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkK KyAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBF VkVOIElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAq LworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVW5zZW50Q2hhckV2ZW50cy5oIgor CisjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgorCituYW1l c3BhY2UgV2ViS2l0IHsKKworVW5zZW50Q2hhckV2ZW50cyBVbnNlbnRDaGFyRXZlbnRzOjpjcmVh dGVXaXRoUmF3S2V5RG93bkV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIHJhd0tl eURvd25FdmVudCkKK3sKKyAgICByZXR1cm4gVW5zZW50Q2hhckV2ZW50cyhyYXdLZXlEb3duRXZl bnQpOworfQorCitVbnNlbnRDaGFyRXZlbnRzOjpVbnNlbnRDaGFyRXZlbnRzKGNvbnN0IE5hdGl2 ZVdlYktleWJvYXJkRXZlbnQmIHJhd0tleURvd25FdmVudCkKKyAgICA6IG1fcmF3S2V5RG93bkV2 ZW50KHJhd0tleURvd25FdmVudCkKK3sKKyAgICBBU1NFUlQobV9yYXdLZXlEb3duRXZlbnQudHlw ZSgpID09IFdlYkV2ZW50OjpSYXdLZXlEb3duKTsKK30KKwordm9pZCBVbnNlbnRDaGFyRXZlbnRz OjphcHBlbmRDaGFyRXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgY2hhckV2ZW50 KQoreworICAgIEFTU0VSVChjaGFyRXZlbnQudHlwZSgpID09IFdlYkV2ZW50OjpDaGFyKTsKKyAg ICBtX2NoYXJFdmVudFF1ZXVlLmFwcGVuZChjaGFyRXZlbnQpOworfQorCit2b2lkIFVuc2VudENo YXJFdmVudHM6OnNlbmRRdWV1ZWRDaGFyRXZlbnRzKFdlYlBhZ2VQcm94eSogd2ViUGFnZVByb3h5 KQoreworICAgIEFTU0VSVF9BUkcod2ViUGFnZVByb3h5LCB3ZWJQYWdlUHJveHkpOworICAgIAor ICAgIHdoaWxlICghbV9jaGFyRXZlbnRRdWV1ZS5pc0VtcHR5KCkpIHsKKyAgICAgICAgTmF0aXZl V2ViS2V5Ym9hcmRFdmVudCBjaGFyRXZlbnQgPSBtX2NoYXJFdmVudFF1ZXVlLmZpcnN0KCk7Cisg ICAgICAgIG1fY2hhckV2ZW50UXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICAgICAgCisgICAgICAg IExPRyhLZXlIYW5kbGluZywgIlVucHJvY2Vzc2VkUmF3S2V5RG93bkFuZENoYXJFdmVudHM6OnNl bmRRdWV1ZWRDaGFyRXZlbnRzOiBzZW5kaW5nIHF1ZXVlZCBDaGFyIGV2ZW50Iik7CisgICAgICAg IHdlYlBhZ2VQcm94eS0+aGFuZGxlS2V5Ym9hcmRFdmVudChjaGFyRXZlbnQpOworICAgIH0KK30K KworI2lmICFBU1NFUlRfRElTQUJMRUQKK2Jvb2wgVW5zZW50Q2hhckV2ZW50czo6aXNTYW1lUmF3 S2V5RG93bkV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIHJhd0tleURvd25FdmVu dCkKK3sKKyAgICByZXR1cm4gKChyYXdLZXlEb3duRXZlbnQubmF0aXZlRXZlbnQoKS0+aHduZCA9 PSBtX3Jhd0tleURvd25FdmVudC5uYXRpdmVFdmVudCgpLT5od25kKSAmJiAocmF3S2V5RG93bkV2 ZW50Lm5hdGl2ZUV2ZW50KCktPm1lc3NhZ2UgPT0gbV9yYXdLZXlEb3duRXZlbnQubmF0aXZlRXZl bnQoKS0+bWVzc2FnZSkKKyAgICAgICAgJiYgKHJhd0tleURvd25FdmVudC5uYXRpdmVFdmVudCgp LT53UGFyYW0gPT0gbV9yYXdLZXlEb3duRXZlbnQubmF0aXZlRXZlbnQoKS0+d1BhcmFtKSAmJiAo cmF3S2V5RG93bkV2ZW50Lm5hdGl2ZUV2ZW50KCktPmxQYXJhbSA9PSBtX3Jhd0tleURvd25FdmVu dC5uYXRpdmVFdmVudCgpLT5sUGFyYW0pKTsKK30KKyNlbmRpZiAvLyAhQVNTRVJUX0RJU0FCTEVE CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAoKUHJvcGVydHkgY2hhbmdlcyBvbjogU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL3dpbi9VbnNlbnRDaGFyRXZlbnRzLmNwcApfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkFkZGVk OiBzdm46ZW9sLXN0eWxlCiAgICsgbmF0aXZlCgpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL3dpbi9VbnNlbnRDaGFyRXZlbnRzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL3dpbi9VbnNlbnRDaGFyRXZlbnRzLmgJKHJldmlzaW9uIDApCisrKyBTb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3Mvd2luL1Vuc2VudENoYXJFdmVudHMuaAkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw1NiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJworICogQU5EIEFO WSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sCisgKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQg RklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBO TyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMKKyAqIEJFIExJQUJM RSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFS WSwgT1IKKyAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sIFBST0NVUkVNRU5UIE9GCisgKiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBM T1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MKKyAqIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVS IElOCisgKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5F R0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQorICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgorICogVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpZm5kZWYgVW5zZW50Q2hhckV2ZW50c19oCisj ZGVmaW5lIFVuc2VudENoYXJFdmVudHNfaAorCisjaW5jbHVkZSAiTmF0aXZlV2ViS2V5Ym9hcmRF dmVudC5oIgorI2luY2x1ZGUgPHd0Zi9EZXF1ZS5oPgorCituYW1lc3BhY2UgV2ViS2l0IHsKKwor Y2xhc3MgV2ViUGFnZVByb3h5OworCitjbGFzcyBVbnNlbnRDaGFyRXZlbnRzIHsKK3B1YmxpYzoK KyAgICBzdGF0aWMgVW5zZW50Q2hhckV2ZW50cyBjcmVhdGVXaXRoUmF3S2V5RG93bkV2ZW50KGNv bnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmKTsKKyAgICAKKyAgICB2b2lkIGFwcGVuZENoYXJF dmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50Jik7CisgICAgdm9pZCBzZW5kUXVldWVk Q2hhckV2ZW50cyhXZWJQYWdlUHJveHkqKTsKKworI2lmICFBU1NFUlRfRElTQUJMRUQKKyAgICBi b29sIGlzU2FtZVJhd0tleURvd25FdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50Jik7 CisjZW5kaWYKKworcHJpdmF0ZTogICAgCisgICAgVW5zZW50Q2hhckV2ZW50cyhjb25zdCBOYXRp dmVXZWJLZXlib2FyZEV2ZW50Jik7CisKKyAgICBOYXRpdmVXZWJLZXlib2FyZEV2ZW50IG1fcmF3 S2V5RG93bkV2ZW50OworICAgIERlcXVlPE5hdGl2ZVdlYktleWJvYXJkRXZlbnQ+IG1fY2hhckV2 ZW50UXVldWU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmIC8vIFVuc2Vu dENoYXJFdmVudHNfaAoKUHJvcGVydHkgY2hhbmdlcyBvbjogU291cmNlL1dlYktpdDIvVUlQcm9j ZXNzL3dpbi9VbnNlbnRDaGFyRXZlbnRzLmgKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpBZGRlZDogc3ZuOmVvbC1zdHls ZQogICArIG5hdGl2ZQoKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy93aW4vV2ViUGFn ZVByb3h5V2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mvd2lu L1dlYlBhZ2VQcm94eVdpbi5jcHAJKHJldmlzaW9uIDg3MDM5KQorKysgU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL3dpbi9XZWJQYWdlUHJveHlXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNiw3 ICsyNiwxMCBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5o IgogCisjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIk5hdGl2ZVdlYktleWJvYXJkRXZl bnQuaCIKICNpbmNsdWRlICJQYWdlQ2xpZW50LmgiCisjaW5jbHVkZSAiVW5zZW50Q2hhckV2ZW50 cy5oIgogI2luY2x1ZGUgIldlYlBvcHVwTWVudVByb3h5V2luLmgiCiAKICNpbmNsdWRlICJyZXNv dXJjZS5oIgpAQCAtODAsNCArODMsNzMgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmRpZEluc3RhbGxP clVuaW5zdGFsbAogICAgIG1fcGFnZUNsaWVudC0+ZGlkSW5zdGFsbE9yVW5pbnN0YWxsUGFnZU92 ZXJsYXkoZGlkSW5zdGFsbCk7CiB9CiAKK2Jvb2wgV2ViUGFnZVByb3h5OjpzaG91bGRIYW5kbGVL ZXlib2FyZEV2ZW50KGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50KQoreworICAg IGlmIChldmVudC50eXBlKCkgPT0gTmF0aXZlV2ViS2V5Ym9hcmRFdmVudDo6UmF3S2V5RG93bikg eworICAgICAgICAvLyBXaGVuIHdlIHJlY2VpdmUgYSBSYXdLZXlEb3duIGV2ZW50LCB3ZSBuZWVk IHRvIHF1ZXVlIHVwIGFuIHN1YnNlcXVlbnQgQ2hhciBldmVudHMgdW50aWwgd2Uga25vdyB3aGV0 aGVyIFdlYktpdAorICAgICAgICAvLyBoYXMgaGFuZGxlZCB0aGUgUmF3S2V5RG93bi4KKyAgICAg ICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5OjpoYW5kbGVLZXlib2FyZEV2ZW50OiBx dWV1ZWluZyBSYXdLZXlEb3duIik7CisgICAgICAgIG1fdW5zZW50Q2hhckV2ZW50UXVldWUuYXBw ZW5kKFVuc2VudENoYXJFdmVudHM6OmNyZWF0ZVdpdGhSYXdLZXlEb3duRXZlbnQoZXZlbnQpKTsK KyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIAorICAgIGlmIChldmVudC50eXBlKCkg IT0gTmF0aXZlV2ViS2V5Ym9hcmRFdmVudDo6Q2hhcikKKyAgICAgICAgcmV0dXJuIHRydWU7Cisg ICAgCisgICAgLy8gUXVldWUgdXAgYW55IENoYXIgbWVzc2FnZXMgd2UgcmVjZWl2ZSBiZWZvcmUg d2Uga25vdyB3aGV0aGVyIHRoZSB3ZWIgcHJvY2VzcyBoYXMgaGFuZGxlZCB0aGUKKyAgICAvLyBs YXN0IFJhd0tleURvd24gdGhlIHdlIHNhdy4KKyAgICBpZiAoIW1fdW5zZW50Q2hhckV2ZW50UXVl dWUuaXNFbXB0eSgpKSB7CisgICAgICAgIExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6 aGFuZGxlS2V5Ym9hcmRFdmVudDogcXVldWVpbmcgQ2hhciIpOworICAgICAgICBtX3Vuc2VudENo YXJFdmVudFF1ZXVlLnJiZWdpbigpLT5hcHBlbmRDaGFyRXZlbnQoZXZlbnQpOworICAgICAgICBy ZXR1cm4gZmFsc2U7CisgICAgfQorICAgIAorICAgIC8vIElmIHdlIGdldCBhIENoYXIgZXZlbnQg YWZ0ZXIgV2ViS2l0IGhhcyBwcm9jZXNzZWQgYWxsIG91dHN0YW5kaW5nIFJhd0tleURvd24gZXZl bnRzLCB3ZSBuZWVkIHRvCisgICAgLy8gZHJvcCBpdCBvbiB0aGUgZmxvb3IgaWYgV2ViS2l0IGhh bmRsZWQgdGhlIGxhc3QgUmF3S2V5RG93bi4gSW4gcHJhY3RpY2UsIHRoaXMgcmFyZWx5IGhhcHBl bnMuCisgICAgaWYgKG1fbGFzdEtleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdCkgeworICAg ICAgICBMT0coS2V5SGFuZGxpbmcsICJXZWJQYWdlUHJveHk6OmhhbmRsZUtleWJvYXJkRXZlbnQ6 IGlnbm9yaW5nIENoYXIgYWZ0ZXIgbGFzdCBSYXdLZXlEb3duIHdhcyBoYW5kbGVkIik7CisgICAg ICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgCisgICAgLy8gVGhlcmUncyBubyBvdXRzdGFu ZGluZyBSYXdLZXlEb3duLCBhbmQgV2ViS2l0IGRpZG4ndCBoYW5kbGUgdGhlIGxhc3QgUmF3S2V5 RG93biwgc28gaXQncyBPSyB0byBzZW5kIHRoZSBDaGFyIGV2ZW50LgorICAgIHJldHVybiB0cnVl OworfQorCit2b2lkIFdlYlBhZ2VQcm94eTo6ZG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRpdmVX ZWJLZXlib2FyZEV2ZW50JiBldmVudCwgYm9vbCBoYW5kbGVkKQoreworICAgIGlmIChldmVudC50 eXBlKCkgPT0gV2ViRXZlbnQ6OkNoYXIpCisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBpZiAo ZXZlbnQudHlwZSgpICE9IFdlYkV2ZW50OjpSYXdLZXlEb3duKSB7CisgICAgICAgIC8vIEFzIHNv b24gYXMgd2UgZ2V0IGFuIGV2ZW50IHRoYXQgaXNuJ3QgYSBSYXdLZXlEb3duIG9yIENoYXIsIHdl IGNhbiByZXNldCB0aGUgbV9sYXN0S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0IGZsYWcu CisgICAgICAgIG1fbGFzdEtleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdCA9IGZhbHNlOwor ICAgICAgICByZXR1cm47CisgICAgfQorICAgIAorICAgIC8vIFRoZSB3ZWIgcHJvY2VzcyBoYXMg cHJvY2Vzc2VkIGEgUmF3S2V5RG93biBtZXNzYWdlLCB3ZSBkb24ndCBuZWVkIHRvIHF1ZXVlIHVw IGFueSBmdXR1cmUgQ2hhciBtZXNzYWdlcyBmb3IgaXQgYW55bW9yZS4KKyAgICBBU1NFUlQoIW1f dW5zZW50Q2hhckV2ZW50UXVldWUuaXNFbXB0eSgpKTsKKyAgICBVbnNlbnRDaGFyRXZlbnRzIHVu cHJvY2Vzc2VkUmF3S2V5RG93bkFuZENoYXJFdmVudHMgPSBtX3Vuc2VudENoYXJFdmVudFF1ZXVl LmZpcnN0KCk7CisgICAgbV91bnNlbnRDaGFyRXZlbnRRdWV1ZS5yZW1vdmVGaXJzdCgpOworICAg IAorICAgIC8vIFdlIHNob3VsZCBhbHdheXMgYmUgbm90aWZpZWQgdGhhdCBhbiBldmVudCB3YXMg cHJvY2Vzc2VkIGluIHRoZSBzYW1lIG9yZGVyIHRoYXQgZXZlbnRzIGFyZSByZWNlaXZlZC4KKyAg ICBBU1NFUlQodW5wcm9jZXNzZWRSYXdLZXlEb3duQW5kQ2hhckV2ZW50cy5pc1NhbWVSYXdLZXlE b3duRXZlbnQoZXZlbnQpKTsKKyAgICAKKyAgICBpZiAoaGFuZGxlZCkgeworICAgICAgICAvLyBL ZWVwIHRyYWNrIHRoYXQgd2UgaGFuZGxlZCB0aGUgbGFzdCBSYXdLZXlEb3duIGV2ZW50IHRoYXQg d2FzIHByb2Nlc3NlZC4KKyAgICAgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5Ojpk aWRSZWNlaXZlRXZlbnQ6IFJhd0tleURvd24gaGFuZGxlZCwgc2V0dGluZyBtX2xhc3RLZXlEb3du RXZlbnRXYXNIYW5kbGVkQnlXZWJLaXQiKTsKKyAgICAgICAgQVNTRVJUKCFtX2xhc3RLZXlEb3du RXZlbnRXYXNIYW5kbGVkQnlXZWJLaXQpOworICAgICAgICBtX2xhc3RLZXlEb3duRXZlbnRXYXNI YW5kbGVkQnlXZWJLaXQgPSB0cnVlOworICAgIH0gZWxzZSB7CisgICAgICAgIC8vIFdlIGRpZG4n dCBoYW5kbGUgdGhlIFJhd0tleURvd24gZXZlbnQsIHNvIHNlbmQgYW55IENoYXIgZXZlbnRzIHdl IHJlY2VpdmVkIGFmdGVyIHRoZSBSYXdLZXlEb3duICh0aGVzZSB3ZXJlIHByb2JhYmx5IGdlbmVy YXRlZCBieSBUcmFuc2xhdGVNZXNzYWdlKCkpLgorICAgICAgICBMT0coS2V5SGFuZGxpbmcsICJX ZWJQYWdlUHJveHk6OmRpZFJlY2VpdmVFdmVudDogUmF3S2V5RG93biBub3QgaGFuZGxlZCwgc2Vu ZGluZyBxdWV1ZWQgQ2hhciBldmVudHMiKTsKKyAgICAgICAgCisgICAgICAgIC8vIFdlIGRvbid0 IHdhbnQgdG8gY2FsbCBzaG91bGRIYW5kbGVLZXlib2FyZEV2ZW50KCkgZm9yIHRoZXNlIGV2ZW50 cy4KKyAgICAgICAgbV9hbHdheXNIYW5kbGVLZXlFdmVudCA9IHRydWU7CisgICAgICAgIHVucHJv Y2Vzc2VkUmF3S2V5RG93bkFuZENoYXJFdmVudHMuc2VuZFF1ZXVlZENoYXJFdmVudHModGhpcyk7 CisgICAgICAgIG1fYWx3YXlzSGFuZGxlS2V5RXZlbnQgPSBmYWxzZTsKKyAgICAgICAgCisgICAg ICAgIG1fbGFzdEtleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdCA9IGZhbHNlOworICAgIH0K K30KKwogfSAvLyBuYW1lc3BhY2UgV2ViS2l0CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi93aW4vV2Vi S2l0Mi52Y3Byb2oKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvd2luL1dlYktpdDIudmNw cm9qCShyZXZpc2lvbiA4NzAzOSkKKysrIFNvdXJjZS9XZWJLaXQyL3dpbi9XZWJLaXQyLnZjcHJv agkod29ya2luZyBjb3B5KQpAQCAtMzUwMiw2ICszNTAyLDE0IEBACiAJCQkJCT4KIAkJCQk8L0Zp bGU+CiAJCQkJPEZpbGUKKwkJCQkJUmVsYXRpdmVQYXRoPSIuLlxVSVByb2Nlc3Ncd2luXFVuc2Vu dENoYXJFdmVudHMuY3BwIgorCQkJCQk+CisJCQkJPC9GaWxlPgorCQkJCTxGaWxlCisJCQkJCVJl bGF0aXZlUGF0aD0iLi5cVUlQcm9jZXNzXHdpblxVbnNlbnRDaGFyRXZlbnRzLmgiCisJCQkJCT4K KwkJCQk8L0ZpbGU+CisJCQkJPEZpbGUKIAkJCQkJUmVsYXRpdmVQYXRoPSIuLlxVSVByb2Nlc3Nc d2luXFdlYkNvbnRleHRNZW51UHJveHlXaW4uY3BwIgogCQkJCQk+CiAJCQkJPC9GaWxlPgpJbmRl eDogVG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL0NoYW5nZUxvZwkocmV2aXNp b24gODcwMzkpCisrKyBUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyArMSwz MCBAQAorMjAxMS0wNS0yMiAgSmVmZiBNaWxsZXIgIDxqZWZmbUBhcHBsZS5jb20+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2ViS2l0MjogQ2xpZW50 cyBoYXZlIHRvIGtub3cgbm90IHRvIGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIG9uIGtleSBtZXNz YWdlcyBkZXN0aW5lZCBmb3IgV2ViS2l0MiB3ZWIgdmlld3MKKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU4Mzc0CisgICAgICAgIDxyZGFyOi8vcHJvYmxl bS85Mjc0NTEwPiAoYW5kIGFsc28gZml4ZXMgPHJkYXI6Ly9wcm9ibGVtLzk0NjkxNjU+KQorICAg ICAgICAKKyAgICAgICAgUmV2ZXJ0IHRoZSBjaGFuZ2VzIG1hZGUgZm9yIGJ1ZyA1NjAyMCBpbiBy ODM2MzMsIGl0IHR1cm5zIG91dCB0aGF0IHRoZSBkZXNpZ24gb2YgbWFraW5nIFdlYktpdCBjbGll bnRzCisgICAgICAgIG9uIFdpbmRvd3Mgd2FpdCB0byBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2UoKSB1 bnRpbCB0aGV5IGtub3cgdGhhdCBXZWJLaXQgZGlkbid0IGhhbmRsZSB0aGUga2V5IGRvd24KKyAg ICAgICAgaXMgdW50ZW5hYmxlLCBzaW5jZSBjbGllbnRzIGRvbid0IGFsd2F5cyBoYXZlIGNvbnRy b2wgb3ZlciB3aGVuIFRyYW5zbGF0ZU1lc3NhZ2UoKSBpcyBjYWxsZWQgKGUuZy4gd2hlbgorICAg ICAgICBXaW5kb3dzIHB1bXBzIG1lc3NhZ2VzIGluIERpYWxvZ0JveCgpIG9yIE1lc3NhZ2VCb3go KSkuCisgICAgICAgIAorICAgICAgICBTcGVjaWZpY2FsbHksIG1ha2UgdGhlIE1pbmlCcm93c2Vy IGFsd2F5cyBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2UoKSBpbW1lZGlhdGVseSBhZ2FpbiwgYW5kIHJl bW92ZSB0aGUgbm93LW9ic29sZXRlCisgICAgICAgIHRlc3QgZm9yIHRoZSBwcmV2aW91cyBkZXNp Z24uCisKKyAgICAgICAgKiBNaW5pQnJvd3Nlci93aW4vbWFpbi5jcHA6IFJlbW92ZWQgc2hvdWxk VHJhbnNsYXRlTWVzc2FnZSgpLgorICAgICAgICAoX3RXaW5NYWluKTogQWx3YXlzIGNhbGwgVHJh bnNsYXRlTWVzc2FnZSgpIGltbWVkaWF0ZWx5IGFnYWluLgorICAgICAgICAKKyAgICAgICAgKiBU ZXN0V2ViS2l0QVBJL1BsYXRmb3JtVXRpbGl0aWVzLmg6IFJlbW92ZWQgc2hvdWxkVHJhbnNsYXRl TWVzc2FnZSgpIG9uIFdpbmRvd3MuCisgICAgICAgICogVGVzdFdlYktpdEFQSS9QbGF0Zm9ybVdl YlZpZXcuaDogUmVtb3ZlZCBzaW11bGF0ZUFLZXlEb3duKCkuCisgICAgICAgICogVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9UcmFuc2xhdGVNZXNzYWdlR2VuZXJhdGVzV01DaGFyLmNw cDogUmVtb3ZlZC4KKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL3dpbi9QbGF0Zm9ybVV0aWxpdGll c1dpbi5jcHA6IFJlbW92ZWQgc2hvdWxkVHJhbnNsYXRlTWVzc2FnZSgpLgorICAgICAgICAoVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKTogQWx3YXlzIGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIGlt bWVkaWF0ZWx5IGFnYWluLgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvd2luL1BsYXRmb3JtV2Vi Vmlld1dpbi5jcHA6IFJlbW92ZWQgc2ltdWxhdGVBS2V5RG93bigpLgorICAgICAgICAqIFRlc3RX ZWJLaXRBUEkvd2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qOiBSZW1vdmVkIFRyYW5zbGF0ZU1lc3Nh Z2VHZW5lcmF0ZXNXTUNoYXIuY3BwLgorCiAyMDExLTA1LTIwICBTaW1vbiBGcmFzZXIgIDxzaW1v bi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcuCklu ZGV4OiBUb29scy9NaW5pQnJvd3Nlci93aW4vbWFpbi5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMv TWluaUJyb3dzZXIvd2luL21haW4uY3BwCShyZXZpc2lvbiA4NzAzMCkKKysrIFRvb2xzL01pbmlC cm93c2VyL3dpbi9tYWluLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDEsMjIgKzQxLDYgQEAKIAog I3ByYWdtYSBjb21tZW50KGxpbmtlciwgIi9tYW5pZmVzdGRlcGVuZGVuY3k6XCJ0eXBlPSd3aW4z MicgbmFtZT0nTWljcm9zb2Z0LldpbmRvd3MuQ29tbW9uLUNvbnRyb2xzJyB2ZXJzaW9uPSc2LjAu MC4wJyBwcm9jZXNzb3JBcmNoaXRlY3R1cmU9JyIgUFJPQ0VTU09SQVJDSElURUNUVVJFICInIHB1 YmxpY0tleVRva2VuPSc2NTk1YjY0MTQ0Y2NmMWRmJyBsYW5ndWFnZT0nKidcIiIpCiAKLXN0YXRp YyBib29sIHNob3VsZFRyYW5zbGF0ZU1lc3NhZ2UoY29uc3QgTVNHJiBtc2cpCi17Ci0gICAgLy8g T25seSB0aGVzZSBmb3VyIG1lc3NhZ2VzIGFyZSBhY3R1YWxseSB0cmFuc2xhdGVkIGJ5IDo6VHJh bnNsYXRlTWVzc2FnZSBvciA6OlRyYW5zbGF0ZUFjY2VsZXJhdG9yLgotICAgIC8vIEl0J3MgdXNl bGVzcyAodGhvdWdoIGhhcm1sZXNzKSB0byBjYWxsIHRob3NlIGZ1bmN0aW9ucyBmb3Igb3RoZXIg bWVzc2FnZXMsIHNvIHdlIGFsd2F5cyBhbGxvdyBvdGhlciBtZXNzYWdlcyB0byBiZSB0cmFuc2xh dGVkLgotICAgIGlmIChtc2cubWVzc2FnZSAhPSBXTV9LRVlET1dOICYmIG1zZy5tZXNzYWdlICE9 IFdNX1NZU0tFWURPV04gJiYgbXNnLm1lc3NhZ2UgIT0gV01fS0VZVVAgJiYgbXNnLm1lc3NhZ2Ug IT0gV01fU1lTS0VZVVApCi0gICAgICAgIHJldHVybiB0cnVlOwotICAgIAotICAgIHdjaGFyX3Qg Y2xhc3NOYW1lWzI1Nl07Ci0gICAgaWYgKCE6OkdldENsYXNzTmFtZVcobXNnLmh3bmQsIGNsYXNz TmFtZSwgQVJSQVlTSVpFKGNsYXNzTmFtZSkpKQotICAgICAgICByZXR1cm4gdHJ1ZTsKLQotICAg IC8vIERvbid0IGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIG9uIGtleSBldmVudHMgZGVzdGluZWQg Zm9yIGEgV2ViS2l0MiB2aWV3LCBXZWJLaXQgd2lsbCBkbyB0aGlzIGlmIGl0IGRvZXNuJ3QgaGFu ZGxlIHRoZSBtZXNzYWdlLgotICAgIC8vIEl0IHdvdWxkIGJlIG5pY2UgdG8gdXNlIHNvbWUgQVBJ IGhlcmUgaW5zdGVhZCBvZiBoYXJkLWNvZGluZyB0aGUgd2luZG93IGNsYXNzIG5hbWUuCi0gICAg cmV0dXJuIHdjc2NtcChjbGFzc05hbWUsIEwiV2ViS2l0MldlYlZpZXdXaW5kb3dDbGFzcyIpOwot fQotCiBpbnQgV0lOQVBJIF90V2luTWFpbihISU5TVEFOQ0UgaEluc3RhbmNlLCBISU5TVEFOQ0Ug aFByZXZJbnN0YW5jZSwgTFBUU1RSIGxwc3RyQ21kTGluZSwgaW50IG5DbWRTaG93KQogewogICAg IE1pbmlCcm93c2VyOjpzaGFyZWQoKS5pbml0aWFsaXplKGhJbnN0YW5jZSk7CkBAIC02OCw5ICs1 Miw3IEBAIGludCBXSU5BUEkgX3RXaW5NYWluKEhJTlNUQU5DRSBoSW5zdGFuY2UKICAgICB3aGls ZSAoQk9PTCByZXN1bHQgPSA6OkdldE1lc3NhZ2UoJm1lc3NhZ2UsIDAsIDAsIDApKSB7CiAgICAg ICAgIGlmIChyZXN1bHQgPT0gLTEpCiAgICAgICAgICAgICBicmVhazsKLSAgICAgICAgCi0gICAg ICAgIGlmIChzaG91bGRUcmFuc2xhdGVNZXNzYWdlKG1lc3NhZ2UpKQotICAgICAgICAgICAgOjpU cmFuc2xhdGVNZXNzYWdlKCZtZXNzYWdlKTsKKyAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKCZt ZXNzYWdlKTsKIAogICAgICAgICBpZiAoIU1pbmlCcm93c2VyOjpzaGFyZWQoKS5oYW5kbGVNZXNz YWdlKCZtZXNzYWdlKSkKICAgICAgICAgICAgIDo6RGlzcGF0Y2hNZXNzYWdlKCZtZXNzYWdlKTsK SW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1VdGlsaXRpZXMuaAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtVXRpbGl0aWVzLmgJKHJldmlzaW9uIDg3 MDMwKQorKysgVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybVV0aWxpdGllcy5oCSh3b3JraW5n IGNvcHkpCkBAIC0zMCw3ICszMCw2IEBACiAjaW5jbHVkZSA8V2ViS2l0Mi9XZWJLaXQyLmg+CiAj aW5jbHVkZSA8Z3Rlc3QvZ3Rlc3QuaD4KICNpbmNsdWRlIDxzdHJpbmc+Ci0jaW5jbHVkZSA8d3Rm L1BsYXRmb3JtLmg+CiAKIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKIG5hbWVzcGFjZSBVdGls IHsKQEAgLTM4LDEwICszNyw2IEBAIG5hbWVzcGFjZSBVdGlsIHsKIC8vIFJ1bnMgYSBwbGF0Zm9y bSBydW5sb29wIHVudGlsIHRoZSAnZG9uZScgaXMgdHJ1ZS4gCiB2b2lkIHJ1bihib29sKiBkb25l KTsKIAotI2lmIFBMQVRGT1JNKFdJTikKLWJvb2wgc2hvdWxkVHJhbnNsYXRlTWVzc2FnZShjb25z dCBNU0cmKTsKLSNlbmRpZgotCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKTsKIAogV0tDb250 ZXh0UmVmIGNyZWF0ZUNvbnRleHRGb3JJbmplY3RlZEJ1bmRsZVRlc3QoY29uc3Qgc3RkOjpzdHJp bmcmLCBXS1R5cGVSZWYgdXNlckRhdGEgPSAwKTsKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkv UGxhdGZvcm1XZWJWaWV3LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0 Zm9ybVdlYlZpZXcuaAkocmV2aXNpb24gODcwMzApCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Bs YXRmb3JtV2ViVmlldy5oCSh3b3JraW5nIGNvcHkpCkBAIC02OSw3ICs2OSw2IEBAIHB1YmxpYzoK ICAgICB2b2lkIHNpbXVsYXRlTW91c2VNb3ZlKHVuc2lnbmVkIHgsIHVuc2lnbmVkIHkpOwogCiAj aWYgUExBVEZPUk0oV0lOKQotICAgIHZvaWQgc2ltdWxhdGVBS2V5RG93bigpOwogICAgIHZvaWQg c2V0UGFyZW50V2luZG93TWVzc2FnZU9ic2VydmVyKFdpbmRvd01lc3NhZ2VPYnNlcnZlciogb2Jz ZXJ2ZXIpIHsgbV9wYXJlbnRXaW5kb3dNZXNzYWdlT2JzZXJ2ZXIgPSBvYnNlcnZlcjsgfQogI2Vu ZGlmCiAKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi93aW4vVHJhbnNs YXRlTWVzc2FnZUdlbmVyYXRlc1dNQ2hhci5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdl YktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9UcmFuc2xhdGVNZXNzYWdlR2VuZXJhdGVzV01DaGFy LmNwcAkocmV2aXNpb24gODcwMzApCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktp dDIvd2luL1RyYW5zbGF0ZU1lc3NhZ2VHZW5lcmF0ZXNXTUNoYXIuY3BwCSh3b3JraW5nIGNvcHkp CkBAIC0xLDkxICswLDAgQEAKLS8qCi0gKiBDb3B5cmlnaHQgKEMpIDIwMTEgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgotICoKLSAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAotICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCi0gKiBh cmUgbWV0OgotICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KLSAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Ci0gKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCi0gKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgotICoKLSAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycKLSAqIEFO RCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLAotICogVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkg QU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgotICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4g SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTCi0gKiBCRSBM SUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVN UExBUlksIE9SCi0gKiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBM SU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgotICogU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNF UzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTCi0gKiBJTlRFUlJV UFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTgotICogQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKLSAqIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0Yg VEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YKLSAqIFRIRSBQT1NT SUJJTElUWSBPRiBTVUNIIERBTUFHRS4KLSAqLwotCi0jaW5jbHVkZSAiVGVzdC5oIgotCi0jaW5j bHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKLSNpbmNsdWRlICJQbGF0Zm9ybVdlYlZpZXcuaCIK LSNpbmNsdWRlICJXaW5kb3dNZXNzYWdlT2JzZXJ2ZXIuaCIKLSNpbmNsdWRlIDxXZWJLaXQyL1dL UmV0YWluUHRyLmg+Ci0KLW5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJIHsKLQotc3RhdGljIGJvb2wg ZGlkU2VlV01DaGFyOwotc3RhdGljIGJvb2wgZGlkTm90SGFuZGxlS2V5RXZlbnRDYWxsZWQ7Ci0K LXN0YXRpYyB2b2lkIGRpZE5vdEhhbmRsZUtleUV2ZW50Q2FsbGJhY2soV0tQYWdlUmVmLCBXS05h dGl2ZUV2ZW50UHRyIGV2ZW50LCBjb25zdCB2b2lkKikKLXsKLSAgICBpZiAoZXZlbnQtPm1lc3Nh Z2UgIT0gV01fS0VZRE9XTikKLSAgICAgICAgcmV0dXJuOwotICAgIAotICAgIC8vIERvbid0IGNh bGwgVHJhbnNsYXRlTWVzc2FnZSgpIGhlcmUgc28gYSBXTV9DSEFSIGlzbid0IGdlbmVyYXRlZC4K LSAgICBkaWROb3RIYW5kbGVLZXlFdmVudENhbGxlZCA9IHRydWU7Ci19Ci0KLXN0YXRpYyB2b2lk IHJ1bkFuZFdhdGNoRm9yV01DaGFyKGJvb2wqIGRvbmUpCi17Ci0gICAgd2hpbGUgKCEqZG9uZSkg ewotICAgICAgICBNU0cgbXNnOwotICAgICAgICBCT09MIHJlc3VsdCA9IDo6R2V0TWVzc2FnZVco Jm1zZywgMCwgMCwgMCk7Ci0gICAgICAgIGlmICghcmVzdWx0IHx8IHJlc3VsdCA9PSAtMSkKLSAg ICAgICAgICAgIGJyZWFrOwotICAgICAgICAKLSAgICAgICAgaWYgKG1zZy5tZXNzYWdlID09IFdN X0NIQVIpCi0gICAgICAgICAgICBkaWRTZWVXTUNoYXIgPSB0cnVlOwotICAgICAgICAKLSAgICAg ICAgaWYgKFV0aWw6OnNob3VsZFRyYW5zbGF0ZU1lc3NhZ2UobXNnKSkKLSAgICAgICAgICAgIDo6 VHJhbnNsYXRlTWVzc2FnZSgmbXNnKTsKLSAgICAgICAgCi0gICAgICAgIDo6RGlzcGF0Y2hNZXNz YWdlKCZtc2cpOwotICAgIH0KLX0KLQotVEVTVChXZWJLaXQyLCBUcmFuc2xhdGVNZXNzYWdlR2Vu ZXJhdGVzV01DaGFyKQotewotICAgIFdLUmV0YWluUHRyPFdLQ29udGV4dFJlZj4gY29udGV4dChB ZG9wdFdLLCBXS0NvbnRleHRDcmVhdGUoKSk7Ci0gICAgUGxhdGZvcm1XZWJWaWV3IHdlYlZpZXco Y29udGV4dC5nZXQoKSk7Ci0KLSAgICB3ZWJWaWV3LnNpbXVsYXRlQUtleURvd24oKTsKLQotICAg IC8vIFdlYktpdCBzaG91bGQgY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgb24gdGhlIFdNX0tFWURP V04gbWVzc2FnZSB0byBnZW5lcmF0ZSB0aGUgV01fQ0hBUiBtZXNzYWdlLgotICAgIHJ1bkFuZFdh dGNoRm9yV01DaGFyKCZkaWRTZWVXTUNoYXIpOwotICAgIAotICAgIGRpZFNlZVdNQ2hhciA9IGZh bHNlOwotCi0gICAgV0tQYWdlVUlDbGllbnQgdWlDbGllbnQ7Ci0gICAgbWVtc2V0KCZ1aUNsaWVu dCwgMCwgc2l6ZW9mKHVpQ2xpZW50KSk7Ci0KLSAgICB1aUNsaWVudC5kaWROb3RIYW5kbGVLZXlF dmVudCA9IGRpZE5vdEhhbmRsZUtleUV2ZW50Q2FsbGJhY2s7Ci0gICAgV0tQYWdlU2V0UGFnZVVJ Q2xpZW50KHdlYlZpZXcucGFnZSgpLCAmdWlDbGllbnQpOwotCi0gICAgd2ViVmlldy5zaW11bGF0 ZUFLZXlEb3duKCk7Ci0KLSAgICBydW5BbmRXYXRjaEZvcldNQ2hhcigmZGlkTm90SGFuZGxlS2V5 RXZlbnRDYWxsZWQpOwotCi0gICAgLy8gV2ViS2l0IHNob3VsZCBub3QgaGF2ZSBjYWxsZWQgVHJh bnNsYXRlTWVzc2FnZSgpIG9uIHRoZSBXTV9LRVlET1dOIG1lc3NhZ2Ugc2luY2Ugd2UgaW5zdGFs bGVkIGEgZGlkTm90SGFuZGxlS2V5RXZlbnQgY2FsbGJhY2suCi0gICAgRVhQRUNUX0ZBTFNFKGRp ZFNlZVdNQ2hhcik7Ci19Ci0KLX0gLy8gbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkKSW5kZXg6IFRv b2xzL1Rlc3RXZWJLaXRBUEkvd2luL1BsYXRmb3JtVXRpbGl0aWVzV2luLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9QbGF0Zm9ybVV0aWxpdGllc1dpbi5jcHAJKHJl dmlzaW9uIDg3MDMwKQorKysgVG9vbHMvVGVzdFdlYktpdEFQSS93aW4vUGxhdGZvcm1VdGlsaXRp ZXNXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC00OSwyOSArNDksMTEgQEAgdm9pZCBydW4oYm9v bCogZG9uZSkKICAgICAgICAgQk9PTCByZXN1bHQgPSA6OkdldE1lc3NhZ2VXKCZtc2csIDAsIDAs IDApOwogICAgICAgICBpZiAoIXJlc3VsdCB8fCByZXN1bHQgPT0gLTEpCiAgICAgICAgICAgICBi cmVhazsKLSAgICAgICAgCi0gICAgICAgIGlmIChzaG91bGRUcmFuc2xhdGVNZXNzYWdlKG1zZykp Ci0gICAgICAgICAgICA6OlRyYW5zbGF0ZU1lc3NhZ2UoJm1zZyk7CisgICAgICAgIDo6VHJhbnNs YXRlTWVzc2FnZSgmbXNnKTsKICAgICAgICAgOjpEaXNwYXRjaE1lc3NhZ2UoJm1zZyk7CiAgICAg fQogfQogCi1ib29sIHNob3VsZFRyYW5zbGF0ZU1lc3NhZ2UoY29uc3QgTVNHJiBtc2cpCi17Ci0g ICAgLy8gT25seSB0aGVzZSBmb3VyIG1lc3NhZ2VzIGFyZSBhY3R1YWxseSB0cmFuc2xhdGVkIGJ5 IDo6VHJhbnNsYXRlTWVzc2FnZSBvciA6OlRyYW5zbGF0ZUFjY2VsZXJhdG9yLgotICAgIC8vIEl0 J3MgdXNlbGVzcyAodGhvdWdoIGhhcm1sZXNzKSB0byBjYWxsIHRob3NlIGZ1bmN0aW9ucyBmb3Ig b3RoZXIgbWVzc2FnZXMsIHNvIHdlIGFsd2F5cyBhbGxvdyBvdGhlciBtZXNzYWdlcyB0byBiZSB0 cmFuc2xhdGVkLgotICAgIGlmIChtc2cubWVzc2FnZSAhPSBXTV9LRVlET1dOICYmIG1zZy5tZXNz YWdlICE9IFdNX1NZU0tFWURPV04gJiYgbXNnLm1lc3NhZ2UgIT0gV01fS0VZVVAgJiYgbXNnLm1l c3NhZ2UgIT0gV01fU1lTS0VZVVApCi0gICAgICAgIHJldHVybiB0cnVlOwotICAgIAotICAgIHdj aGFyX3QgY2xhc3NOYW1lWzI1Nl07Ci0gICAgaWYgKCE6OkdldENsYXNzTmFtZVcobXNnLmh3bmQs IGNsYXNzTmFtZSwgQVJSQVlTSVpFKGNsYXNzTmFtZSkpKQotICAgICAgICByZXR1cm4gdHJ1ZTsK LQotICAgIC8vIERvbid0IGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIG9uIGtleSBldmVudHMgZGVz dGluZWQgZm9yIGEgV2ViS2l0MiB2aWV3LCBXZWJLaXQgd2lsbCBkbyB0aGlzIGlmIGl0IGRvZXNu J3QgaGFuZGxlIHRoZSBtZXNzYWdlLgotICAgIC8vIEl0IHdvdWxkIGJlIG5pY2UgdG8gdXNlIHNv bWUgQVBJIGhlcmUgaW5zdGVhZCBvZiBoYXJkLWNvZGluZyB0aGUgd2luZG93IGNsYXNzIG5hbWUu Ci0gICAgcmV0dXJuIHdjc2NtcChjbGFzc05hbWUsIEwiV2ViS2l0MldlYlZpZXdXaW5kb3dDbGFz cyIpOwotfQotCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKQogewogICAgIDo6U2xlZXAoc2Vj b25kcyAqIDEwMDApOwpJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQSS93aW4vUGxhdGZvcm1XZWJW aWV3V2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9QbGF0Zm9y bVdlYlZpZXdXaW4uY3BwCShyZXZpc2lvbiA4NzAzMCkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkv d2luL1BsYXRmb3JtV2ViVmlld1dpbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTkyLDE0ICs5Miw2 IEBAIHZvaWQgUGxhdGZvcm1XZWJWaWV3OjpzaW11bGF0ZVNwYWNlYmFyS2UKICAgICA6OlNlbmRN ZXNzYWdlVyh3aW5kb3csIFdNX0tFWVVQLCBWS19TUEFDRSwgKDEgPDwgcmVwZWF0Q291bnRCaXRP ZmZzZXQpIHwgKDM5IDw8IHNjYW5Db2RlQml0T2Zmc2V0KSB8ICgxIDw8IHByZXZpb3VzU3RhdGVC aXRPZmZzZXQpIHwgKDEgPDwgdHJhbnNpdGlvblN0YXRlQml0T2Zmc2V0KSk7CiB9CiAKLXZvaWQg UGxhdGZvcm1XZWJWaWV3OjpzaW11bGF0ZUFLZXlEb3duKCkKLXsKLSAgICBIV05EIHdpbmRvdyA9 IFdLVmlld0dldFdpbmRvdyhtX3ZpZXcpOwotICAgIAotICAgIC8vIFRoZXNlIHZhbHVlcyBtYXRj aCB3aGF0IGhhcHBlbnMgd2hlbiB5b3UgcHJlc3MgdGhlICdBJyBrZXkgaW4gTm90ZXBhZCwgYXMg b2JzZXJ2ZWQgYnkgU3B5KysuCi0gICAgOjpTZW5kTWVzc2FnZVcod2luZG93LCBXTV9LRVlET1dO LCAnQScsICgxIDw8IHJlcGVhdENvdW50Qml0T2Zmc2V0KSB8ICgzMCA8PCBzY2FuQ29kZUJpdE9m ZnNldCkpOwotfQotCiB2b2lkIFBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVBbHRLZXlQcmVzcygp CiB7CiAgICAgSFdORCB3aW5kb3cgPSBXS1ZpZXdHZXRXaW5kb3cobV92aWV3KTsKSW5kZXg6IFRv b2xzL1Rlc3RXZWJLaXRBUEkvd2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qCj09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0t IFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qCShyZXZpc2lvbiA4 NzAzMCkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qCSh3 b3JraW5nIGNvcHkpCkBAIC01NzUsMTAgKzU3NSw2IEBACiAJCQkJCQk+CiAJCQkJCTwvRmlsZT4K IAkJCQkJPEZpbGUKLQkJCQkJCVJlbGF0aXZlUGF0aD0iLi5cVGVzdHNcV2ViS2l0Mlx3aW5cVHJh bnNsYXRlTWVzc2FnZUdlbmVyYXRlc1dNQ2hhci5jcHAiCi0JCQkJCQk+Ci0JCQkJCTwvRmlsZT4K LQkJCQkJPEZpbGUKIAkJCQkJCVJlbGF0aXZlUGF0aD0iLi5cVGVzdHNcV2ViS2l0Mlx3aW5cV01D bG9zZUNhbGxzVUlDbGllbnRDbG9zZS5jcHAiCiAJCQkJCQk+CiAJCQkJCTwvRmlsZT4K 95937 2011-06-03 11:49:52 -0700 2011-07-22 10:05:29 -0700 Queue key events until we know whether the RawKeyDown was processed by WebKit KeyEventQueueing.patch text/plain 16116 jeffm SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDg4MDMwKQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsNDYgQEAKKzIwMTEtMDYtMDMgIEplZmYgTWls bGVyICA8amVmZm1AYXBwbGUuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIFdlYktpdDI6IENsaWVudHMgaGF2ZSB0byBrbm93IG5vdCB0byBjYWxs IFRyYW5zbGF0ZU1lc3NhZ2UoKSBvbiBrZXkgbWVzc2FnZXMgZGVzdGluZWQgZm9yIFdlYktpdDIg d2ViIHZpZXdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD01ODM3NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vOTI3NDUxMD4gKGFuZCBhbHNvIGZpeGVz IDxyZGFyOi8vcHJvYmxlbS85NDY5MTY1PikKKworICAgICAgICBPdXIgY3VycmVudCBkZXNpZ24g b2YgbWFraW5nIFdlYktpdCBjbGllbnRzIG9uIFdpbmRvd3Mgd2FpdCB0byBjYWxsIFRyYW5zbGF0 ZU1lc3NhZ2UoKSB1bnRpbCB0aGV5IGtub3cgdGhhdAorICAgICAgICBXZWJLaXQgZGlkbid0IGhh bmRsZSB0aGUga2V5IGRvd24gaXMgdW50ZW5hYmxlLCBzaW5jZSBjbGllbnRzIGRvbid0IGFsd2F5 cyBoYXZlIGNvbnRyb2wgb3ZlciB3aGVuIFRyYW5zbGF0ZU1lc3NhZ2UoKQorICAgICAgICBpcyBj YWxsZWQgKGUuZy4gd2hlbiBXaW5kb3dzIHB1bXBzIG1lc3NhZ2VzIGluIERpYWxvZ0JveCgpIG9y IE1lc3NhZ2VCb3goKSkuIEluc3RlYWQsIFdlYktpdCBub3cgYXNzdW1lcyB0aGF0IGNsaWVudHMK KyAgICAgICAgYWx3YXlzIGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIGltbWVkaWF0ZWx5LgorICAg ICAgICAKKyAgICAgICAgVGhpcyBtZWFucyB0aGF0IFdlYlBhZ2VQcm94eSBpbiB0aGUgVUkgcHJv Y2VzcyBuZWVkcyB0byBxdWV1ZSB1cCBrZXkgZXZlbnRzIHRoYXQgZm9sbG93IGEgUmF3S2V5RG93 biBldmVudAorICAgICAgICAodGhlIGVxdWl2YWxlbnQgb2YgYSBXTV9LRVlET1dOIG1lc3NhZ2Up IHVudGlsIHRoZSB3ZWIgcHJvY2VzcyBpbmZvcm1zIGl0IHdoZXRoZXIgdGhlIFJhd0tleURvd24g ZXZlbnQgd2FzIGhhbmRsZWQuCisgICAgICAgIElmIFdlYktpdCBoYW5kbGVkIHRoZSBldmVudCwg V2ViUGFnZVByb3h5IGRyb3BzIGFueSBDaGFyIGV2ZW50cyB0aGF0IHdlcmUgcmVjZWl2ZWQgYWZ0 ZXIgdGhlIFJhd0tleURvd24uCisgICAgICAgIElmIFdlYktpdCBkaWRuJ3QgaGFuZGxlIHRoZSBl dmVudCwgV2ViUGFnZVByb3h5IHNlbmRzIGFueSBxdWV1ZWQgQ2hhciBldmVudHMgZm9yIHRoZSBS YXdLZXlEb3duIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAgSW4gZWl0aGVyIGNhc2UsIGl0 IGFsd2F5cyBzZW5kcyBhbnkgS2V5VXAgZXZlbnRzLiBGaW5hbGx5LCBpZiBhbiBhZGRpdGlvbmFs IFJhd0tleURvd24gZXZlbnQgd2FzIHJlY2VpdmVkIHdoaWxlIHRoZSBjdXJyZW50CisgICAgICAg IFJhd0tleURvd24gd2FzIGluIHByb2Nlc3MsIGl0IHNlbmRzIHRoYXQgZXZlbnQgYXMgd2VsbC4K KyAgICAgICAgCisgICAgICAgIFVuZm9ydHVuYXRlbHksIHRoZXJlJ3Mgbm8gd2F5IHRvIGRldGVy bWluZSB0aGF0IGEgV01fQ0hBUiBtZXNzYWdlIHdhcyBnZW5lcmF0ZWQgZnJvbSBjYWxsaW5nIFRy YW5zbGF0ZU1lc3NhZ2UoKSB3aXRoIGEKKyAgICAgICAgc3BlY2lmaWMgV01fS0VZRE9XTiBtZXNz YWdlLiAgV2UganVzdCBhc3NvY2lhdGUgYW55IENoYXIgZXZlbnQgdGhhdCdzIHJlY2VpdmVkIHdp dGggdGhlIGxhc3QgdW5wcm9jZXNzZWQgUmF3S2V5RG93biB3ZSd2ZSBzZWVuLgorICAgICAgICBH ZW5lcmFsbHksIGFueSBSYXdLZXlEb3duIGV2ZW50IHNob3VsZCBldmVudHVhbGx5IGJlIGZvbGxv d2VkIGJ5IGEgS2V5VXAgZXZlbnQsIGJ1dCB3aGlsZSB3ZSBjYW4gdXNlIHRoaXMgYXMgYSBoaW50 IHRoYXQKKyAgICAgICAgdGhlIHRyYW5zYWN0aW9uIGlzIGNvbXBsZXRlLCB0aGVyZSdzIG5vIGd1 YXJhbnRlZSB0aGF0IGEgS2V5VXAgd2lsbCBhbHdheXMgYmUgc2VudC4KKyAgICAgICAgCisgICAg ICAgIEluIHRoZW9yeSwgc29tZW9uZSBjb3VsZCBhcnRpZmljaWFsbHkgc2VuZCBhIFdNX0NIQVIg bWVzc2FnZSB0byB0aGUgd2ViIHZpZXcgd2l0aG91dCBhIFdNX0tFWURPV04sIHNvIEkgdHJpZWQg dG8gYWNjb3VudCBmb3IgdGhpcworICAgICAgICBwb3NzaWJpbGl0eSBhcyB3ZWxsIGJ5IGxpbWl0 aW5nIHRoZSBhbW91bnQgb2YgdGltZSB3ZSBzd2FsbG93IENoYXIgZXZlbnRzIHdoZW4gdGhlIGxh c3QgUmF3S2V5RG93biB3YXMgaGFuZGxlZCBieSBXZWJLaXQgdG8gMSBzZWNvbmQuCisgICAgICAg IElmIHdlIGdldCBhIEtleVVwIGV2ZW50LCB3aGljaCBpcyB3aGF0IHR5cGljYWxseSBoYXBwZW5z LCB0aGlzIHRpbWVvdXQgaXNuJ3QgbmVjZXNzYXJ5LgorICAgICAgICAKKyAgICAgICAgKiBVSVBy b2Nlc3MvV2ViUGFnZVByb3h5LmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjpX ZWJQYWdlUHJveHkpOiBJbml0aWFsaXplIG5ldyBXaW5kb3dzLXNwZWNpZmljIGl2YXJzLgorICAg ICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmhhbmRsZUtleWJvYXJkRXZlbnQpOiBBZGQgbW9y ZSBsb2dnaW5nIGFuZCBjaGVjayB3aXRoIHNob3VsZEhhbmRsZUtleWJvYXJkRXZlbnQoKSBiZWZv cmUgc2VuZGluZyB0aGUgZXZlbnQgb24gV2luZG93cy4KKyAgICAgICAgKFdlYktpdDo6V2ViUGFn ZVByb3h5OjpkaWRSZWNlaXZlRXZlbnQpOiBDYWxsIGRvbmVXaXRoS2V5RXZlbnQoKSBhbmQgc3Rv cCBjYWxsaW5nIFRyYW5zbGF0ZU1lc3NhZ2UoKSBvbiBXaW5kb3dzLgorICAgICAgICAoV2ViS2l0 OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRDcmFzaCk6IEluaXRpYWxpemUgbmV3IFdpbmRvd3Mt c3BlY2lmaWMgaXZhcnMgd2hlbiB3ZWIgcHJvY2VzcyBjcmFzaGVzLgorICAgICAgICAKKyAgICAg ICAgKiBVSVByb2Nlc3MvV2ViUGFnZVByb3h5Lmg6IEFkZGVkIG5ldyBXaW5kb3dzLXNwZWNpZmlj IGl2YXJzIGFuZCBtZW1iZXIgZnVuY3Rpb25zLgorICAgICAgICAKKyAgICAgICAgKiBVSVByb2Nl c3Mvd2luL1dlYlBhZ2VQcm94eVdpbi5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94 eTo6c2hvdWxkSGFuZGxlS2V5Ym9hcmRFdmVudCk6IEFkZGVkLCBxdWV1ZXMga2V5IGV2ZW50cyBm b3IgbGF0ZXIgcHJvY2Vzc2luZyBhcyBuZWNlc3NhcnkuCisgICAgICAgIChXZWJLaXQ6OmlzU2Ft ZVJhd0tleURvd25FdmVudCk6IEFkZGVkLgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6 OmRvbmVXaXRoS2V5RXZlbnQpOiBBZGRlZCwgaWYgdGhlIGV2ZW50IGlzIGEgUmF3S2V5RG93biwg cHJvY2Vzc2VzIGFueSBxdWV1ZWQgS2V5VXAgYW5kIENoYXIgZXZlbnRzLgorICAgICAgICAoV2Vi S2l0OjpXZWJQYWdlUHJveHk6OnByb2Nlc3NLZXlFdmVudHMpOiBBZGRlZCwgc2VuZHMgYWxsIHF1 ZXVlZCBLZXlVcCBhbmQgKG9wdGlvbmFsbHkpIENoYXIgZXZlbnRzIGZvciB0aGUgbGFzdCBSYXdL ZXlEb3duIGV2ZW50LCBhbmQgc2VuZHMgdGhlIG5leHQgUmF3S2V5RG93bi4KKwogMjAxMS0wNi0w MyAgTm8nYW0gUm9zZW50aGFsICA8bm9hbS5yb3NlbnRoYWxAbm9raWEuY29tPgogCiAgICAgICAg IFJldmlld2VkIGJ5IEFuZHJlYXMgS2xpbmcuCkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvV2ViUGFnZVByb3h5LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvV2ViUGFnZVByb3h5LmNwcAkocmV2aXNpb24gODgwMjApCisrKyBTb3VyY2UvV2ViS2l0Mi9V SVByb2Nlc3MvV2ViUGFnZVByb3h5LmNwcAkod29ya2luZyBjb3B5KQpAQCAtMTY0LDYgKzE2NCwx MCBAQCBXZWJQYWdlUHJveHk6OldlYlBhZ2VQcm94eShQYWdlQ2xpZW50KiBwCiAgICAgLCBtX3N5 bmNOYXZpZ2F0aW9uQWN0aW9uUG9saWN5QWN0aW9uSXNWYWxpZChmYWxzZSkKICAgICAsIG1fc3lu Y05hdmlnYXRpb25BY3Rpb25Qb2xpY3lBY3Rpb24oUG9saWN5VXNlKQogICAgICwgbV9zeW5jTmF2 aWdhdGlvbkFjdGlvblBvbGljeURvd25sb2FkSUQoMCkKKyNpZiBQTEFURk9STShXSU4pCisgICAg LCBtX2Fsd2F5c0hhbmRsZUtleUV2ZW50KGZhbHNlKQorICAgICwgbV9hc3N1bWVMYXN0UmF3S2V5 RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0VW50aWwoMCkKKyNlbmRpZgogICAgICwgbV9wcm9j ZXNzaW5nTW91c2VNb3ZlRXZlbnQoZmFsc2UpCiAgICAgLCBtX3BhZ2VJRChwYWdlSUQpCiAjaWYg UExBVEZPUk0oTUFDKQpAQCAtOTI4LDYgKzkzMiwyMCBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6aGFu ZGxlS2V5Ym9hcmRFdmVudChjCiAgICAgCiAgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVBy b3h5OjpoYW5kbGVLZXlib2FyZEV2ZW50OiAlcyIsIHdlYktleWJvYXJkRXZlbnRUeXBlU3RyaW5n KGV2ZW50LnR5cGUoKSkpOwogCisjaWYgUExBVEZPUk0oV0lOKQorICAgIGlmICghbV9hbHdheXNI YW5kbGVLZXlFdmVudCAmJiAhc2hvdWxkSGFuZGxlS2V5Ym9hcmRFdmVudChldmVudCkpIHsKKyAg ICAgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5OjpoYW5kbGVLZXlib2FyZEV2ZW50 OiBpZ25vcmluZyAlcyIsIHdlYktleWJvYXJkRXZlbnRUeXBlU3RyaW5nKGV2ZW50LnR5cGUoKSkp OworICAgICAgICByZXR1cm47CisgICAgfQorCisjaWYgIUxPR19ESVNBQkxFRAorICAgIGlmIChl dmVudC50eXBlKCkgPT0gV2ViRXZlbnQ6OkNoYXIpCisgICAgICAgIExPRyhLZXlIYW5kbGluZywg IldlYlBhZ2VQcm94eTo6aGFuZGxlS2V5Ym9hcmRFdmVudDogc2VuZGluZyBDaGFyICglYykiLCBl dmVudC5uYXRpdmVFdmVudCgpLT53UGFyYW0pOworICAgIGVsc2UKKyAgICAgICAgTE9HKEtleUhh bmRsaW5nLCAiV2ViUGFnZVByb3h5OjpoYW5kbGVLZXlib2FyZEV2ZW50OiBzZW5kaW5nICVzIiwg d2ViS2V5Ym9hcmRFdmVudFR5cGVTdHJpbmcoZXZlbnQudHlwZSgpKSk7CisjZW5kaWYKKyNlbmRp ZgorCiAgICAgbV9rZXlFdmVudFF1ZXVlLmFwcGVuZChldmVudCk7CiAKICAgICBwcm9jZXNzKCkt PnJlc3BvbnNpdmVuZXNzVGltZXIoKS0+c3RhcnQoKTsKQEAgLTI3NDQsMTUgKzI3NjIsMTUgQEAg dm9pZCBXZWJQYWdlUHJveHk6OmRpZFJlY2VpdmVFdmVudCh1aW50MwogCiAgICAgICAgIG1fcGFn ZUNsaWVudC0+ZG9uZVdpdGhLZXlFdmVudChldmVudCwgaGFuZGxlZCk7CiAKKyNpZiBQTEFURk9S TShXSU4pCisgICAgICAgIGRvbmVXaXRoS2V5RXZlbnQoZXZlbnQsIGhhbmRsZWQpOworI2VuZGlm CisKICAgICAgICAgaWYgKGhhbmRsZWQpCiAgICAgICAgICAgICBicmVhazsKIAogICAgICAgICBp ZiAobV91aUNsaWVudC5pbXBsZW1lbnRzRGlkTm90SGFuZGxlS2V5RXZlbnQoKSkKICAgICAgICAg ICAgIG1fdWlDbGllbnQuZGlkTm90SGFuZGxlS2V5RXZlbnQodGhpcywgZXZlbnQpOwotI2lmIFBM QVRGT1JNKFdJTikKLSAgICAgICAgZWxzZQotICAgICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdl KGV2ZW50Lm5hdGl2ZUV2ZW50KCkpOwotI2VuZGlmCiAgICAgICAgIGJyZWFrOwogICAgIH0KICAg ICB9CkBAIC0yOTQzLDYgKzI5NjEsMTEgQEAgdm9pZCBXZWJQYWdlUHJveHk6OnByb2Nlc3NEaWRD cmFzaCgpCiAgICAgLy8gQ2FuJ3QgZXhwZWN0IERpZFJlY2VpdmVFdmVudCBub3RpZmljYXRpb25z IGZyb20gYSBjcmFzaGVkIHdlYiBwcm9jZXNzLgogICAgIG1fa2V5RXZlbnRRdWV1ZS5jbGVhcigp OwogICAgIAorI2lmIFBMQVRGT1JNKFdJTikKKyAgICBtX3VucHJvY2Vzc2VkS2V5RXZlbnRRdWV1 ZS5jbGVhcigpOworICAgIG1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hhbmRsZWRCeVdl YktpdFVudGlsID0gMDsKKyNlbmRpZgorICAgIAogICAgIG1fd2hlZWxFdmVudFF1ZXVlLmNsZWFy KCk7CiAgICAgbV9jdXJyZW50bHlQcm9jZXNzZWRXaGVlbEV2ZW50cy5jbGVhcigpOwogCkluZGV4 OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5LmgKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94eS5oCShyZXZpc2lvbiA4ODAyMCkK KysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJveHkuaAkod29ya2luZyBjb3B5 KQpAQCAtNjU3LDYgKzY1NywxMiBAQCBwcml2YXRlOgogICAgIHZvaWQgZXhlY3V0ZVNhdmVkQ29t bWFuZEJ5U2VsZWN0b3IoY29uc3QgU3RyaW5nJiBzZWxlY3RvciwgYm9vbCYgaGFuZGxlZCk7CiAj ZW5kaWYKIAorI2lmIFBMQVRGT1JNKFdJTikKKyAgICBib29sIHNob3VsZEhhbmRsZUtleWJvYXJk RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYpOworICAgIHZvaWQgZG9uZVdpdGhL ZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCk7CisgICAgdm9pZCBw cm9jZXNzS2V5RXZlbnRzKGJvb2wpOworI2VuZGlmCisKICNpZiBQTEFURk9STShHVEspCiAgICAg dm9pZCBnZXRFZGl0b3JDb21tYW5kc0ZvcktleUV2ZW50KFZlY3RvcjxTdHJpbmc+Jik7CiAjZW5k aWYKQEAgLTg1NCw2ICs4NjAsMTIgQEAgcHJpdmF0ZToKICAgICB1aW50NjRfdCBtX3N5bmNOYXZp Z2F0aW9uQWN0aW9uUG9saWN5RG93bmxvYWRJRDsKIAogICAgIERlcXVlPE5hdGl2ZVdlYktleWJv YXJkRXZlbnQ+IG1fa2V5RXZlbnRRdWV1ZTsKKyAKKyNpZiBQTEFURk9STShXSU4pCisgICAgRGVx dWU8TmF0aXZlV2ViS2V5Ym9hcmRFdmVudD4gbV91bnByb2Nlc3NlZEtleUV2ZW50UXVldWU7Cisg ICAgZG91YmxlIG1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdFVu dGlsOworICAgIGJvb2wgbV9hbHdheXNIYW5kbGVLZXlFdmVudDsKKyNlbmRpZgogCiAgICAgRGVx dWU8TmF0aXZlV2ViV2hlZWxFdmVudD4gbV93aGVlbEV2ZW50UXVldWU7CiAgICAgVmVjdG9yPE5h dGl2ZVdlYldoZWVsRXZlbnQ+IG1fY3VycmVudGx5UHJvY2Vzc2VkV2hlZWxFdmVudHM7CkluZGV4 OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3Mvd2luL1dlYlBhZ2VQcm94eVdpbi5jcHAKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL3dpbi9XZWJQYWdlUHJveHlXaW4uY3Bw CShyZXZpc2lvbiA4ODAyMCkKKysrIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy93aW4vV2ViUGFn ZVByb3h5V2luLmNwcAkod29ya2luZyBjb3B5KQpAQCAtMjYsNiArMjYsOCBAQAogI2luY2x1ZGUg ImNvbmZpZy5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94eS5oIgogCisjaW5jbHVkZSAiTG9nZ2lu Zy5oIgorI2luY2x1ZGUgIk5hdGl2ZVdlYktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJQYWdl Q2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViUG9wdXBNZW51UHJveHlXaW4uaCIKIApAQCAtMzMsNiAr MzUsNyBAQAogI2luY2x1ZGUgPHRjaGFyLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9TeXN0ZW1JbmZv Lmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9XZWJDb3JlSW5zdGFuY2VIYW5kbGUuaD4KKyNpbmNsdWRl IDx3dGYvQ3VycmVudFRpbWUuaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAjaW5j bHVkZSA8d3RmL3RleHQvU3RyaW5nQ29uY2F0ZW5hdGUuaD4KIApAQCAtNDAsNiArNDMsMTEgQEAg dXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiAKIG5hbWVzcGFjZSBXZWJLaXQgewogCisvLyBBcmJp dHJhcnkgYW1vdW50IG9mIHRpbWUgZHVyaW5nIHdoaWNoIHdlIGFzc3VtZSB0aGF0IHdlIHNob3Vs ZCBpZ25vcmUgYW55IENoYXIgZXZlbnRzIHRoYXQgY29tZSBpbiBhZnRlciBhIFJhd0tleURvd24g ZXZlbnQgdGhhdCB3YXMgaGFuZGxlZCBieSBXZWJLaXQuCisvLyBOb3JtYWxseSwgYSBDaGFyIGV2 ZW50IHdpbGwgYmUgZ2VuZXJhdGVkIGZyb20gYSBSYXdLZXlEb3duIGV2ZW50LCBhbmQgd2lsbCBh cnJpdmUgY2xvc2UgdG8gdGhlIFJhd0tleURvd24gZXZlbnQuICBIb3dldmVyLCBqdXN0IGluIGNh c2UKKy8vIHNvbWVvbmUgaXMgYXJ0aWZpY2lhbGx5IGluamVjdGluZyBDaGFyIGV2ZW50cyBsYXRl ciwgd2UgZG9uJ3Qgd2FudCB0byBtaXN0YWtlbmx5IHN3YWxsb3cgdGhlbS4KK3N0YXRpYyBjb25z dCBkb3VibGUga0ludGVydmFsVG9Bc3N1bWVMYXN0UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5 V2ViS2l0SW5NUyA9IDEwMDA7CisKIHN0YXRpYyBTdHJpbmcgdXNlclZpc2libGVXZWJLaXRWZXJz aW9uU3RyaW5nKCkKIHsKICAgICBMUFdTVFIgYnVpbGROdW1iZXJTdHJpbmdQdHI7CkBAIC04MCw0 ICs4OCwxNDUgQEAgdm9pZCBXZWJQYWdlUHJveHk6OmRpZEluc3RhbGxPclVuaW5zdGFsbAogICAg IG1fcGFnZUNsaWVudC0+ZGlkSW5zdGFsbE9yVW5pbnN0YWxsUGFnZU92ZXJsYXkoZGlkSW5zdGFs bCk7CiB9CiAKK2Jvb2wgV2ViUGFnZVByb3h5OjpzaG91bGRIYW5kbGVLZXlib2FyZEV2ZW50KGNv bnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmIGV2ZW50KQoreworICAgIC8vIFdlIHNob3VsZCBu ZXZlciBnZW5lcmF0ZSBLZXlEb3duIGV2ZW50cyBvbiBXaW5kb3dzLCB3ZSBhbHdheXMgdXNlIFJh d0tleURvd24uCisgICAgQVNTRVJUKGV2ZW50LnR5cGUoKSAhPSBXZWJFdmVudDo6S2V5RG93bik7 CisgICAgCisgICAgaWYgKGV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6UmF3S2V5RG93bikgewor ICAgICAgICAvLyBXaGVuIHdlIHJlY2VpdmUgYSBSYXdLZXlEb3duIGV2ZW50LCB3ZSBuZWVkIHRv IHF1ZXVlIHVwIGFueSBzdWJzZXF1ZW50IENoYXIgYW5kIEtleVVwCisgICAgICAgIC8vIGV2ZW50 cyB1bnRpbCB3ZSBrbm93IHdoZXRoZXIgV2ViS2l0IGhhcyBoYW5kbGVkIHRoZSBSYXdLZXlEb3du LgorICAgICAgICBib29sIHVucHJvY2Vzc2VkS2V5RXZlbnRRdWV1ZVdhc0VtcHR5ID0gbV91bnBy b2Nlc3NlZEtleUV2ZW50UXVldWUuaXNFbXB0eSgpOworICAgICAgICBMT0coS2V5SGFuZGxpbmcs ICJXZWJQYWdlUHJveHk6OmhhbmRsZUtleWJvYXJkRXZlbnQ6IHF1ZXVlaW5nIFJhd0tleURvd24i KTsKKyAgICAgICAgbV91bnByb2Nlc3NlZEtleUV2ZW50UXVldWUuYXBwZW5kKGV2ZW50KTsKKyAg ICAgICAgCisgICAgICAgIC8vIElmIHdlIGFscmVhZHkgaGF2ZSBhIEtleURvd24gaW4tZmxpZ2h0 IHRvIHRoZSB3ZWIgcHJvY2VzcywgZG9uJ3Qgc2VuZCBhbnkgbmV3IEtleURvd24KKyAgICAgICAg Ly8gZXZlbnRzIHVudGlsIHdlIGtub3cgd2hldGhlciB0aGUgb3RoZXIgS2V5RG93biBpcyBoYW5k bGVkIHNvIHdlIGRlbGl2ZXIga2V5IGV2ZW50cworICAgICAgICAvLyBpbiB0aGUgc2FtZSBvcmRl ciB0aGV5IHdlcmUgcmVjZWl2ZWQuCisgICAgICAgIHJldHVybiB1bnByb2Nlc3NlZEtleUV2ZW50 UXVldWVXYXNFbXB0eTsKKyAgICB9CisgICAgCisgICAgaWYgKChldmVudC50eXBlKCkgIT0gV2Vi RXZlbnQ6OkNoYXIpICYmIChldmVudC50eXBlKCkgIT0gV2ViRXZlbnQ6OktleVVwKSkgeworICAg ICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQor ICAgIAorICAgIC8vIFF1ZXVlIHVwIGFueSBDaGFyIG9yIEtleVVwIGV2ZW50cyB3ZSByZWNlaXZl IGJlZm9yZSB3ZSBrbm93IHdoZXRoZXIgdGhlIHdlYiBwcm9jZXNzIGhhcyBoYW5kbGVkIHRoZQor ICAgIC8vIGxhc3QgUmF3S2V5RG93biB0aGUgd2Ugc2F3LgorICAgIGlmICghbV91bnByb2Nlc3Nl ZEtleUV2ZW50UXVldWUuaXNFbXB0eSgpKSB7CisjaWYgIUxPR19ESVNBQkxFRAorICAgICAgICBp ZiAoZXZlbnQudHlwZSgpID09IFdlYkV2ZW50OjpDaGFyKQorICAgICAgICAgICAgTE9HKEtleUhh bmRsaW5nLCAiV2ViUGFnZVByb3h5OjpzaG91bGRIYW5kbGVLZXlib2FyZEV2ZW50OiBxdWV1ZWlu ZyBDaGFyICglYykiLCBldmVudC5uYXRpdmVFdmVudCgpLT53UGFyYW0pOworICAgICAgICBlbHNl CisgICAgICAgICAgICBMT0coS2V5SGFuZGxpbmcsICJXZWJQYWdlUHJveHk6OnNob3VsZEhhbmRs ZUtleWJvYXJkRXZlbnQ6IHF1ZXVlaW5nIEtleVVwIik7CisjZW5kaWYKKyAgICAgICAgbV91bnBy b2Nlc3NlZEtleUV2ZW50UXVldWUuYXBwZW5kKGV2ZW50KTsKKyAgICAgICAgcmV0dXJuIGZhbHNl OworICAgIH0KKyAgICAKKyAgICAvLyBXZWJLaXQgaGFzIHByb2Nlc3NlZCBhbGwgb3V0c3RhbmRp bmcgUmF3S2V5RG93biBldmVudHMsIHdlIGFsd2F5cyB3YW50IHRvIGhhbmRsZSBLZXlVcCBldmVu dHMgaGVyZS4KKyAgICBpZiAoZXZlbnQudHlwZSgpID09IFdlYkV2ZW50OjpLZXlVcCkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgLy8gSWYgd2UgZ2V0IGEgQ2hhciBldmVudCBhZnRl ciBXZWJLaXQgaGFzIHByb2Nlc3NlZCBhbGwgb3V0c3RhbmRpbmcgUmF3S2V5RG93biBldmVudHMs IHdlIG5lZWQgdG8KKyAgICAvLyBkcm9wIGl0IG9uIHRoZSBmbG9vciBpZiBXZWJLaXQgaGFuZGxl ZCB0aGUgbGFzdCBSYXdLZXlEb3duLiBJbiBwcmFjdGljZSwgdGhpcyByYXJlbHkgaGFwcGVucy4K KyAgICAvLyBVc3VhbGx5LCB3ZSdsbCBnZXQgYW4gaW50ZXJ2ZW5pbmcgS2V5VXAgd2hpY2ggd2ls bCBpbnZhbGlkYXRlIG1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktp dFVudGlsLAorICAgIC8vIGJ1dCBqdXN0IGluIGNhc2Ugd2UgZG9uJ3Qgd2UgbGltaXQgdGhlIGFt b3VudCBvZiB0aW1lIHdlIHN3YWxsb3cgQ2hhciBldmVudHMuCisgICAgaWYgKCFtX2Fzc3VtZUxh c3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXRVbnRpbCB8fCAoY3VycmVudFRpbWVN UygpID4gbV9hc3N1bWVMYXN0UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0VW50aWwp KSB7CisgICAgICAgIC8vIFRoZXJlJ3Mgbm8gb3V0c3RhbmRpbmcgUmF3S2V5RG93biwgYW5kIFdl YktpdCBkaWRuJ3QgaGFuZGxlIHRoZSBsYXN0IFJhd0tleURvd24gKG9yIGhhbmRsZWQgaXQgdG9v IGZhciBpbiB0aGUgcGFzdCksIHNvIGl0J3MgT0sgdG8gc2VuZCB0aGUgZXZlbnQuCisjaWYgIUxP R19ESVNBQkxFRAorICAgICAgICAvLyBJdCdzIGV4dHJlbWVseSB1bnVzdWFsIHRvIHJlY2VpdmUg YSBDaGFyIGV2ZW50IGFmdGVyIG1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hhbmRsZWRC eVdlYktpdFVudGlsIHdpdGhvdXQgYW4gaW50ZXJ2ZW5pbmcgUmF3S2V5RG93biwgc28gbG9nIHRo aXMuCisgICAgICAgIGlmIChtX2Fzc3VtZUxhc3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlX ZWJLaXRVbnRpbCkKKyAgICAgICAgICAgIExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6 c2hvdWxkSGFuZGxlS2V5Ym9hcmRFdmVudDogcmVjZWl2ZWQgQ2hhciBhZnRlciB0aW1lb3V0IGZv ciBsYXN0IGhhbmRsZWQgUmF3S2V5RG93biIpOworI2VuZGlmCisKKyAgICAgICAgbV9hc3N1bWVM YXN0UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0VW50aWwgPSAwOworICAgICAgICBy ZXR1cm4gdHJ1ZTsKKyAgICB9CisgICAgCisgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVBy b3h5OjpzaG91bGRIYW5kbGVLZXlib2FyZEV2ZW50OiBpZ25vcmluZyBDaGFyICglYykgZm9yIGxh c3QgaGFuZGxlZCBSYXdLZXlEb3duIiwgZXZlbnQubmF0aXZlRXZlbnQoKS0+d1BhcmFtKTsKKyAg ICByZXR1cm4gZmFsc2U7Cit9CisKKyNpZiAhQVNTRVJUX0RJU0FCTEVECitzdGF0aWMgYm9vbCBp c1NhbWVSYXdLZXlEb3duRXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgcmF3S2V5 RG93bkV2ZW50MSwgY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgcmF3S2V5RG93bkV2ZW50 MikKK3sKKyAgICByZXR1cm4gKChyYXdLZXlEb3duRXZlbnQxLm5hdGl2ZUV2ZW50KCktPmh3bmQg PT0gcmF3S2V5RG93bkV2ZW50Mi5uYXRpdmVFdmVudCgpLT5od25kKSAmJiAocmF3S2V5RG93bkV2 ZW50MS5uYXRpdmVFdmVudCgpLT5tZXNzYWdlID09IHJhd0tleURvd25FdmVudDIubmF0aXZlRXZl bnQoKS0+bWVzc2FnZSkKKyAgICAgICAgJiYgKHJhd0tleURvd25FdmVudDEubmF0aXZlRXZlbnQo KS0+d1BhcmFtID09IHJhd0tleURvd25FdmVudDIubmF0aXZlRXZlbnQoKS0+d1BhcmFtKSAmJiAo cmF3S2V5RG93bkV2ZW50MS5uYXRpdmVFdmVudCgpLT5sUGFyYW0gPT0gcmF3S2V5RG93bkV2ZW50 Mi5uYXRpdmVFdmVudCgpLT5sUGFyYW0pKTsKK30KKyNlbmRpZgorCit2b2lkIFdlYlBhZ2VQcm94 eTo6ZG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiBldmVudCwg Ym9vbCBoYW5kbGVkKQoreworICAgIGlmIChldmVudC50eXBlKCkgPT0gV2ViRXZlbnQ6OkNoYXIp CisgICAgICAgIHJldHVybjsKKyAgICAKKyAgICBpZiAoZXZlbnQudHlwZSgpICE9IFdlYkV2ZW50 OjpSYXdLZXlEb3duKSB7CisgICAgICAgIC8vIEFzIHNvb24gYXMgd2UgZ2V0IGEga2V5IGV2ZW50 IHRoYXQgaXNuJ3QgYSBSYXdLZXlEb3duIG9yIENoYXIsIHdlIGNhbiByZXNldCBtX2Fzc3VtZUxh c3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXRVbnRpbC4KKyAgICAgICAgLy8gSW4g cHJhY3RpY2UsIHRoZSBvbmx5IG90aGVyIGtleSBldmVudCB3ZSBzaG91bGQgYmUgZ2VuZXJhdGlu ZyBvbiBXaW5kb3dzIGlzIEtleVVwLgorICAgICAgICBBU1NFUlQoZXZlbnQudHlwZSgpID09IFdl YkV2ZW50OjpLZXlVcCk7CisgICAgICAgIG1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hh bmRsZWRCeVdlYktpdFVudGlsID0gMDsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICAKKyAg ICAvLyBUaGUgd2ViIHByb2Nlc3MgaGFzIHByb2Nlc3NlZCBhIFJhd0tleURvd24gZXZlbnQsIHdo aWNoIHNob3VsZCBiZSB0aGUgZmlyc3QgZXZlbnQgaW4gbV91bnByb2Nlc3NlZEtleUV2ZW50UXVl dWUsCisgICAgLy8gZm9sbG93ZWQgYnkgYW55IENoYXIgYW5kIEtleVVwIGV2ZW50cyB3ZSBxdWV1 ZWQgZm9yIHRoZSBSYXdLZXlEb3duLgorICAgIEFTU0VSVCghbV91bnByb2Nlc3NlZEtleUV2ZW50 UXVldWUuaXNFbXB0eSgpKTsKKyAgICBOYXRpdmVXZWJLZXlib2FyZEV2ZW50IHJhd0tleURvd25F dmVudCA9IG1fdW5wcm9jZXNzZWRLZXlFdmVudFF1ZXVlLmZpcnN0KCk7CisgICAgbV91bnByb2Nl c3NlZEtleUV2ZW50UXVldWUucmVtb3ZlRmlyc3QoKTsKKyAgICAKKyAgICBBU1NFUlQocmF3S2V5 RG93bkV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6UmF3S2V5RG93bik7CisgICAgCisgICAgLy8g V2Ugc2hvdWxkIGFsd2F5cyBiZSBub3RpZmllZCB0aGF0IGFuIGV2ZW50IHdhcyBwcm9jZXNzZWQg aW4gdGhlIHNhbWUgb3JkZXIgdGhhdCBldmVudHMgYXJlIHJlY2VpdmVkLgorICAgIEFTU0VSVChp c1NhbWVSYXdLZXlEb3duRXZlbnQocmF3S2V5RG93bkV2ZW50LCBldmVudCkpOworICAgIAorICAg IGlmIChoYW5kbGVkKSB7CisgICAgICAgIExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6 ZG9uZVdpdGhLZXlFdmVudDogUmF3S2V5RG93biBoYW5kbGVkIik7CisgICAgICAgIAorICAgICAg ICAvLyBEcm9wIGFueSBDaGFyIGV2ZW50cyBmb3IgdGhpcyBSYXdLZXlEb3duIG9uIHRoZSBmbG9v ciAoYnV0IHNlbmQgYW55IEtleVVwIGV2ZW50cykuCisgICAgICAgIHByb2Nlc3NLZXlFdmVudHMo ZmFsc2UpOworCisgICAgICAgIC8vIElmIHdlIGdldCBmdXJ0aGVyIENoYXIgZXZlbnRzIHdpdGhp biBrSW50ZXJ2YWxUb0Fzc3VtZUxhc3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXRJ bk1TIG9mIGhhdmluZyBiZWVuIG5vdGlmaWVkIHRoYXQKKyAgICAgICAgLy8gdGhlIGxhc3QgUmF3 S2V5RG93biB3YXMgaGFuZGxlZCwgd2Ugd2FudCB0byBkcm9wIHRoZW0gb24gdGhlIGZsb29yIGFz IHdlbGwuIAorICAgICAgICBtX2Fzc3VtZUxhc3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlX ZWJLaXRVbnRpbCA9IG1fdW5wcm9jZXNzZWRLZXlFdmVudFF1ZXVlLmlzRW1wdHkoKSA/IGN1cnJl bnRUaW1lTVMoKSArIGtJbnRlcnZhbFRvQXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hhbmRs ZWRCeVdlYktpdEluTVMgOiAwOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgLy8gV2Ug ZGlkbid0IGhhbmRsZSB0aGUgUmF3S2V5RG93biBldmVudCwgc28gc2VuZCBhbnkgQ2hhciBhbmQg S2V5VXAgZXZlbnRzIHdlIHJlY2VpdmVkIGFmdGVyIHRoZSBSYXdLZXlEb3duLgorICAgIExPRyhL ZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6ZG9uZVdpdGhLZXlFdmVudDogUmF3S2V5RG93biBu b3QgaGFuZGxlZCwgc2VuZGluZyBxdWV1ZWQga2V5IGV2ZW50cyIpOworICAgIHByb2Nlc3NLZXlF dmVudHModHJ1ZSk7CisgICAgbV9hc3N1bWVMYXN0UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5 V2ViS2l0VW50aWwgPSAwOworfQorCit2b2lkIFdlYlBhZ2VQcm94eTo6cHJvY2Vzc0tleUV2ZW50 cyhib29sIGhhbmRsZUNoYXJFdmVudHMpCit7CisgICAgd2hpbGUgKCFtX3VucHJvY2Vzc2VkS2V5 RXZlbnRRdWV1ZS5pc0VtcHR5KCkpIHsKKyAgICAgICAgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCBl dmVudCA9IG1fdW5wcm9jZXNzZWRLZXlFdmVudFF1ZXVlLmZpcnN0KCk7CisKKyAgICAgICAgLy8g V2hlbiB3ZSd2ZSBydW4gb3V0IG9mIENoYXIgYW5kIEtleVVwIGV2ZW50cywgbGVhdmUgdGhlIG5l eHQgUmF3S2V5RG93biBldmVudCAoaWYgYW55KSBpbiB0aGUgcXVldWUsIGJ1dCBzZW5kIGl0IHRv IHRoZSB3ZWIgcHJvY2VzcywKKyAgICAgICAgLy8gc2luY2Ugd2UgZGVmZXJyZWQgZG9pbmcgdGhh dCB3aGlsZSB0aGVyZSBpcyBhbiBleGlzdGluZyBSYXdLZXlEb3duIGluLWZsaWdodC4KKyAgICAg ICAgaWYgKGV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6UmF3S2V5RG93bikgeworICAgICAgICAg ICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5Ojpwcm9jZXNzS2V5RXZlbnRzOiBzZW5k aW5nIFJhd0tleURvd24iKTsKKyAgICAgICAgICAgIAorICAgICAgICAgICAgLy8gV2UgZG9uJ3Qg d2FudCB0byBjYWxsIHNob3VsZEhhbmRsZUtleWJvYXJkRXZlbnQoKSBmb3IgdGhpcyBldmVudC4K KyAgICAgICAgICAgIG1fYWx3YXlzSGFuZGxlS2V5RXZlbnQgPSB0cnVlOworICAgICAgICAgICAg aGFuZGxlS2V5Ym9hcmRFdmVudChldmVudCk7CisgICAgICAgICAgICBtX2Fsd2F5c0hhbmRsZUtl eUV2ZW50ID0gZmFsc2U7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAg CisgICAgICAgIEFTU0VSVCgoZXZlbnQudHlwZSgpID09IFdlYkV2ZW50OjpDaGFyKSB8fCAoZXZl bnQudHlwZSgpID09IFdlYkV2ZW50OjpLZXlVcCkpOworICAgICAgICBtX3VucHJvY2Vzc2VkS2V5 RXZlbnRRdWV1ZS5yZW1vdmVGaXJzdCgpOworICAgICAgICAKKyAgICAgICAgaWYgKGhhbmRsZUNo YXJFdmVudHMgfHwgKGV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6S2V5VXApKSB7CisgICAgICAg ICAgICBMT0coS2V5SGFuZGxpbmcsICJXZWJQYWdlUHJveHk6OnByb2Nlc3NLZXlFdmVudHM6IHNl bmRpbmcgJXMiLCAoZXZlbnQudHlwZSgpID09IFdlYkV2ZW50OjpDaGFyKSA/ICJDaGFyIiA6ICJL ZXlVcCIpOworCisgICAgICAgICAgICAvLyBXZSBkb24ndCB3YW50IHRvIGNhbGwgc2hvdWxkSGFu ZGxlS2V5Ym9hcmRFdmVudCgpIGZvciB0aGVzZSBldmVudHMuCisgICAgICAgICAgICBtX2Fsd2F5 c0hhbmRsZUtleUV2ZW50ID0gdHJ1ZTsKKyAgICAgICAgICAgIGhhbmRsZUtleWJvYXJkRXZlbnQo ZXZlbnQpOworICAgICAgICAgICAgbV9hbHdheXNIYW5kbGVLZXlFdmVudCA9IGZhbHNlOworICAg ICAgICB9CisgICAgfQorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQK 95938 2011-06-03 11:50:51 -0700 2011-07-22 10:05:45 -0700 Remove old key handling test and add a new one, and update MiniBrowser to always call TranslateMessage() again KeyEventTestAndMiniBrowser.patch text/plain 22106 jeffm SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDg4MDMwKQorKysgVG9vbHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMg KzEsNTAgQEAKKzIwMTEtMDYtMDMgIEplZmYgTWlsbGVyICA8amVmZm1AYXBwbGUuY29tPgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFdlYktpdDI6IENs aWVudHMgaGF2ZSB0byBrbm93IG5vdCB0byBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2UoKSBvbiBrZXkg bWVzc2FnZXMgZGVzdGluZWQgZm9yIFdlYktpdDIgd2ViIHZpZXdzCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODM3NAorCisgICAgICAgIFJldmVydCB0 aGUgY2hhbmdlcyBtYWRlIGZvciBidWcgNTYwMjAgaW4gcjgzNjMzLCBpdCB0dXJucyBvdXQgdGhh dCB0aGUgZGVzaWduIG9mIG1ha2luZyBXZWJLaXQgY2xpZW50cworICAgICAgICBvbiBXaW5kb3dz IHdhaXQgdG8gY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgdW50aWwgdGhleSBrbm93IHRoYXQgV2Vi S2l0IGRpZG4ndCBoYW5kbGUgdGhlIGtleSBkb3duCisgICAgICAgIGlzIHVudGVuYWJsZSwgc2lu Y2UgY2xpZW50cyBkb24ndCBhbHdheXMgaGF2ZSBjb250cm9sIG92ZXIgd2hlbiBUcmFuc2xhdGVN ZXNzYWdlKCkgaXMgY2FsbGVkIChlLmcuIHdoZW4KKyAgICAgICAgV2luZG93cyBwdW1wcyBtZXNz YWdlcyBpbiBEaWFsb2dCb3goKSBvciBNZXNzYWdlQm94KCkpLgorICAgICAgICAKKyAgICAgICAg U3BlY2lmaWNhbGx5LCBtYWtlIHRoZSBNaW5pQnJvd3NlciBhbHdheXMgY2FsbCBUcmFuc2xhdGVN ZXNzYWdlKCkgaW1tZWRpYXRlbHkgYWdhaW4sIGFuZCByZW1vdmUgdGhlIG5vdy1vYnNvbGV0ZQor ICAgICAgICB0ZXN0IGZvciB0aGUgcHJldmlvdXMgZGVzaWduLgorICAgICAgICAKKyAgICAgICAg QWRkIGEgbmV3IEtleUV2ZW50SGFuZGxpbmcgdGVzdCBhbmQgdXBkYXRlZCB0aGUgU3BhY2ViYXJT Y3JvbGxpbmcgdGVzdCBmb3IgdGhlIG5ldyBrZXkgaGFuZGxpbmcgZGVzaWduLgorICAgICAgICAK KyAgICAgICAgKiBNaW5pQnJvd3Nlci93aW4vbWFpbi5jcHA6IFJlbW92ZWQgc2hvdWxkVHJhbnNs YXRlTWVzc2FnZSgpLgorICAgICAgICAoX3RXaW5NYWluKTogQWx3YXlzIGNhbGwgVHJhbnNsYXRl TWVzc2FnZSgpIGltbWVkaWF0ZWx5IGFnYWluLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9Q bGF0Zm9ybVV0aWxpdGllcy5oOiBSZW1vdmVkIHNob3VsZFRyYW5zbGF0ZU1lc3NhZ2UoKSBhbmQg YWRkZWQgcnVuVW50aWwoKSBvbiBXaW5kb3dzLgorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxh dGZvcm1XZWJWaWV3Lmg6IFJlbW92ZWQgc2ltdWxhdGVBS2V5RG93bigpIGFuZCBhZGRlZCB2YXJp b3VzIGZ1bmN0aW9ucyBmb3Igc2ltdWxhdGluZyB0YWIga2V5LgorICAgICAgICAKKyAgICAgICAg KiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvU3BhY2ViYXJTY3JvbGxpbmcuY3BwOgorICAg ICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6IFVzZSBydW5VbnRpbCgpIHRvIGdpdmUgV2ViS2l0 IGEgY2hhbmNlIHRvIGZpbmlzaCBrZXkgaGFuZGxpbmcgYmVmb3JlIHRlc3RpbmcgcmVzdWx0cy4K KyAgICAgICAgCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9LZXlF dmVudEhhbmRsaW5nLmNwcDogQWRkZWQuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpkaWRGaW5p c2hMb2FkRm9yRnJhbWUpOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOiBB ZGRlZC4KKyAgICAgICAgCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dp bi9UcmFuc2xhdGVNZXNzYWdlR2VuZXJhdGVzV01DaGFyLmNwcDogUmVtb3ZlZC4KKyAgICAgICAg CisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9rZXktZXZlbnQtaGFu ZGxpbmcuaHRtbDogQWRkZWQuCisgICAgICAgIAorICAgICAgICAqIFRlc3RXZWJLaXRBUEkvd2lu L1BsYXRmb3JtVXRpbGl0aWVzV2luLmNwcDogUmVtb3ZlZCBzaG91bGRUcmFuc2xhdGVNZXNzYWdl KCkuCisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpVdGlsOjpydW4pOiBBbHdheXMgY2FsbCBUcmFu c2xhdGVNZXNzYWdlKCkgaW1tZWRpYXRlbHkgYWdhaW4uCisgICAgICAgIChUZXN0V2ViS2l0QVBJ OjpVdGlsOjpydW5VbnRpbCk6IEFkZGVkLgorICAgICAgICAKKyAgICAgICAgKiBUZXN0V2ViS2l0 QVBJL3dpbi9QbGF0Zm9ybVdlYlZpZXdXaW4uY3BwOiBSZW1vdmVkIHNpbXVsYXRlQUtleURvd24o KS4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVUYWJL ZXlQcmVzcyk6IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6UGxhdGZvcm1XZWJWaWV3 OjpzaW11bGF0ZVRhYktleURvd24pOiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlBs YXRmb3JtV2ViVmlldzo6c2ltdWxhdGVUYWJDaGFyKTogQWRkZWQuCisgICAgICAgIAorICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvd2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qOiBSZW1vdmVkIFRyYW5z bGF0ZU1lc3NhZ2VHZW5lcmF0ZXNXTUNoYXIuY3BwIGFuZCBhZGRlZCBLZXlFdmVudEhhbmRsaW5n LmNwcCBhbmQga2V5LWV2ZW50LWhhbmRsaW5nLmh0bWwuCisgICAgICAgIAorICAgICAgICAqIFRl c3RXZWJLaXRBUEkvd2luL2NvcHktcmVzb3VyY2VzLmNtZDogQ29weSBrZXktZXZlbnQtaGFuZGxp bmcuaHRtbC4KKwogMjAxMS0wNi0wMyAgQ2FyeSBDbGFyayAgPGNhcnljbGFya0Bnb29nbGUuY29t PgogCiAgICAgICAgIFJldmlld2VkIGJ5IEVyaWMgU2VpZGVsLgpJbmRleDogVG9vbHMvTWluaUJy b3dzZXIvd2luL21haW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL01pbmlCcm93c2VyL3dpbi9t YWluLmNwcAkocmV2aXNpb24gODgwMjApCisrKyBUb29scy9NaW5pQnJvd3Nlci93aW4vbWFpbi5j cHAJKHdvcmtpbmcgY29weSkKQEAgLTQxLDIyICs0MSw2IEBACiAKICNwcmFnbWEgY29tbWVudChs aW5rZXIsICIvbWFuaWZlc3RkZXBlbmRlbmN5OlwidHlwZT0nd2luMzInIG5hbWU9J01pY3Jvc29m dC5XaW5kb3dzLkNvbW1vbi1Db250cm9scycgdmVyc2lvbj0nNi4wLjAuMCcgcHJvY2Vzc29yQXJj aGl0ZWN0dXJlPSciIFBST0NFU1NPUkFSQ0hJVEVDVFVSRSAiJyBwdWJsaWNLZXlUb2tlbj0nNjU5 NWI2NDE0NGNjZjFkZicgbGFuZ3VhZ2U9JyonXCIiKQogCi1zdGF0aWMgYm9vbCBzaG91bGRUcmFu c2xhdGVNZXNzYWdlKGNvbnN0IE1TRyYgbXNnKQotewotICAgIC8vIE9ubHkgdGhlc2UgZm91ciBt ZXNzYWdlcyBhcmUgYWN0dWFsbHkgdHJhbnNsYXRlZCBieSA6OlRyYW5zbGF0ZU1lc3NhZ2Ugb3Ig OjpUcmFuc2xhdGVBY2NlbGVyYXRvci4KLSAgICAvLyBJdCdzIHVzZWxlc3MgKHRob3VnaCBoYXJt bGVzcykgdG8gY2FsbCB0aG9zZSBmdW5jdGlvbnMgZm9yIG90aGVyIG1lc3NhZ2VzLCBzbyB3ZSBh bHdheXMgYWxsb3cgb3RoZXIgbWVzc2FnZXMgdG8gYmUgdHJhbnNsYXRlZC4KLSAgICBpZiAobXNn Lm1lc3NhZ2UgIT0gV01fS0VZRE9XTiAmJiBtc2cubWVzc2FnZSAhPSBXTV9TWVNLRVlET1dOICYm IG1zZy5tZXNzYWdlICE9IFdNX0tFWVVQICYmIG1zZy5tZXNzYWdlICE9IFdNX1NZU0tFWVVQKQot ICAgICAgICByZXR1cm4gdHJ1ZTsKLSAgICAKLSAgICB3Y2hhcl90IGNsYXNzTmFtZVsyNTZdOwot ICAgIGlmICghOjpHZXRDbGFzc05hbWVXKG1zZy5od25kLCBjbGFzc05hbWUsIEFSUkFZU0laRShj bGFzc05hbWUpKSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KLSAgICAvLyBEb24ndCBjYWxsIFRy YW5zbGF0ZU1lc3NhZ2UoKSBvbiBrZXkgZXZlbnRzIGRlc3RpbmVkIGZvciBhIFdlYktpdDIgdmll dywgV2ViS2l0IHdpbGwgZG8gdGhpcyBpZiBpdCBkb2Vzbid0IGhhbmRsZSB0aGUgbWVzc2FnZS4K LSAgICAvLyBJdCB3b3VsZCBiZSBuaWNlIHRvIHVzZSBzb21lIEFQSSBoZXJlIGluc3RlYWQgb2Yg aGFyZC1jb2RpbmcgdGhlIHdpbmRvdyBjbGFzcyBuYW1lLgotICAgIHJldHVybiB3Y3NjbXAoY2xh c3NOYW1lLCBMIldlYktpdDJXZWJWaWV3V2luZG93Q2xhc3MiKTsKLX0KLQogaW50IFdJTkFQSSBf dFdpbk1haW4oSElOU1RBTkNFIGhJbnN0YW5jZSwgSElOU1RBTkNFIGhQcmV2SW5zdGFuY2UsIExQ VFNUUiBscHN0ckNtZExpbmUsIGludCBuQ21kU2hvdykKIHsKICAgICBNaW5pQnJvd3Nlcjo6c2hh cmVkKCkuaW5pdGlhbGl6ZShoSW5zdGFuY2UpOwpAQCAtNjgsOSArNTIsNyBAQCBpbnQgV0lOQVBJ IF90V2luTWFpbihISU5TVEFOQ0UgaEluc3RhbmNlCiAgICAgd2hpbGUgKEJPT0wgcmVzdWx0ID0g OjpHZXRNZXNzYWdlKCZtZXNzYWdlLCAwLCAwLCAwKSkgewogICAgICAgICBpZiAocmVzdWx0ID09 IC0xKQogICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIAotICAgICAgICBpZiAoc2hvdWxkVHJh bnNsYXRlTWVzc2FnZShtZXNzYWdlKSkKLSAgICAgICAgICAgIDo6VHJhbnNsYXRlTWVzc2FnZSgm bWVzc2FnZSk7CisgICAgICAgIDo6VHJhbnNsYXRlTWVzc2FnZSgmbWVzc2FnZSk7CiAKICAgICAg ICAgaWYgKCFNaW5pQnJvd3Nlcjo6c2hhcmVkKCkuaGFuZGxlTWVzc2FnZSgmbWVzc2FnZSkpCiAg ICAgICAgICAgICA6OkRpc3BhdGNoTWVzc2FnZSgmbWVzc2FnZSk7CkluZGV4OiBUb29scy9UZXN0 V2ViS2l0QVBJL1BsYXRmb3JtVXRpbGl0aWVzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdl YktpdEFQSS9QbGF0Zm9ybVV0aWxpdGllcy5oCShyZXZpc2lvbiA4ODAyMCkKKysrIFRvb2xzL1Rl c3RXZWJLaXRBUEkvUGxhdGZvcm1VdGlsaXRpZXMuaAkod29ya2luZyBjb3B5KQpAQCAtMzksNyAr MzksNyBAQCBuYW1lc3BhY2UgVXRpbCB7CiB2b2lkIHJ1bihib29sKiBkb25lKTsKIAogI2lmIFBM QVRGT1JNKFdJTikKLWJvb2wgc2hvdWxkVHJhbnNsYXRlTWVzc2FnZShjb25zdCBNU0cmKTsKK3Zv aWQgcnVuVW50aWwoZG91YmxlKTsKICNlbmRpZgogCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRz KTsKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1XZWJWaWV3LmgKPT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PQotLS0gVG9vbHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybVdlYlZpZXcuaAkocmV2aXNpb24gODgw MjApCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtV2ViVmlldy5oCSh3b3JraW5nIGNv cHkpCkBAIC02OSw3ICs2OSw5IEBAIHB1YmxpYzoKICAgICB2b2lkIHNpbXVsYXRlTW91c2VNb3Zl KHVuc2lnbmVkIHgsIHVuc2lnbmVkIHkpOwogCiAjaWYgUExBVEZPUk0oV0lOKQotICAgIHZvaWQg c2ltdWxhdGVBS2V5RG93bigpOworICAgIHZvaWQgc2ltdWxhdGVUYWJLZXlQcmVzcygpOworICAg IHZvaWQgc2ltdWxhdGVUYWJLZXlEb3duKCk7CisgICAgdm9pZCBzaW11bGF0ZVRhYkNoYXIoKTsK ICAgICB2b2lkIHNldFBhcmVudFdpbmRvd01lc3NhZ2VPYnNlcnZlcihXaW5kb3dNZXNzYWdlT2Jz ZXJ2ZXIqIG9ic2VydmVyKSB7IG1fcGFyZW50V2luZG93TWVzc2FnZU9ic2VydmVyID0gb2JzZXJ2 ZXI7IH0KICNlbmRpZgogCkluZGV4OiBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIv U3BhY2ViYXJTY3JvbGxpbmcuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Mi9TcGFjZWJhclNjcm9sbGluZy5jcHAJKHJldmlzaW9uIDg4MDIwKQorKysg VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL1NwYWNlYmFyU2Nyb2xsaW5nLmNwcAko d29ya2luZyBjb3B5KQpAQCAtNzMsNiArNzMsMTEgQEAgVEVTVChXZWJLaXQyLCBTcGFjZWJhclNj cm9sbGluZykKIAogICAgIHdlYlZpZXcuc2ltdWxhdGVTcGFjZWJhcktleVByZXNzKCk7CiAKKyNp ZiBQTEFURk9STShXSU4pCisgICAgLy8gT24gV2luZG93cywgV2ViS2l0J3Mga2V5IGhhbmRsaW5n IGNhbiBpbnRyb2R1Y2UgYWRkaXRpb25hbCBsYXRlbmN5LCBzbyBnaXZlIGl0IHRpbWUgdG8gZmlu aXNoLgorICAgIFV0aWw6OnJ1blVudGlsKDEwMCk7CisjZW5kaWYKKwogICAgIEVYUEVDVF9UUlVF KHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImlzRG9jdW1lbnRTY3JvbGxlZCgpIiwgImZhbHNl IikpOwogICAgIEVYUEVDVF9UUlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgInRleHRGaWVs ZENvbnRhaW5zU3BhY2UoKSIsICJ0cnVlIikpOwogCkBAIC05MCw2ICs5NSwxMSBAQCBURVNUKFdl YktpdDIsIFNwYWNlYmFyU2Nyb2xsaW5nKQogICAgIGRpZE5vdEhhbmRsZUtleURvd25FdmVudCA9 IGZhbHNlOwogICAgIHdlYlZpZXcuc2ltdWxhdGVTcGFjZWJhcktleVByZXNzKCk7CiAKKyNpZiBQ TEFURk9STShXSU4pCisgICAgLy8gT24gV2luZG93cywgV2ViS2l0J3Mga2V5IGhhbmRsaW5nIGNh biBpbnRyb2R1Y2UgYWRkaXRpb25hbCBsYXRlbmN5LCBzbyBnaXZlIGl0IHRpbWUgdG8gZmluaXNo LgorICAgIFV0aWw6OnJ1blVudGlsKDEwMCk7CisjZW5kaWYKKwogICAgIEVYUEVDVF9UUlVFKHJ1 bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImlzRG9jdW1lbnRTY3JvbGxlZCgpIiwgInRydWUiKSk7 CiAgICAgRVhQRUNUX1RSVUUocnVuSlNUZXN0KHdlYlZpZXcucGFnZSgpLCAidGV4dEZpZWxkQ29u dGFpbnNTcGFjZSgpIiwgInRydWUiKSk7CiAKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVz dHMvV2ViS2l0Mi93aW4vS2V5RXZlbnRIYW5kbGluZy5jcHAKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9LZXlFdmVudEhhbmRsaW5nLmNwcAkocmV2 aXNpb24gMCkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi93aW4vS2V5RXZl bnRIYW5kbGluZy5jcHAJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsOTEgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTEgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENP TlRSSUJVVE9SUyBgYEFTIElTJycKKyAqIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgor ICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBP UiBJVFMgQ09OVFJJQlVUT1JTCisgKiBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SCisgKiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRgorICog U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJ VFM7IE9SIEJVU0lORVNTCisgKiBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTgorICogQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkKKyAq IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTIFNPRlRXQVJFLCBFVkVO IElGIEFEVklTRUQgT0YKKyAqIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaW5jbHVkZSAiVGVzdC5oIgorCisjaW5jbHVkZSAiSmF2YVNjcmlwdFRlc3QuaCIKKyNpbmNs dWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgorI2luY2x1ZGUgIlBsYXRmb3JtV2ViVmlldy5oIgor I2luY2x1ZGUgPFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KKworbmFtZXNwYWNlIFRlc3RXZWJLaXRB UEkgeworCitzdGF0aWMgYm9vbCBkaWRGaW5pc2hMb2FkOworCitzdGF0aWMgdm9pZCBkaWRGaW5p c2hMb2FkRm9yRnJhbWUoV0tQYWdlUmVmLCBXS0ZyYW1lUmVmLCBXS1R5cGVSZWYsIGNvbnN0IHZv aWQqKQoreworICAgIGRpZEZpbmlzaExvYWQgPSB0cnVlOworfQorCitURVNUKFdlYktpdDIsIEtl eUV2ZW50SGFuZGxpbmcpCit7CisgICAgV0tSZXRhaW5QdHI8V0tDb250ZXh0UmVmPiBjb250ZXh0 KEFkb3B0V0ssIFdLQ29udGV4dENyZWF0ZSgpKTsKKyAgICBQbGF0Zm9ybVdlYlZpZXcgd2ViVmll dyhjb250ZXh0LmdldCgpKTsKKworICAgIFdLUGFnZUxvYWRlckNsaWVudCBsb2FkZXJDbGllbnQ7 CisgICAgbWVtc2V0KCZsb2FkZXJDbGllbnQsIDAsIHNpemVvZihsb2FkZXJDbGllbnQpKTsKKyAg ICAKKyAgICBsb2FkZXJDbGllbnQudmVyc2lvbiA9IDA7CisgICAgbG9hZGVyQ2xpZW50LmRpZEZp bmlzaExvYWRGb3JGcmFtZSA9IGRpZEZpbmlzaExvYWRGb3JGcmFtZTsKKyAgICBXS1BhZ2VTZXRQ YWdlTG9hZGVyQ2xpZW50KHdlYlZpZXcucGFnZSgpLCAmbG9hZGVyQ2xpZW50KTsKKworICAgIFdL UmV0YWluUHRyPFdLVVJMUmVmPiB1cmwoQWRvcHRXSywgVXRpbDo6Y3JlYXRlVVJMRm9yUmVzb3Vy Y2UoImtleS1ldmVudC1oYW5kbGluZyIsICJodG1sIikpOworICAgIFdLUGFnZUxvYWRVUkwod2Vi Vmlldy5wYWdlKCksIHVybC5nZXQoKSk7CisgICAgVXRpbDo6cnVuKCZkaWRGaW5pc2hMb2FkKTsK KyAgICAKKyAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5wYWdlKCksICJpc0ZpZWxk MUZvY3VzZWQoKSIsICJ0cnVlIikpOworCisgICAgLy8gVGFiIHNob3VsZCBtb3ZlIGZvY3VzIGZy b20gZmllbGQgMSB0byBmaWVsZCAyLCBhbmQgbm90IGVudGVyIGEgdGFiIGNoYXJhY3RlciBpbnRv IHRoZSBmaWVsZC4KKyAgICB3ZWJWaWV3LnNpbXVsYXRlVGFiS2V5UHJlc3MoKTsKKyAgICBFWFBF Q1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5wYWdlKCksICJpc0ZpZWxkMkZvY3VzZWQoKSIsICJ0 cnVlIikpOworICAgIEVYUEVDVF9UUlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImFueUZp ZWxkQ29udGFpbnNUYWIoKSIsICJmYWxzZSIpKTsKKyAgICAKKyAgICAvLyBTZXQgZm9jdXMgYmFj ayB0byBmaWVsZCAxLgorICAgIEVYUEVDVF9UUlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwg InNldEZvY3VzVG9GaWVsZDEoKSIsICJ1bmRlZmluZWQiKSk7CisgICAgRVhQRUNUX1RSVUUocnVu SlNUZXN0KHdlYlZpZXcucGFnZSgpLCAiaXNGaWVsZDFGb2N1c2VkKCkiLCAidHJ1ZSIpKTsKKyAg ICAKKyAgICAvLyBUYWIgc2hvdWxkIHN0aWxsIG1vdmUgZm9jdXMgZnJvbSBmaWVsZCAxIHRvIGZp ZWxkIDIsIGJ1dCB0aGlzCisgICAgLy8gdGltZSBkb24ndCBzZW5kIGEgV01fS0VZVVAgc28gV2Vi S2l0IHRoaW5rcyB0aGF0IHRoZSBsYXN0CisgICAgLy8gaGFuZGxlZCBXTV9LRVlET1dOIGlzIHN0 aWxsIG91dHN0YW5kaW5nLgorICAgIHdlYlZpZXcuc2ltdWxhdGVUYWJLZXlEb3duKCk7CisgICAg RVhQRUNUX1RSVUUocnVuSlNUZXN0KHdlYlZpZXcucGFnZSgpLCAiaXNGaWVsZDJGb2N1c2VkKCki LCAidHJ1ZSIpKTsKKyAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5wYWdlKCksICJh bnlGaWVsZENvbnRhaW5zVGFiKCkiLCAiZmFsc2UiKSk7CisgICAgCisgICAgLy8gU2VuZCBhIFdN X0NIQVIsIHdoaWNoIFdlYktpdCBzaG91bGQgZHJvcCBvbiB0aGUgZmxvb3Igc2luY2UgdGhlCisg ICAgLy8gbGFzdCBoYW5kbGVkIFdNX0tFWURPV04gaXMgc3RpbGwgb3V0c3RhbmRpbmcuCisgICAg d2ViVmlldy5zaW11bGF0ZVRhYkNoYXIoKTsKKyAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2Vi Vmlldy5wYWdlKCksICJpc0ZpZWxkMkZvY3VzZWQoKSIsICJ0cnVlIikpOworICAgIEVYUEVDVF9U UlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImFueUZpZWxkQ29udGFpbnNUYWIoKSIsICJm YWxzZSIpKTsKKworICAgIC8vIFdlYktpdCB3aWxsIGZvcmdldCBhYm91dCB0aGUgbGFzdCBXTV9L RVlET1dOIGFmdGVyIG9uZSBzZWNvbmQsIHNvIHdhaXQgMS4xIHNlY29uZHMuCisgICAgVXRpbDo6 cnVuVW50aWwoMTEwMCk7CisKKyAgICAvLyBTZW5kIGEgV01fQ0hBUiBhZ2Fpbiwgd2hpY2ggV2Vi S2l0IHNob3VsZCBsZXQgdGhyb3VnaCB0aGlzIHRpbWUgYW5kIHRyZWF0IGFzIGEgY2hhcmFjdGVy IGZvciB0aGUgZmllbGQuCisgICAgd2ViVmlldy5zaW11bGF0ZVRhYkNoYXIoKTsKKyAgICBFWFBF Q1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5wYWdlKCksICJpc0ZpZWxkMkZvY3VzZWQoKSIsICJ0 cnVlIikpOworICAgIEVYUEVDVF9UUlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImZpZWxk MkNvbnRhaW5zVGFiKCkiLCAidHJ1ZSIpKTsKK30KKworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktp dEFQSQoKUHJvcGVydHkgY2hhbmdlcyBvbjogVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyL3dpbi9LZXlFdmVudEhhbmRsaW5nLmNwcApfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkFkZGVkOiBzdm46ZW9sLXN0 eWxlCiAgICsgbmF0aXZlCgpJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQy L3dpbi9UcmFuc2xhdGVNZXNzYWdlR2VuZXJhdGVzV01DaGFyLmNwcAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBU b29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvd2luL1RyYW5zbGF0ZU1lc3NhZ2VHZW5l cmF0ZXNXTUNoYXIuY3BwCShyZXZpc2lvbiA4ODAyMCkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Mi93aW4vVHJhbnNsYXRlTWVzc2FnZUdlbmVyYXRlc1dNQ2hhci5jcHAJKHdv cmtpbmcgY29weSkKQEAgLTEsOTEgKzAsMCBAQAotLyoKLSAqIENvcHlyaWdodCAoQykgMjAxMSBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0Ci0gKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgotICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCi0gKgotICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMg SVMnJwotICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCi0gKiBUSEUgSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNI QU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCi0gKiBQVVJQT1NFIEFSRSBE SVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRP UlMKLSAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsIEVYRU1QTEFSWSwgT1IKLSAqIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCi0gKiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MK LSAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElB QklMSVRZLCBXSEVUSEVSIElOCi0gKiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQotICogQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRgot ICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICovCi0KLSNpbmNsdWRlICJUZXN0 LmgiCi0KLSNpbmNsdWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgotI2luY2x1ZGUgIlBsYXRmb3Jt V2ViVmlldy5oIgotI2luY2x1ZGUgIldpbmRvd01lc3NhZ2VPYnNlcnZlci5oIgotI2luY2x1ZGUg PFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KLQotbmFtZXNwYWNlIFRlc3RXZWJLaXRBUEkgewotCi1z dGF0aWMgYm9vbCBkaWRTZWVXTUNoYXI7Ci1zdGF0aWMgYm9vbCBkaWROb3RIYW5kbGVLZXlFdmVu dENhbGxlZDsKLQotc3RhdGljIHZvaWQgZGlkTm90SGFuZGxlS2V5RXZlbnRDYWxsYmFjayhXS1Bh Z2VSZWYsIFdLTmF0aXZlRXZlbnRQdHIgZXZlbnQsIGNvbnN0IHZvaWQqKQotewotICAgIGlmIChl dmVudC0+bWVzc2FnZSAhPSBXTV9LRVlET1dOKQotICAgICAgICByZXR1cm47Ci0gICAgCi0gICAg Ly8gRG9uJ3QgY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgaGVyZSBzbyBhIFdNX0NIQVIgaXNuJ3Qg Z2VuZXJhdGVkLgotICAgIGRpZE5vdEhhbmRsZUtleUV2ZW50Q2FsbGVkID0gdHJ1ZTsKLX0KLQot c3RhdGljIHZvaWQgcnVuQW5kV2F0Y2hGb3JXTUNoYXIoYm9vbCogZG9uZSkKLXsKLSAgICB3aGls ZSAoISpkb25lKSB7Ci0gICAgICAgIE1TRyBtc2c7Ci0gICAgICAgIEJPT0wgcmVzdWx0ID0gOjpH ZXRNZXNzYWdlVygmbXNnLCAwLCAwLCAwKTsKLSAgICAgICAgaWYgKCFyZXN1bHQgfHwgcmVzdWx0 ID09IC0xKQotICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIAotICAgICAgICBpZiAobXNnLm1l c3NhZ2UgPT0gV01fQ0hBUikKLSAgICAgICAgICAgIGRpZFNlZVdNQ2hhciA9IHRydWU7Ci0gICAg ICAgIAotICAgICAgICBpZiAoVXRpbDo6c2hvdWxkVHJhbnNsYXRlTWVzc2FnZShtc2cpKQotICAg ICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKCZtc2cpOwotICAgICAgICAKLSAgICAgICAgOjpE aXNwYXRjaE1lc3NhZ2UoJm1zZyk7Ci0gICAgfQotfQotCi1URVNUKFdlYktpdDIsIFRyYW5zbGF0 ZU1lc3NhZ2VHZW5lcmF0ZXNXTUNoYXIpCi17Ci0gICAgV0tSZXRhaW5QdHI8V0tDb250ZXh0UmVm PiBjb250ZXh0KEFkb3B0V0ssIFdLQ29udGV4dENyZWF0ZSgpKTsKLSAgICBQbGF0Zm9ybVdlYlZp ZXcgd2ViVmlldyhjb250ZXh0LmdldCgpKTsKLQotICAgIHdlYlZpZXcuc2ltdWxhdGVBS2V5RG93 bigpOwotCi0gICAgLy8gV2ViS2l0IHNob3VsZCBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2UoKSBvbiB0 aGUgV01fS0VZRE9XTiBtZXNzYWdlIHRvIGdlbmVyYXRlIHRoZSBXTV9DSEFSIG1lc3NhZ2UuCi0g ICAgcnVuQW5kV2F0Y2hGb3JXTUNoYXIoJmRpZFNlZVdNQ2hhcik7Ci0gICAgCi0gICAgZGlkU2Vl V01DaGFyID0gZmFsc2U7Ci0KLSAgICBXS1BhZ2VVSUNsaWVudCB1aUNsaWVudDsKLSAgICBtZW1z ZXQoJnVpQ2xpZW50LCAwLCBzaXplb2YodWlDbGllbnQpKTsKLQotICAgIHVpQ2xpZW50LmRpZE5v dEhhbmRsZUtleUV2ZW50ID0gZGlkTm90SGFuZGxlS2V5RXZlbnRDYWxsYmFjazsKLSAgICBXS1Bh Z2VTZXRQYWdlVUlDbGllbnQod2ViVmlldy5wYWdlKCksICZ1aUNsaWVudCk7Ci0KLSAgICB3ZWJW aWV3LnNpbXVsYXRlQUtleURvd24oKTsKLQotICAgIHJ1bkFuZFdhdGNoRm9yV01DaGFyKCZkaWRO b3RIYW5kbGVLZXlFdmVudENhbGxlZCk7Ci0KLSAgICAvLyBXZWJLaXQgc2hvdWxkIG5vdCBoYXZl IGNhbGxlZCBUcmFuc2xhdGVNZXNzYWdlKCkgb24gdGhlIFdNX0tFWURPV04gbWVzc2FnZSBzaW5j ZSB3ZSBpbnN0YWxsZWQgYSBkaWROb3RIYW5kbGVLZXlFdmVudCBjYWxsYmFjay4KLSAgICBFWFBF Q1RfRkFMU0UoZGlkU2VlV01DaGFyKTsKLX0KLQotfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQ SQpJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9rZXktZXZlbnQt aGFuZGxpbmcuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDIvd2luL2tleS1ldmVudC1oYW5kbGluZy5odG1sCShyZXZpc2lvbiAwKQorKysgVG9vbHMv VGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9rZXktZXZlbnQtaGFuZGxpbmcuaHRtbAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MSBAQAorPCFET0NUWVBFIGh0bWw+Cis8c2NyaXB0Pgor ICAgIGZ1bmN0aW9uIHNldEZvY3VzVG9GaWVsZDEoKQorICAgIHsKKyAgICAgICAgZG9jdW1lbnQu cXVlcnlTZWxlY3RvcigiI2ZpZWxkMSIpLmZvY3VzKCk7CisgICAgfQorICAgIAorICAgIGZ1bmN0 aW9uIGlzRmllbGQxRm9jdXNlZCgpCisgICAgeworICAgICAgICByZXR1cm4gZG9jdW1lbnQuYWN0 aXZlRWxlbWVudCA9PSBkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIjZmllbGQxIik7CisgICAgfQor CisgICAgZnVuY3Rpb24gaXNGaWVsZDJGb2N1c2VkKCkKKyAgICB7CisgICAgICAgIHJldHVybiBk b2N1bWVudC5hY3RpdmVFbGVtZW50ID09IGRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoIiNmaWVsZDIi KTsKKyAgICB9CisKKyAgICBmdW5jdGlvbiBmaWVsZDFDb250YWluc1RhYigpCisgICAgeworICAg ICAgICByZXR1cm4gZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiI2ZpZWxkMSIpLnZhbHVlLmluZGV4 T2YoIlx0IikgIT0gLTE7CisgICAgfQorICAgIAorICAgIGZ1bmN0aW9uIGZpZWxkMkNvbnRhaW5z VGFiKCkKKyAgICB7CisgICAgICAgIHJldHVybiBkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIjZmll bGQyIikudmFsdWUuaW5kZXhPZigiXHQiKSAhPSAtMTsKKyAgICB9CisgICAgCisgICAgZnVuY3Rp b24gYW55RmllbGRDb250YWluc1RhYigpCisgICAgeworICAgICAgICByZXR1cm4gZmllbGQxQ29u dGFpbnNUYWIoKSB8fCBmaWVsZDJDb250YWluc1RhYigpOworICAgIH0KKyAgICAKKyAgICBmdW5j dGlvbiBsb2FkZWQoKQorICAgIHsKKyAgICAgICAgc2V0Rm9jdXNUb0ZpZWxkMSgpOworICAgIH0K KworICAgIGFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLCBsb2FkZWQpOworPC9zY3JpcHQ+CitGaWVs ZCAxOiA8aW5wdXQgaWQ9ImZpZWxkMSI+PGJyLz4KK0ZpZWxkIDI6IDxpbnB1dCBpZD0iZmllbGQy Ij4KSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1BsYXRmb3JtVXRpbGl0aWVzV2luLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9QbGF0Zm9ybVV0aWxpdGll c1dpbi5jcHAJKHJldmlzaW9uIDg4MDIwKQorKysgVG9vbHMvVGVzdFdlYktpdEFQSS93aW4vUGxh dGZvcm1VdGlsaXRpZXNXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNyw2ICsyNyw3IEBACiAK ICNpbmNsdWRlIDxXZWJLaXQyL1dLU3RyaW5nQ0YuaD4KICNpbmNsdWRlIDxXZWJLaXQyL1dLVVJM Q0YuaD4KKyNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KICNpbmNsdWRlIDx3dGYvUmV0YWlu UHRyLmg+CiAKICNpZiBVU0UoQ0ZORVRXT1JLKQpAQCAtNDksMjcgKzUwLDM3IEBAIHZvaWQgcnVu KGJvb2wqIGRvbmUpCiAgICAgICAgIEJPT0wgcmVzdWx0ID0gOjpHZXRNZXNzYWdlVygmbXNnLCAw LCAwLCAwKTsKICAgICAgICAgaWYgKCFyZXN1bHQgfHwgcmVzdWx0ID09IC0xKQogICAgICAgICAg ICAgYnJlYWs7Ci0gICAgICAgIAotICAgICAgICBpZiAoc2hvdWxkVHJhbnNsYXRlTWVzc2FnZSht c2cpKQotICAgICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKCZtc2cpOworCisgICAgICAgIDo6 VHJhbnNsYXRlTWVzc2FnZSgmbXNnKTsKICAgICAgICAgOjpEaXNwYXRjaE1lc3NhZ2UoJm1zZyk7 CiAgICAgfQogfQogCi1ib29sIHNob3VsZFRyYW5zbGF0ZU1lc3NhZ2UoY29uc3QgTVNHJiBtc2cp Cit2b2lkIHJ1blVudGlsKGRvdWJsZSB0aW1lb3V0SW5NUykKIHsKLSAgICAvLyBPbmx5IHRoZXNl IGZvdXIgbWVzc2FnZXMgYXJlIGFjdHVhbGx5IHRyYW5zbGF0ZWQgYnkgOjpUcmFuc2xhdGVNZXNz YWdlIG9yIDo6VHJhbnNsYXRlQWNjZWxlcmF0b3IuCi0gICAgLy8gSXQncyB1c2VsZXNzICh0aG91 Z2ggaGFybWxlc3MpIHRvIGNhbGwgdGhvc2UgZnVuY3Rpb25zIGZvciBvdGhlciBtZXNzYWdlcywg c28gd2UgYWx3YXlzIGFsbG93IG90aGVyIG1lc3NhZ2VzIHRvIGJlIHRyYW5zbGF0ZWQuCi0gICAg aWYgKG1zZy5tZXNzYWdlICE9IFdNX0tFWURPV04gJiYgbXNnLm1lc3NhZ2UgIT0gV01fU1lTS0VZ RE9XTiAmJiBtc2cubWVzc2FnZSAhPSBXTV9LRVlVUCAmJiBtc2cubWVzc2FnZSAhPSBXTV9TWVNL RVlVUCkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0gICAgCi0gICAgd2NoYXJfdCBjbGFzc05hbWVb MjU2XTsKLSAgICBpZiAoITo6R2V0Q2xhc3NOYW1lVyhtc2cuaHduZCwgY2xhc3NOYW1lLCBBUlJB WVNJWkUoY2xhc3NOYW1lKSkpCi0gICAgICAgIHJldHVybiB0cnVlOwotCi0gICAgLy8gRG9uJ3Qg Y2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgb24ga2V5IGV2ZW50cyBkZXN0aW5lZCBmb3IgYSBXZWJL aXQyIHZpZXcsIFdlYktpdCB3aWxsIGRvIHRoaXMgaWYgaXQgZG9lc24ndCBoYW5kbGUgdGhlIG1l c3NhZ2UuCi0gICAgLy8gSXQgd291bGQgYmUgbmljZSB0byB1c2Ugc29tZSBBUEkgaGVyZSBpbnN0 ZWFkIG9mIGhhcmQtY29kaW5nIHRoZSB3aW5kb3cgY2xhc3MgbmFtZS4KLSAgICByZXR1cm4gd2Nz Y21wKGNsYXNzTmFtZSwgTCJXZWJLaXQyV2ViVmlld1dpbmRvd0NsYXNzIik7CisgICAgZG91Ymxl IGVuZFRpbWUgPSBjdXJyZW50VGltZU1TKCkgKyB0aW1lb3V0SW5NUzsKKworICAgIHdoaWxlICh0 cnVlKSB7CisgICAgICAgIERXT1JEIG5vdyA9IGN1cnJlbnRUaW1lTVMoKTsKKyAgICAgICAgaWYg KG5vdyA+IGVuZFRpbWUpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgICAKKyAgICAg ICAgRFdPUkQgcmVzdWx0ID0gOjpNc2dXYWl0Rm9yTXVsdGlwbGVPYmplY3RzRXgoMCwgMCwgZW5k VGltZS1ub3csIFFTX0FMTElOUFVULCBNV01PX0lOUFVUQVZBSUxBQkxFKTsKKyAgICAgICAgaWYg KHJlc3VsdCA9PSBXQUlUX1RJTUVPVVQpCisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIAor ICAgICAgICBpZiAocmVzdWx0ICE9IFdBSVRfT0JKRUNUXzApIHsKKyAgICAgICAgICAgIEFTU0VS VF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisKKyAgICAg ICAgLy8gVGhlcmUgYXJlIG1lc3NhZ2VzIGluIHRoZSBxdWV1ZS4gUHJvY2VzcyB0aGVtLgorICAg ICAgICBNU0cgbXNnOworICAgICAgICB3aGlsZSAoOjpQZWVrTWVzc2FnZVcoJm1zZywgMCwgMCwg MCwgUE1fUkVNT1ZFKSkgeworICAgICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKCZtc2cpOwor ICAgICAgICAgICAgOjpEaXNwYXRjaE1lc3NhZ2VXKCZtc2cpOworICAgICAgICB9CisgICAgfQog fQogCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKQpJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQ SS93aW4vUGxhdGZvcm1XZWJWaWV3V2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2Vi S2l0QVBJL3dpbi9QbGF0Zm9ybVdlYlZpZXdXaW4uY3BwCShyZXZpc2lvbiA4ODAyMCkKKysrIFRv b2xzL1Rlc3RXZWJLaXRBUEkvd2luL1BsYXRmb3JtV2ViVmlld1dpbi5jcHAJKHdvcmtpbmcgY29w eSkKQEAgLTkyLDEyICs5MiwzMyBAQCB2b2lkIFBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVTcGFj ZWJhcktlCiAgICAgOjpTZW5kTWVzc2FnZVcod2luZG93LCBXTV9LRVlVUCwgVktfU1BBQ0UsICgx IDw8IHJlcGVhdENvdW50Qml0T2Zmc2V0KSB8ICgzOSA8PCBzY2FuQ29kZUJpdE9mZnNldCkgfCAo MSA8PCBwcmV2aW91c1N0YXRlQml0T2Zmc2V0KSB8ICgxIDw8IHRyYW5zaXRpb25TdGF0ZUJpdE9m ZnNldCkpOwogfQogCi12b2lkIFBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVBS2V5RG93bigpCit2 b2lkIFBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVUYWJLZXlQcmVzcygpCiB7CiAgICAgSFdORCB3 aW5kb3cgPSBXS1ZpZXdHZXRXaW5kb3cobV92aWV3KTsKICAgICAKLSAgICAvLyBUaGVzZSB2YWx1 ZXMgbWF0Y2ggd2hhdCBoYXBwZW5zIHdoZW4geW91IHByZXNzIHRoZSAnQScga2V5IGluIE5vdGVw YWQsIGFzIG9ic2VydmVkIGJ5IFNweSsrLgotICAgIDo6U2VuZE1lc3NhZ2VXKHdpbmRvdywgV01f S0VZRE9XTiwgJ0EnLCAoMSA8PCByZXBlYXRDb3VudEJpdE9mZnNldCkgfCAoMzAgPDwgc2NhbkNv ZGVCaXRPZmZzZXQpKTsKKyAgICAvLyBUaGVzZSB2YWx1ZXMgbWF0Y2ggd2hhdCBoYXBwZW5zIHdo ZW4geW91IHByZXNzIHRoZSB0YWIga2V5IGluIE5vdGVwYWQsIGFzIG9ic2VydmVkIGJ5IFNweSsr LgorICAgIDo6U2VuZE1lc3NhZ2VXKHdpbmRvdywgV01fS0VZRE9XTiwgVktfVEFCLCAoMSA8PCBy ZXBlYXRDb3VudEJpdE9mZnNldCkgfCAoMTUgPDwgc2NhbkNvZGVCaXRPZmZzZXQpKTsKKyAgICA6 OlNlbmRNZXNzYWdlVyh3aW5kb3csIFdNX0NIQVIsIDB4MDksICgxIDw8IHJlcGVhdENvdW50Qml0 T2Zmc2V0KSB8ICgxNSA8PCBzY2FuQ29kZUJpdE9mZnNldCkpOworICAgIDo6U2VuZE1lc3NhZ2VX KHdpbmRvdywgV01fS0VZVVAsIFZLX1RBQiwgKDEgPDwgcmVwZWF0Q291bnRCaXRPZmZzZXQpIHwg KDE1IDw8IHNjYW5Db2RlQml0T2Zmc2V0KSB8ICgxIDw8IHByZXZpb3VzU3RhdGVCaXRPZmZzZXQp IHwgKDEgPDwgdHJhbnNpdGlvblN0YXRlQml0T2Zmc2V0KSk7Cit9CisKK3ZvaWQgUGxhdGZvcm1X ZWJWaWV3OjpzaW11bGF0ZVRhYktleURvd24oKQoreworICAgIEhXTkQgd2luZG93ID0gV0tWaWV3 R2V0V2luZG93KG1fdmlldyk7CisgICAgCisgICAgLy8gVGhpcyB2YWx1ZSBtYXRjaGVzIHdoYXQg aGFwcGVucyB3aGVuIHlvdSBwcmVzcyB0aGUgdGFiIGtleSBpbiBOb3RlcGFkLCBhcyBvYnNlcnZl ZCBieSBTcHkrKy4KKyAgICA6OlNlbmRNZXNzYWdlVyh3aW5kb3csIFdNX0tFWURPV04sIFZLX1RB QiwgKDEgPDwgcmVwZWF0Q291bnRCaXRPZmZzZXQpIHwgKDE1IDw8IHNjYW5Db2RlQml0T2Zmc2V0 KSk7CisgICAgOjpTZW5kTWVzc2FnZVcod2luZG93LCBXTV9DSEFSLCAweDA5LCAoMSA8PCByZXBl YXRDb3VudEJpdE9mZnNldCkgfCAoMTUgPDwgc2NhbkNvZGVCaXRPZmZzZXQpKTsKKyAgICAKKyAg ICAvLyBVbmxpa2Ugc2ltdWxhdGVUYWJLZXlQcmVzcygpLCB3ZSBkb24ndCBzZW50IGEgV01fS0VZ VVAgaGVyZS4KK30KKwordm9pZCBQbGF0Zm9ybVdlYlZpZXc6OnNpbXVsYXRlVGFiQ2hhcigpCit7 CisgICAgSFdORCB3aW5kb3cgPSBXS1ZpZXdHZXRXaW5kb3cobV92aWV3KTsKKyAgICAKKyAgICAv LyBUaGlzIHZhbHVlIG1hdGNoZXMgd2hhdCBoYXBwZW5zIHdoZW4geW91IHByZXNzIHRoZSB0YWIg a2V5IGluIE5vdGVwYWQsIGFzIG9ic2VydmVkIGJ5IFNweSsrLgorICAgIDo6U2VuZE1lc3NhZ2VX KHdpbmRvdywgV01fQ0hBUiwgMHgwOSwgKDEgPDwgcmVwZWF0Q291bnRCaXRPZmZzZXQpIHwgKDE1 IDw8IHNjYW5Db2RlQml0T2Zmc2V0KSk7CiB9CiAKIHZvaWQgUGxhdGZvcm1XZWJWaWV3OjpzaW11 bGF0ZUFsdEtleVByZXNzKCkKSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1Rlc3RXZWJL aXRBUEkudmNwcm9qCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1Rlc3RX ZWJLaXRBUEkudmNwcm9qCShyZXZpc2lvbiA4ODAyMCkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkv d2luL1Rlc3RXZWJLaXRBUEkudmNwcm9qCSh3b3JraW5nIGNvcHkpCkBAIC01NzEsMTEgKzU3MSwx NSBAQAogCQkJCQkJPgogCQkJCQk8L0ZpbGU+CiAJCQkJCTxGaWxlCi0JCQkJCQlSZWxhdGl2ZVBh dGg9Ii4uXFRlc3RzXFdlYktpdDJcd2luXFJlc2l6ZVZpZXdXaGlsZUhpZGRlbi5jcHAiCisJCQkJ CQlSZWxhdGl2ZVBhdGg9Ii4uXFRlc3RzXFdlYktpdDJcd2luXGtleS1ldmVudC1oYW5kbGluZy5o dG1sIgogCQkJCQkJPgogCQkJCQk8L0ZpbGU+CiAJCQkJCTxGaWxlCi0JCQkJCQlSZWxhdGl2ZVBh dGg9Ii4uXFRlc3RzXFdlYktpdDJcd2luXFRyYW5zbGF0ZU1lc3NhZ2VHZW5lcmF0ZXNXTUNoYXIu Y3BwIgorCQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxUZXN0c1xXZWJLaXQyXHdpblxLZXlFdmVudEhh bmRsaW5nLmNwcCIKKwkJCQkJCT4KKwkJCQkJPC9GaWxlPgorCQkJCQk8RmlsZQorCQkJCQkJUmVs YXRpdmVQYXRoPSIuLlxUZXN0c1xXZWJLaXQyXHdpblxSZXNpemVWaWV3V2hpbGVIaWRkZW4uY3Bw IgogCQkJCQkJPgogCQkJCQk8L0ZpbGU+CiAJCQkJCTxGaWxlCkluZGV4OiBUb29scy9UZXN0V2Vi S2l0QVBJL3dpbi9jb3B5LXJlc291cmNlcy5jbWQKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdl YktpdEFQSS93aW4vY29weS1yZXNvdXJjZXMuY21kCShyZXZpc2lvbiA4ODAyMCkKKysrIFRvb2xz L1Rlc3RXZWJLaXRBUEkvd2luL2NvcHktcmVzb3VyY2VzLmNtZAkod29ya2luZyBjb3B5KQpAQCAt MTcsNiArMTcsNyBAQCBmb3IgJSVmIGluICgKICAgICAuLlxUZXN0c1xXZWJLaXQyXHNpbXBsZS1h Y2NlbGVyYXRlZC1jb21wb3NpdGluZy5odG1sCiAgICAgLi5cVGVzdHNcV2ViS2l0MlxzaW1wbGUt Zm9ybS5odG1sCiAgICAgLi5cVGVzdHNcV2ViS2l0MlxzcGFjZWJhci1zY3JvbGxpbmcuaHRtbAor ICAgIC4uXFRlc3RzXFdlYktpdDJcd2luXGtleS1ldmVudC1oYW5kbGluZy5odG1sCiApIGRvICgK ICAgICB4Y29weSAveSAvZCAlJWYgIiVSZXNvdXJjZXNEaXJlY3RvcnklIgogKQo= 101790 2011-07-22 16:44:35 -0700 2011-07-22 17:30:51 -0700 Take 2: Queue key events until we know whether the RawKeyDown was processed by WebKit KeyEventQueueing2.patch text/plain 17538 jeffm SW5kZXg6IFNvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi S2l0Mi9DaGFuZ2VMb2cJKHJldmlzaW9uIDkxNjE3KQorKysgU291cmNlL1dlYktpdDIvQ2hhbmdl TG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsNTIgQEAKKzIwMTEtMDctMjIgIEplZmYgTWls bGVyICA8amVmZm1AYXBwbGUuY29tPgorCisgICAgICAgIFdlYktpdDI6IENsaWVudHMgaGF2ZSB0 byBrbm93IG5vdCB0byBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2UoKSBvbiBrZXkgbWVzc2FnZXMgZGVz dGluZWQgZm9yIFdlYktpdDIgd2ViIHZpZXdzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01ODM3NAorICAgICAgICA8cmRhcjovL3Byb2JsZW0vOTI3NDUx MD4gKGFuZCBhbHNvIGZpeGVzIDxyZGFyOi8vcHJvYmxlbS85NDY5MTY1PikKKworICAgICAgICBP dXIgY3VycmVudCBkZXNpZ24gb2YgbWFraW5nIFdlYktpdCBjbGllbnRzIG9uIFdpbmRvd3Mgd2Fp dCB0byBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2UoKSB1bnRpbCB0aGV5IGtub3cgdGhhdAorICAgICAg ICBXZWJLaXQgZGlkbid0IGhhbmRsZSB0aGUga2V5IGRvd24gaXMgdW50ZW5hYmxlLCBzaW5jZSBj bGllbnRzIGRvbid0IGFsd2F5cyBoYXZlIGNvbnRyb2wgb3ZlciB3aGVuIFRyYW5zbGF0ZU1lc3Nh Z2UoKQorICAgICAgICBpcyBjYWxsZWQgKGUuZy4gd2hlbiBXaW5kb3dzIHB1bXBzIG1lc3NhZ2Vz IGluIERpYWxvZ0JveCgpIG9yIE1lc3NhZ2VCb3goKSkuIEluc3RlYWQsIFdlYktpdCBub3cgYXNz dW1lcyB0aGF0IGNsaWVudHMKKyAgICAgICAgYWx3YXlzIGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgp IGltbWVkaWF0ZWx5LgorICAgICAgICAKKyAgICAgICAgVGhpcyBtZWFucyB0aGF0IFdlYlBhZ2VQ cm94eSBpbiB0aGUgVUkgcHJvY2VzcyBuZWVkcyB0byBxdWV1ZSB1cCBrZXkgZXZlbnRzIHRoYXQg Zm9sbG93IGEgUmF3S2V5RG93biBldmVudAorICAgICAgICAodGhlIGVxdWl2YWxlbnQgb2YgYSBX TV9LRVlET1dOIG1lc3NhZ2UpIHVudGlsIHRoZSB3ZWIgcHJvY2VzcyBpbmZvcm1zIGl0IHdoZXRo ZXIgdGhlIFJhd0tleURvd24gZXZlbnQgd2FzIGhhbmRsZWQuCisgICAgICAgIElmIFdlYktpdCBo YW5kbGVkIHRoZSBldmVudCwgV2ViUGFnZVByb3h5IGRyb3BzIGFueSBDaGFyIGV2ZW50cyB0aGF0 IHdlcmUgcmVjZWl2ZWQgYWZ0ZXIgdGhlIFJhd0tleURvd24uCisgICAgICAgIElmIFdlYktpdCBk aWRuJ3QgaGFuZGxlIHRoZSBldmVudCwgV2ViUGFnZVByb3h5IHNlbmRzIGFueSBxdWV1ZWQgQ2hh ciBldmVudHMgZm9yIHRoZSBSYXdLZXlEb3duIHRvIHRoZSB3ZWIgcHJvY2Vzcy4KKyAgICAgICAg SW4gZWl0aGVyIGNhc2UsIGl0IGFsd2F5cyBzZW5kcyBhbnkgS2V5VXAgZXZlbnRzLiBGaW5hbGx5 LCBpZiBhbiBhZGRpdGlvbmFsIFJhd0tleURvd24gZXZlbnQgd2FzIHJlY2VpdmVkIHdoaWxlIHRo ZSBjdXJyZW50CisgICAgICAgIFJhd0tleURvd24gd2FzIGluIHByb2Nlc3MsIGl0IHNlbmRzIHRo YXQgZXZlbnQgYXMgd2VsbC4KKyAgICAgICAgCisgICAgICAgIFVuZm9ydHVuYXRlbHksIHRoZXJl J3Mgbm8gd2F5IHRvIGRldGVybWluZSB0aGF0IGEgV01fQ0hBUiBtZXNzYWdlIHdhcyBnZW5lcmF0 ZWQgZnJvbSBjYWxsaW5nIFRyYW5zbGF0ZU1lc3NhZ2UoKSB3aXRoIGEKKyAgICAgICAgc3BlY2lm aWMgV01fS0VZRE9XTiBtZXNzYWdlLiBXZSBqdXN0IGFzc29jaWF0ZSBhbnkgQ2hhciBldmVudCB0 aGF0J3MgcmVjZWl2ZWQgd2l0aCB0aGUgbGFzdCB1bnByb2Nlc3NlZCBSYXdLZXlEb3duIHdlJ3Zl IHNlZW4uCisgICAgICAgIEdlbmVyYWxseSwgYW55IFJhd0tleURvd24gZXZlbnQgc2hvdWxkIGV2 ZW50dWFsbHkgYmUgZm9sbG93ZWQgYnkgYSBLZXlVcCBldmVudCwgYnV0IHdoaWxlIHdlIGNhbiB1 c2UgdGhpcyBhcyBhIGhpbnQgdGhhdAorICAgICAgICB0aGUgdHJhbnNhY3Rpb24gaXMgY29tcGxl dGUsIHRoZXJlJ3Mgbm8gZ3VhcmFudGVlIHRoYXQgYSBLZXlVcCB3aWxsIGFsd2F5cyBiZSBzZW50 LgorICAgICAgICAKKyAgICAgICAgSW4gdGhlb3J5LCBzb21lb25lIGNvdWxkIGFydGlmaWNpYWxs eSBzZW5kIGEgV01fQ0hBUiBtZXNzYWdlIHRvIHRoZSB3ZWIgdmlldyB3aXRob3V0IGEgV01fS0VZ RE9XTiwgYnV0IEkgZGlkbid0IHRyeSB0byBhY2NvdW50CisgICAgICAgIGZvciB0aGlzIHVubGlr ZWx5IHBvc3NpYmlsaXR5LiBJZiB3ZSBnZXQgYSBLZXlVcCBldmVudCwgd2hpY2ggaXMgd2hhdCB0 eXBpY2FsbHkgaGFwcGVucywgdGhpcyBzaG91bGRuJ3QgYmUgYSBwcm9ibGVtIGFueXdheS4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFVJUHJvY2Vz cy9XZWJQYWdlUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OndlYktl eWJvYXJkRXZlbnRUeXBlU3RyaW5nKTogTWFkZSB0aGlzIGV4aXN0aW5nIHJvdXRpbmUgYSBzdGF0 aWMgbWVtYmVyIGZ1bmN0aW9uLgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OldlYlBh Z2VQcm94eSk6IEluaXRpYWxpemUgbmV3IFdpbmRvd3Mtc3BlY2lmaWMgaXZhcnMuCisgICAgICAg IChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6aGFuZGxlS2V5Ym9hcmRFdmVudCk6IEFkZCBtb3JlIGxv Z2dpbmcgYW5kIGNoZWNrIHdpdGggc2hvdWxkU2VuZEtleUV2ZW50VG9XZWJQcm9jZXNzKCkgYmVm b3JlIHNlbmRpbmcgdGhlIGV2ZW50LgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnNo b3VsZFNlbmRLZXlFdmVudFRvV2ViUHJvY2Vzcyk6IEltcGxlbWVudGF0aW9uIGZvciBub24tV2lu ZG93cyBwbGF0Zm9ybXMuCisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94eTo6c2VuZEtleUV2 ZW50VG9XZWJQcm9jZXNzKTogU3BsaXQgb3V0IGZyb20gaGFuZGxlS2V5Ym9hcmRFdmVudCgpLgor ICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OmRpZFJlY2VpdmVFdmVudCk6IE1vdmUgc29t ZSBjb2RlIHRvIGRvbmVXaXRoS2V5RXZlbnQoKS4KKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVBy b3h5Ojpkb25lV2l0aEtleUV2ZW50KTogQWRkZWQuCisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQ cm94eTo6cGxhdGZvcm1Eb25lV2l0aEtleUV2ZW50KTogSW1wbGVtZW50YXRpb24gZm9yIG5vbi1X aW5kb3dzIHBsYXRmb3Jtcy4KKyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5Ojpwcm9jZXNz RGlkQ3Jhc2gpOiBJbml0aWFsaXplIG5ldyBXaW5kb3dzLXNwZWNpZmljIGl2YXJzIHdoZW4gd2Vi IHByb2Nlc3MgY3Jhc2hlcy4KKyAgICAgICAgCisgICAgICAgICogVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5oOiBSZW5hbWVkIG1fa2V5RXZlbnRRdWV1ZSB0byBtX3NlbnRLZXlFdmVudFF1ZXVlLCBh ZGRlZCBuZXcgbWVtYmVyIGZ1bmN0aW9ucyBhbmQgc29tZSBXaW5kb3dzLXNwZWNpZmljIGl2YXJz LgorICAgICAgICAKKyAgICAgICAgKiBVSVByb2Nlc3MvbWFjL1dlYlBhZ2VQcm94eU1hYy5tbToK KyAgICAgICAgKFdlYktpdDo6V2ViUGFnZVByb3h5OjppbnRlcnByZXRRdWV1ZWRLZXlFdmVudCk6 IFJlbmFtZWQgbV9rZXlFdmVudFF1ZXVlIHRvIG1fc2VudEtleUV2ZW50UXVldWUuCisgICAgICAg IAorICAgICAgICAqIFVJUHJvY2Vzcy93aW4vV2ViUGFnZVByb3h5V2luLmNwcDoKKyAgICAgICAg KFdlYktpdDo6V2ViUGFnZVByb3h5OjpzaG91bGRTZW5kS2V5RXZlbnRUb1dlYlByb2Nlc3MpOiBB ZGRlZCwgcXVldWVzIGtleSBldmVudHMgZm9yIGxhdGVyIHByb2Nlc3NpbmcgYXMgbmVjZXNzYXJ5 LgorICAgICAgICAoV2ViS2l0OjpXZWJQYWdlUHJveHk6OnBsYXRmb3JtRG9uZVdpdGhLZXlFdmVu dCk6IEFkZGVkLCBpZiB0aGUgZXZlbnQgaXMgYSBSYXdLZXlEb3duLCBwcm9jZXNzZXMgYW55IHF1 ZXVlZCBLZXlVcCBhbmQgQ2hhciBldmVudHMuCisgICAgICAgIChXZWJLaXQ6OldlYlBhZ2VQcm94 eTo6c2VuZFF1ZXVlZEtleUV2ZW50c1RvV2ViUHJvY2Vzcyk6IEFkZGVkLCBzZW5kcyBhbGwgcXVl dWVkIEtleVVwIGFuZCAob3B0aW9uYWxseSkgQ2hhciBldmVudHMgZm9yIHRoZSBsYXN0IFJhd0tl eURvd24gZXZlbnQsIGFuZCBzZW5kcyB0aGUgbmV4dCBSYXdLZXlEb3duLgorCiAyMDExLTA3LTIy ICBKZXNzaWUgQmVybGluICA8amJlcmxpbkBhcHBsZS5jb20+CiAKICAgICAgICAgW1dlYktpdDJd IENoYW5naW5nIHRoZSBjb29raWUgYWNjZXB0IHBvbGljeSBpbiBQcml2YXRlIEJyb3dzaW5nIGRv ZXNu4oCZdCB3b3JrLgpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQcm94 eS5jcHAJKHJldmlzaW9uIDkxNTY5KQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBh Z2VQcm94eS5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTExMiw3ICsxMTIsNyBAQCBzdGF0aWMgV1RG OjpSZWZDb3VudGVkTGVha0NvdW50ZXIgd2ViUGFnCiAjZW5kaWYKIAogI2lmICFMT0dfRElTQUJM RUQKLXN0YXRpYyBjb25zdCBjaGFyKiB3ZWJLZXlib2FyZEV2ZW50VHlwZVN0cmluZyhXZWJFdmVu dDo6VHlwZSB0eXBlKQorY29uc3QgY2hhciogV2ViUGFnZVByb3h5Ojp3ZWJLZXlib2FyZEV2ZW50 VHlwZVN0cmluZyhXZWJFdmVudDo6VHlwZSB0eXBlKQogewogICAgIHN3aXRjaCAodHlwZSkgewog ICAgIGNhc2UgV2ViRXZlbnQ6OktleURvd246CkBAIC0xNjksNiArMTY5LDkgQEAgV2ViUGFnZVBy b3h5OjpXZWJQYWdlUHJveHkoUGFnZUNsaWVudCogcAogICAgICwgbV9zeW5jTmF2aWdhdGlvbkFj dGlvblBvbGljeUFjdGlvbklzVmFsaWQoZmFsc2UpCiAgICAgLCBtX3N5bmNOYXZpZ2F0aW9uQWN0 aW9uUG9saWN5QWN0aW9uKFBvbGljeVVzZSkKICAgICAsIG1fc3luY05hdmlnYXRpb25BY3Rpb25Q b2xpY3lEb3dubG9hZElEKDApCisjaWYgUExBVEZPUk0oV0lOKQorICAgICwgbV9hc3N1bWVMYXN0 UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0KGZhbHNlKQorI2VuZGlmCiAgICAgLCBt X3Byb2Nlc3NpbmdNb3VzZU1vdmVFdmVudChmYWxzZSkKICNpZiBFTkFCTEUoVE9VQ0hfRVZFTlRT KQogICAgICwgbV9uZWVkVG91Y2hFdmVudHMoZmFsc2UpCkBAIC05NTksOCArOTYyLDMyIEBAIHZv aWQgV2ViUGFnZVByb3h5OjpoYW5kbGVLZXlib2FyZEV2ZW50KGMKICAgICAgICAgcmV0dXJuOwog ICAgIAogICAgIExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6aGFuZGxlS2V5Ym9hcmRF dmVudDogJXMiLCB3ZWJLZXlib2FyZEV2ZW50VHlwZVN0cmluZyhldmVudC50eXBlKCkpKTsKKyAg ICAKKyAgICBpZiAoc2hvdWxkU2VuZEtleUV2ZW50VG9XZWJQcm9jZXNzKGV2ZW50KSkKKyAgICAg ICAgc2VuZEtleUV2ZW50VG9XZWJQcm9jZXNzKGV2ZW50KTsKK30KKworI2lmICFQTEFURk9STShX SU4pCitib29sIFdlYlBhZ2VQcm94eTo6c2hvdWxkU2VuZEtleUV2ZW50VG9XZWJQcm9jZXNzKGNv bnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmKQoreworICAgIHJldHVybiB0cnVlOworfQorI2Vu ZGlmIC8vICFQTEFURk9STShXSU4pCisKK3ZvaWQgV2ViUGFnZVByb3h5OjpzZW5kS2V5RXZlbnRU b1dlYlByb2Nlc3MoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYgZXZlbnQpCit7CisjaWYg IUxPR19ESVNBQkxFRAorICAgIGlmIChldmVudC50eXBlKCkgPT0gV2ViRXZlbnQ6OkNoYXIpIHsK KyNpZiBQTEFURk9STShXSU4pCisgICAgICAgIExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94 eTo6c2VuZEtleUV2ZW50VG9XZWJQcm9jZXNzOiBzZW5kaW5nIENoYXIgKCVjKSIsIGV2ZW50Lm5h dGl2ZUV2ZW50KCktPndQYXJhbSk7CisjZWxzZQorICAgICAgICBMT0coS2V5SGFuZGxpbmcsICJX ZWJQYWdlUHJveHk6OnNlbmRLZXlFdmVudFRvV2ViUHJvY2Vzczogc2VuZGluZyBDaGFyIik7Cisj ZW5kaWYKKyAgICB9IGVsc2UKKyAgICAgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5 OjpzZW5kS2V5RXZlbnRUb1dlYlByb2Nlc3M6IHNlbmRpbmcgJXMiLCB3ZWJLZXlib2FyZEV2ZW50 VHlwZVN0cmluZyhldmVudC50eXBlKCkpKTsKKyNlbmRpZiAvLyAhTE9HX0RJU0FCTEVECiAKLSAg ICBtX2tleUV2ZW50UXVldWUuYXBwZW5kKGV2ZW50KTsKKyAgICBtX3NlbnRLZXlFdmVudFF1ZXVl LmFwcGVuZChldmVudCk7CiAKICAgICBwcm9jZXNzKCktPnJlc3BvbnNpdmVuZXNzVGltZXIoKS0+ c3RhcnQoKTsKICAgICBwcm9jZXNzKCktPnNlbmQoTWVzc2FnZXM6OldlYlBhZ2U6OktleUV2ZW50 KGV2ZW50KSwgbV9wYWdlSUQpOwpAQCAtMjgwNiwyNiArMjgzMywxNCBAQCB2b2lkIFdlYlBhZ2VQ cm94eTo6ZGlkUmVjZWl2ZUV2ZW50KHVpbnQzCiAgICAgY2FzZSBXZWJFdmVudDo6S2V5VXA6CiAg ICAgY2FzZSBXZWJFdmVudDo6UmF3S2V5RG93bjoKICAgICBjYXNlIFdlYkV2ZW50OjpDaGFyOiB7 Ci0gICAgICAgIExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6ZGlkUmVjZWl2ZUV2ZW50 OiAlcyIsIHdlYktleWJvYXJkRXZlbnRUeXBlU3RyaW5nKHR5cGUpKTsKLQotICAgICAgICBOYXRp dmVXZWJLZXlib2FyZEV2ZW50IGV2ZW50ID0gbV9rZXlFdmVudFF1ZXVlLmZpcnN0KCk7CisgICAg ICAgIE5hdGl2ZVdlYktleWJvYXJkRXZlbnQgZXZlbnQgPSBtX3NlbnRLZXlFdmVudFF1ZXVlLmZp cnN0KCk7CiAgICAgICAgIE1FU1NBR0VfQ0hFQ0sodHlwZSA9PSBldmVudC50eXBlKCkpOwotCi0g ICAgICAgIG1fa2V5RXZlbnRRdWV1ZS5yZW1vdmVGaXJzdCgpOwotCi0gICAgICAgIG1fcGFnZUNs aWVudC0+ZG9uZVdpdGhLZXlFdmVudChldmVudCwgaGFuZGxlZCk7Ci0KLSAgICAgICAgaWYgKGhh bmRsZWQpCi0gICAgICAgICAgICBicmVhazsKLQotICAgICAgICBpZiAobV91aUNsaWVudC5pbXBs ZW1lbnRzRGlkTm90SGFuZGxlS2V5RXZlbnQoKSkKLSAgICAgICAgICAgIG1fdWlDbGllbnQuZGlk Tm90SGFuZGxlS2V5RXZlbnQodGhpcywgZXZlbnQpOwotI2lmIFBMQVRGT1JNKFdJTikKLSAgICAg ICAgZWxzZQotICAgICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKGV2ZW50Lm5hdGl2ZUV2ZW50 KCkpOwotI2VuZGlmCisgICAgICAgIG1fc2VudEtleUV2ZW50UXVldWUucmVtb3ZlRmlyc3QoKTsK KyAgICAgICAgCisgICAgICAgIGRvbmVXaXRoS2V5RXZlbnQoZXZlbnQsIGhhbmRsZWQpOwogICAg ICAgICBicmVhazsKICAgICB9CisgICAgCiAjaWYgRU5BQkxFKFRPVUNIX0VWRU5UUykKICAgICBj YXNlIFdlYkV2ZW50OjpUb3VjaFN0YXJ0OgogICAgIGNhc2UgV2ViRXZlbnQ6OlRvdWNoTW92ZToK QEAgLTI4NDYsNiArMjg2MSwyNiBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6ZGlkUmVjZWl2ZUV2ZW50 KHVpbnQzCiAgICAgfQogfQogCit2b2lkIFdlYlBhZ2VQcm94eTo6ZG9uZVdpdGhLZXlFdmVudChj b25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiBldmVudCwgYm9vbCBoYW5kbGVkKQoreworICAg IExPRyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6ZG9uZVdpdGhLZXlFdmVudDogJXMiLCB3 ZWJLZXlib2FyZEV2ZW50VHlwZVN0cmluZyhldmVudC50eXBlKCkpKTsKKworICAgIG1fcGFnZUNs aWVudC0+ZG9uZVdpdGhLZXlFdmVudChldmVudCwgaGFuZGxlZCk7CisgICAgcGxhdGZvcm1Eb25l V2l0aEtleUV2ZW50KGV2ZW50LCBoYW5kbGVkKTsKKworICAgIGlmIChoYW5kbGVkKQorICAgICAg ICByZXR1cm47CisKKyAgICBpZiAobV91aUNsaWVudC5pbXBsZW1lbnRzRGlkTm90SGFuZGxlS2V5 RXZlbnQoKSkKKyAgICAgICAgbV91aUNsaWVudC5kaWROb3RIYW5kbGVLZXlFdmVudCh0aGlzLCBl dmVudCk7Cit9CisKKyNpZiAhUExBVEZPUk0oV0lOKQordm9pZCBXZWJQYWdlUHJveHk6OnBsYXRm b3JtRG9uZVdpdGhLZXlFdmVudChjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiwgYm9vbCkK K3sKK30KKyNlbmRpZiAvLyAhUExBVEZPUk0oV0lOKQorCiB2b2lkIFdlYlBhZ2VQcm94eTo6c3Rv cFJlc3BvbnNpdmVuZXNzVGltZXIoKQogewogICAgIHByb2Nlc3MoKS0+cmVzcG9uc2l2ZW5lc3NU aW1lcigpLT5zdG9wKCk7CkBAIC0zMDM1LDcgKzMwNzAsMTEgQEAgdm9pZCBXZWJQYWdlUHJveHk6 OnByb2Nlc3NEaWRDcmFzaCgpCiAgICAgbV9sb2FkZXJDbGllbnQucHJvY2Vzc0RpZENyYXNoKHRo aXMpOwogCiAgICAgLy8gQ2FuJ3QgZXhwZWN0IERpZFJlY2VpdmVFdmVudCBub3RpZmljYXRpb25z IGZyb20gYSBjcmFzaGVkIHdlYiBwcm9jZXNzLgotICAgIG1fa2V5RXZlbnRRdWV1ZS5jbGVhcigp OworICAgIG1fc2VudEtleUV2ZW50UXVldWUuY2xlYXIoKTsKKyNpZiBQTEFURk9STShXSU4pCisg ICAgbV91bnNlbnRLZXlFdmVudFF1ZXVlLmNsZWFyKCk7CisgICAgbV9hc3N1bWVMYXN0UmF3S2V5 RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0ID0gZmFsc2U7CisjZW5kaWYKICAgICAKICAgICBt X3doZWVsRXZlbnRRdWV1ZS5jbGVhcigpOwogICAgIG1fY3VycmVudGx5UHJvY2Vzc2VkV2hlZWxF dmVudHMuY2xlYXIoKTsKSW5kZXg6IFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9XZWJQYWdlUHJv eHkuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvV2ViUGFnZVByb3h5 LmgJKHJldmlzaW9uIDkxNTY5KQorKysgU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL1dlYlBhZ2VQ cm94eS5oCSh3b3JraW5nIGNvcHkpCkBAIC02ODksNiArNjg5LDE2IEBAIHByaXZhdGU6CiAgICAg dm9pZCBleGVjdXRlU2F2ZWRDb21tYW5kQnlTZWxlY3Rvcihjb25zdCBTdHJpbmcmIHNlbGVjdG9y LCBib29sJiBoYW5kbGVkKTsKICNlbmRpZgogCisgICAgYm9vbCBzaG91bGRTZW5kS2V5RXZlbnRU b1dlYlByb2Nlc3MoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYpOworICAgIHZvaWQgc2Vu ZEtleUV2ZW50VG9XZWJQcm9jZXNzKGNvbnN0IE5hdGl2ZVdlYktleWJvYXJkRXZlbnQmKTsKKyAg ICB2b2lkIGRvbmVXaXRoS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRFdmVudCYsIGJv b2wpOworICAgIHZvaWQgcGxhdGZvcm1Eb25lV2l0aEtleUV2ZW50KGNvbnN0IE5hdGl2ZVdlYktl eWJvYXJkRXZlbnQmLCBib29sKTsgICAgCisKKyNpZiBQTEFURk9STShXSU4pCisgICAgZW51bSBT aG91bGRTZW5kUXVldWVkQ2hhckV2ZW50cyB7IFNlbmRRdWV1ZWRDaGFyRXZlbnRzLCBEb05vdFNl bmRRdWV1ZWRDaGFyRXZlbnRzIH07CisgICAgdm9pZCBzZW5kUXVldWVkS2V5RXZlbnRzVG9XZWJQ cm9jZXNzKFNob3VsZFNlbmRRdWV1ZWRDaGFyRXZlbnRzKTsKKyNlbmRpZgorCiAjaWYgUExBVEZP Uk0oR1RLKQogICAgIHZvaWQgZ2V0RWRpdG9yQ29tbWFuZHNGb3JLZXlFdmVudChjb25zdCBBdG9t aWNTdHJpbmcmLCBWZWN0b3I8U3RyaW5nPiYpOwogI2VuZGlmCkBAIC02OTYsNiArNzA2LDEwIEBA IHByaXZhdGU6CiAgICAgdm9pZCBnZXRFZGl0b3JDb21tYW5kc0ZvcktleUV2ZW50KFZlY3RvcjxT dHJpbmc+Jik7CiAjZW5kaWYKIAorI2lmICFMT0dfRElTQUJMRUQKKyAgICBzdGF0aWMgY29uc3Qg Y2hhciogd2ViS2V5Ym9hcmRFdmVudFR5cGVTdHJpbmcoV2ViRXZlbnQ6OlR5cGUgdHlwZSk7Cisj ZW5kaWYKKwogICAgIC8vIFBvcHVwIE1lbnUuCiAgICAgdm9pZCBzaG93UG9wdXBNZW51KGNvbnN0 IFdlYkNvcmU6OkludFJlY3QmIHJlY3QsIHVpbnQ2NF90IHRleHREaXJlY3Rpb24sIGNvbnN0IFZl Y3RvcjxXZWJQb3B1cEl0ZW0+JiBpdGVtcywgaW50MzJfdCBzZWxlY3RlZEluZGV4LCBjb25zdCBQ bGF0Zm9ybVBvcHVwTWVudURhdGEmKTsKICAgICB2b2lkIGhpZGVQb3B1cE1lbnUoKTsKQEAgLTg4 Nyw3ICs5MDEsMTIgQEAgcHJpdmF0ZToKICAgICBXZWJDb3JlOjpQb2xpY3lBY3Rpb24gbV9zeW5j TmF2aWdhdGlvbkFjdGlvblBvbGljeUFjdGlvbjsKICAgICB1aW50NjRfdCBtX3N5bmNOYXZpZ2F0 aW9uQWN0aW9uUG9saWN5RG93bmxvYWRJRDsKIAotICAgIERlcXVlPE5hdGl2ZVdlYktleWJvYXJk RXZlbnQ+IG1fa2V5RXZlbnRRdWV1ZTsKKyAgICBEZXF1ZTxOYXRpdmVXZWJLZXlib2FyZEV2ZW50 PiBtX3NlbnRLZXlFdmVudFF1ZXVlOworI2lmIFBMQVRGT1JNKFdJTikKKyAgICBEZXF1ZTxOYXRp dmVXZWJLZXlib2FyZEV2ZW50PiBtX3Vuc2VudEtleUV2ZW50UXVldWU7CisgICAgYm9vbCBtX2Fz c3VtZUxhc3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXQ7CisjZW5kaWYKKwogICAg IERlcXVlPE5hdGl2ZVdlYldoZWVsRXZlbnQ+IG1fd2hlZWxFdmVudFF1ZXVlOwogICAgIFZlY3Rv cjxOYXRpdmVXZWJXaGVlbEV2ZW50PiBtX2N1cnJlbnRseVByb2Nlc3NlZFdoZWVsRXZlbnRzOwog CkluZGV4OiBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dlYlBhZ2VQcm94eU1hYy5tbQo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dlYlBhZ2VQcm94eU1h Yy5tbQkocmV2aXNpb24gOTE1NjkpCisrKyBTb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dl YlBhZ2VQcm94eU1hYy5tbQkod29ya2luZyBjb3B5KQpAQCAtMjc5LDcgKzI3OSw3IEBAIHZvaWQg V2ViUGFnZVByb3h5OjpwZXJmb3JtRGljdGlvbmFyeUxvb2sKIHZvaWQgV2ViUGFnZVByb3h5Ojpp bnRlcnByZXRRdWV1ZWRLZXlFdmVudChjb25zdCBFZGl0b3JTdGF0ZSYgc3RhdGUsIGJvb2wmIGhh bmRsZWQsIFZlY3RvcjxXZWJDb3JlOjpLZXlwcmVzc0NvbW1hbmQ+JiBjb21tYW5kcykKIHsKICAg ICBtX2VkaXRvclN0YXRlID0gc3RhdGU7Ci0gICAgaGFuZGxlZCA9IG1fcGFnZUNsaWVudC0+aW50 ZXJwcmV0S2V5RXZlbnQobV9rZXlFdmVudFF1ZXVlLmZpcnN0KCksIGNvbW1hbmRzKTsKKyAgICBo YW5kbGVkID0gbV9wYWdlQ2xpZW50LT5pbnRlcnByZXRLZXlFdmVudChtX3NlbnRLZXlFdmVudFF1 ZXVlLmZpcnN0KCksIGNvbW1hbmRzKTsKIH0KIAogLy8gQ29tcGxleCB0ZXh0IGlucHV0IHN1cHBv cnQgZm9yIHBsdWctaW5zLgpJbmRleDogU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL3dpbi9XZWJQ YWdlUHJveHlXaW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy93 aW4vV2ViUGFnZVByb3h5V2luLmNwcAkocmV2aXNpb24gOTE1NjkpCisrKyBTb3VyY2UvV2ViS2l0 Mi9VSVByb2Nlc3Mvd2luL1dlYlBhZ2VQcm94eVdpbi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI2 LDEzICsyNiwxNSBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUgIldlYlBhZ2VQcm94 eS5oIgogCisjaW5jbHVkZSAiTG9nZ2luZy5oIgorI2luY2x1ZGUgIk5hdGl2ZVdlYktleWJvYXJk RXZlbnQuaCIKICNpbmNsdWRlICJQYWdlQ2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViUG9wdXBNZW51 UHJveHlXaW4uaCIKIAogI2luY2x1ZGUgInJlc291cmNlLmgiCi0jaW5jbHVkZSA8dGNoYXIuaD4K ICNpbmNsdWRlIDxXZWJDb3JlL1N5c3RlbUluZm8uaD4KICNpbmNsdWRlIDxXZWJDb3JlL1dlYkNv cmVJbnN0YW5jZUhhbmRsZS5oPgorI2luY2x1ZGUgPHRjaGFyLmg+CiAjaW5jbHVkZSA8d3RmL1N0 ZExpYkV4dHJhcy5oPgogI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0NvbmNhdGVuYXRlLmg+CiAK QEAgLTgwLDQgKzgyLDExNiBAQCB2b2lkIFdlYlBhZ2VQcm94eTo6ZGlkSW5zdGFsbE9yVW5pbnN0 YWxsCiAgICAgbV9wYWdlQ2xpZW50LT5kaWRJbnN0YWxsT3JVbmluc3RhbGxQYWdlT3ZlcmxheShk aWRJbnN0YWxsKTsKIH0KIAorYm9vbCBXZWJQYWdlUHJveHk6OnNob3VsZFNlbmRLZXlFdmVudFRv V2ViUHJvY2Vzcyhjb25zdCBOYXRpdmVXZWJLZXlib2FyZEV2ZW50JiBldmVudCkKK3sKKyAgICAv LyBXZSBzaG91bGQgbmV2ZXIgZ2VuZXJhdGUgS2V5RG93biBldmVudHMgb24gV2luZG93cywgd2Ug YWx3YXlzIHVzZSBSYXdLZXlEb3duLgorICAgIEFTU0VSVChldmVudC50eXBlKCkgIT0gV2ViRXZl bnQ6OktleURvd24pOworICAgIAorICAgIC8vIFdlIGtub3cgdGhhdCBhIFJhd0tleURvd24gaXMg aW4tZmxpZ2h0IHRvIHRoZSB3ZWIgcHJvY2VzcyBpZiB0aGVyZSBhcmUgYW55IHVuc2VudAorICAg IC8vIENoYXIgYW5kIEtleVVwIGV2ZW50cywgb3IgaWYgdGhlIGxhc3Qga2V5IGV2ZW50IHdlIHNl bnQgdG8gdGhlIHdlYiBwcm9jZXNzIHdhcyBhIFJhd0tleURvd24uCisgICAgYm9vbCBrZXlEb3du SXNJbkZsaWdodCA9ICFtX3Vuc2VudEtleUV2ZW50UXVldWUuaXNFbXB0eSgpIHx8ICghbV9zZW50 S2V5RXZlbnRRdWV1ZS5pc0VtcHR5KCkgJiYgKG1fc2VudEtleUV2ZW50UXVldWUubGFzdCgpLnR5 cGUoKSA9PSBXZWJFdmVudDo6UmF3S2V5RG93bikpOworCisgICAgaWYgKGV2ZW50LnR5cGUoKSA9 PSBXZWJFdmVudDo6UmF3S2V5RG93bikgeworICAgICAgICBpZiAoIWtleURvd25Jc0luRmxpZ2h0 KQorICAgICAgICAgICAgcmV0dXJuIHRydWU7CisgICAgICAgIAorICAgICAgICAvLyBJZiB3ZSBh bHJlYWR5IGhhdmUgYSBSYXdLZXlEb3duIGluLWZsaWdodCB0byB0aGUgd2ViIHByb2Nlc3MsIGRv bid0IHNlbmQgYW55IG5ldyBLZXlEb3duCisgICAgICAgIC8vIGV2ZW50cyB1bnRpbCB3ZSBrbm93 IHdoZXRoZXIgdGhlIG90aGVyIFJhd0tleURvd24gaXMgaGFuZGxlZCBzbyB3ZSBkZWxpdmVyIGtl eSBldmVudHMKKyAgICAgICAgLy8gaW4gdGhlIHNhbWUgb3JkZXIgdGhleSB3ZXJlIHJlY2VpdmVk LgorICAgICAgICBMT0coS2V5SGFuZGxpbmcsICJXZWJQYWdlUHJveHk6OmhhbmRsZUtleWJvYXJk RXZlbnQ6IHF1ZXVlaW5nIFJhd0tleURvd24iKTsKKyAgICAgICAgbV91bnNlbnRLZXlFdmVudFF1 ZXVlLmFwcGVuZChldmVudCk7CisgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgCisg ICAgaWYgKChldmVudC50eXBlKCkgIT0gV2ViRXZlbnQ6OkNoYXIpICYmIChldmVudC50eXBlKCkg IT0gV2ViRXZlbnQ6OktleVVwKSkgeworICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAg ICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIAorICAgIC8vIFF1ZXVlIHVwIGFueSBDaGFy IG9yIEtleVVwIGV2ZW50cyB3ZSByZWNlaXZlIGJlZm9yZSB3ZSBrbm93IHdoZXRoZXIgdGhlIHdl YiBwcm9jZXNzIGhhcyBoYW5kbGVkIHRoZQorICAgIC8vIGxhc3QgUmF3S2V5RG93biB0aGUgd2Ug c2F3LgorICAgIGlmIChrZXlEb3duSXNJbkZsaWdodCkgeworI2lmICFMT0dfRElTQUJMRUQKKyAg ICAgICAgaWYgKGV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6Q2hhcikKKyAgICAgICAgICAgIExP RyhLZXlIYW5kbGluZywgIldlYlBhZ2VQcm94eTo6c2hvdWxkU2VuZEtleUV2ZW50VG9XZWJQcm9j ZXNzOiBxdWV1ZWluZyBDaGFyICglYykiLCBldmVudC5uYXRpdmVFdmVudCgpLT53UGFyYW0pOwor ICAgICAgICBlbHNlCisgICAgICAgICAgICBMT0coS2V5SGFuZGxpbmcsICJXZWJQYWdlUHJveHk6 OnNob3VsZFNlbmRLZXlFdmVudFRvV2ViUHJvY2VzczogcXVldWVpbmcgS2V5VXAiKTsKKyNlbmRp ZgorICAgICAgICBtX3Vuc2VudEtleUV2ZW50UXVldWUuYXBwZW5kKGV2ZW50KTsKKyAgICAgICAg cmV0dXJuIGZhbHNlOworICAgIH0KKyAgICAKKyAgICAvLyBXZWJLaXQgaGFzIHByb2Nlc3NlZCBh bGwgb3V0c3RhbmRpbmcgUmF3S2V5RG93biBldmVudHMsIHdlIGFsd2F5cyB3YW50IHRvIGhhbmRs ZSBLZXlVcCBldmVudHMgaGVyZS4KKyAgICBpZiAoZXZlbnQudHlwZSgpID09IFdlYkV2ZW50OjpL ZXlVcCkKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgCisgICAgLy8gSWYgd2UgZ2V0IGEgQ2hh ciBldmVudCBhZnRlciBXZWJLaXQgaGFzIHByb2Nlc3NlZCBhbGwgb3V0c3RhbmRpbmcgUmF3S2V5 RG93biBldmVudHMsIHdlIG5lZWQgdG8KKyAgICAvLyBkcm9wIGl0IG9uIHRoZSBmbG9vciBpZiBX ZWJLaXQgaGFuZGxlZCB0aGUgbGFzdCBSYXdLZXlEb3duLiBJbiBwcmFjdGljZSwgdGhpcyByYXJl bHkgaGFwcGVucy4KKyAgICAvLyBVc3VhbGx5LCB3ZSdsbCBnZXQgYW4gaW50ZXJ2ZW5pbmcgS2V5 VXAgd2hpY2ggd2lsbCBpbnZhbGlkYXRlIG1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hh bmRsZWRCeVdlYktpdC4KKyAgICBpZiAoIW1fYXNzdW1lTGFzdFJhd0tleURvd25FdmVudFdhc0hh bmRsZWRCeVdlYktpdCkgeworICAgICAgICAvLyBUaGVyZSdzIG5vIG91dHN0YW5kaW5nIFJhd0tl eURvd24sIGFuZCBXZWJLaXQgZGlkbid0IGhhbmRsZSB0aGUgbGFzdCBSYXdLZXlEb3duLCBzbyBp dCdzIE9LIHRvIHNlbmQgdGhlIGV2ZW50LgorI2lmICFMT0dfRElTQUJMRUQKKyAgICAgICAgLy8g SXQncyBleHRyZW1lbHkgdW51c3VhbCB0byByZWNlaXZlIGEgQ2hhciBldmVudCB3aXRob3V0IGFu IGludGVydmVuaW5nIFJhd0tleURvd24sIHNvIGxvZyB0aGlzLgorICAgICAgICBpZiAobV9hc3N1 bWVMYXN0UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0KQorICAgICAgICAgICAgTE9H KEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5OjpzaG91bGRTZW5kS2V5RXZlbnRUb1dlYlByb2Nl c3M6IHJlY2VpdmVkIENoYXIgZm9yIGxhc3QgaGFuZGxlZCBSYXdLZXlEb3duIik7CisjZW5kaWYK KworICAgICAgICBtX2Fzc3VtZUxhc3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXQg PSBmYWxzZTsKKyAgICAgICAgcmV0dXJuIHRydWU7CisgICAgfQorICAgIAorICAgIExPRyhLZXlI YW5kbGluZywgIldlYlBhZ2VQcm94eTo6c2hvdWxkU2VuZEtleUV2ZW50VG9XZWJQcm9jZXNzOiBp Z25vcmluZyBDaGFyICglYykgZm9yIGxhc3QgaGFuZGxlZCBSYXdLZXlEb3duIiwgZXZlbnQubmF0 aXZlRXZlbnQoKS0+d1BhcmFtKTsKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgV2ViUGFn ZVByb3h5OjpwbGF0Zm9ybURvbmVXaXRoS2V5RXZlbnQoY29uc3QgTmF0aXZlV2ViS2V5Ym9hcmRF dmVudCYgZXZlbnQsIGJvb2wgaGFuZGxlZCkKK3sKKyAgICBpZiAoZXZlbnQudHlwZSgpID09IFdl YkV2ZW50OjpDaGFyKQorICAgICAgICByZXR1cm47CisgICAgCisgICAgaWYgKGV2ZW50LnR5cGUo KSAhPSBXZWJFdmVudDo6UmF3S2V5RG93bikgeworICAgICAgICAvLyBBcyBzb29uIGFzIHdlIGdl dCBhIGtleSBldmVudCB0aGF0IGlzbid0IGEgUmF3S2V5RG93biBvciBDaGFyLCB3ZSBjYW4gcmVz ZXQgbV9hc3N1bWVMYXN0UmF3S2V5RG93bkV2ZW50V2FzSGFuZGxlZEJ5V2ViS2l0LgorICAgICAg ICAvLyBJbiBwcmFjdGljZSwgdGhlIG9ubHkgb3RoZXIga2V5IGV2ZW50IHdlIHNob3VsZCBiZSBn ZW5lcmF0aW5nIG9uIFdpbmRvd3MgaXMgS2V5VXAuCisgICAgICAgIEFTU0VSVChldmVudC50eXBl KCkgPT0gV2ViRXZlbnQ6OktleVVwKTsKKyAgICAgICAgbV9hc3N1bWVMYXN0UmF3S2V5RG93bkV2 ZW50V2FzSGFuZGxlZEJ5V2ViS2l0ID0gZmFsc2U7CisgICAgICAgIHJldHVybjsKKyAgICB9Cisg ICAgCisgICAgaWYgKGhhbmRsZWQpIHsKKyAgICAgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFn ZVByb3h5OjpwbGF0Zm9ybURvbmVXaXRoS2V5RXZlbnQ6IFJhd0tleURvd24gaGFuZGxlZCIpOwor ICAgICAgICAKKyAgICAgICAgLy8gRHJvcCBhbnkgQ2hhciBldmVudHMgZm9yIHRoaXMgUmF3S2V5 RG93biBvbiB0aGUgZmxvb3IgKGJ1dCBzZW5kIGFueSBLZXlVcCBldmVudHMpLgorICAgICAgICBz ZW5kUXVldWVkS2V5RXZlbnRzVG9XZWJQcm9jZXNzKERvTm90U2VuZFF1ZXVlZENoYXJFdmVudHMp OworCisgICAgICAgIC8vIElmIHdlIGdldCBmdXJ0aGVyIENoYXIgZXZlbnRzLCB3ZSB3YW50IHRv IGRyb3AgdGhlbSBvbiB0aGUgZmxvb3IgYXMgd2VsbC4gCisgICAgICAgIG1fYXNzdW1lTGFzdFJh d0tleURvd25FdmVudFdhc0hhbmRsZWRCeVdlYktpdCA9IG1fdW5zZW50S2V5RXZlbnRRdWV1ZS5p c0VtcHR5KCkgPyB0cnVlIDogZmFsc2U7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAv LyBXZSBkaWRuJ3QgaGFuZGxlIHRoZSBSYXdLZXlEb3duIGV2ZW50LCBzbyBzZW5kIGFueSBDaGFy IGFuZCBLZXlVcCBldmVudHMgd2UgcmVjZWl2ZWQgYWZ0ZXIgdGhlIFJhd0tleURvd24uCisgICAg TE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVByb3h5OjpwbGF0Zm9ybURvbmVXaXRoS2V5RXZlbnQ6 IFJhd0tleURvd24gbm90IGhhbmRsZWQsIHNlbmRpbmcgcXVldWVkIGtleSBldmVudHMiKTsKKyAg ICBzZW5kUXVldWVkS2V5RXZlbnRzVG9XZWJQcm9jZXNzKFNlbmRRdWV1ZWRDaGFyRXZlbnRzKTsK KyAgICBtX2Fzc3VtZUxhc3RSYXdLZXlEb3duRXZlbnRXYXNIYW5kbGVkQnlXZWJLaXQgPSBmYWxz ZTsKK30KKwordm9pZCBXZWJQYWdlUHJveHk6OnNlbmRRdWV1ZWRLZXlFdmVudHNUb1dlYlByb2Nl c3MoU2hvdWxkU2VuZFF1ZXVlZENoYXJFdmVudHMgc2hvdWxkU2VuZFF1ZXVlZENoYXJFdmVudHMp Cit7CisgICAgd2hpbGUgKCFtX3Vuc2VudEtleUV2ZW50UXVldWUuaXNFbXB0eSgpKSB7CisgICAg ICAgIE5hdGl2ZVdlYktleWJvYXJkRXZlbnQgZXZlbnQgPSBtX3Vuc2VudEtleUV2ZW50UXVldWUu Zmlyc3QoKTsKKworICAgICAgICBBU1NFUlQoKGV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6UmF3 S2V5RG93bikgfHwgKGV2ZW50LnR5cGUoKSA9PSBXZWJFdmVudDo6Q2hhcikgfHwgKGV2ZW50LnR5 cGUoKSA9PSBXZWJFdmVudDo6S2V5VXApKTsKKyAgICAgICAgbV91bnNlbnRLZXlFdmVudFF1ZXVl LnJlbW92ZUZpcnN0KCk7CisgICAgICAgIAorICAgICAgICBpZiAoKHNob3VsZFNlbmRRdWV1ZWRD aGFyRXZlbnRzID09IFNlbmRRdWV1ZWRDaGFyRXZlbnRzKSB8fCAoZXZlbnQudHlwZSgpICE9IFdl YkV2ZW50OjpDaGFyKSkgeworICAgICAgICAgICAgTE9HKEtleUhhbmRsaW5nLCAiV2ViUGFnZVBy b3h5OjpzZW5kUXVldWVkS2V5RXZlbnRzOiBzZW5kaW5nICVzIiwgd2ViS2V5Ym9hcmRFdmVudFR5 cGVTdHJpbmcoZXZlbnQudHlwZSgpKSk7CisgICAgICAgICAgICBzZW5kS2V5RXZlbnRUb1dlYlBy b2Nlc3MoZXZlbnQpOworICAgICAgICAgICAgCisgICAgICAgICAgICBpZiAoZXZlbnQudHlwZSgp ID09IFdlYkV2ZW50OjpSYXdLZXlEb3duKSB7CisgICAgICAgICAgICAgICAgLy8gRG9uJ3Qgc2Vu ZCBhbnkgbW9yZSBldmVudHMgdW50aWwgd2Uga25vdyB3aGV0aGVyIHRoZSBSYXdLZXlEb3duIGlz IGhhbmRsZWQuCisgICAgICAgICAgICAgICAgcmV0dXJuOworICAgICAgICAgICAgfQorICAgICAg ICB9CisgICAgfQorfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJLaXQK 101792 2011-07-22 16:45:25 -0700 2011-07-22 18:15:18 -0700 Take 2: Remove old key handling test and add a new one, and update MiniBrowser to always call TranslateMessage() again KeyEventTestAndMiniBrowser2.patch text/plain 20442 jeffm SW5kZXg6IFRvb2xzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9DaGFuZ2VMb2cJKHJl dmlzaW9uIDkxNjE3KQorKysgVG9vbHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMg KzEsNDkgQEAKKzIwMTEtMDctMjIgIEplZmYgTWlsbGVyICA8amVmZm1AYXBwbGUuY29tPgorCisg ICAgICAgIFdlYktpdDI6IENsaWVudHMgaGF2ZSB0byBrbm93IG5vdCB0byBjYWxsIFRyYW5zbGF0 ZU1lc3NhZ2UoKSBvbiBrZXkgbWVzc2FnZXMgZGVzdGluZWQgZm9yIFdlYktpdDIgd2ViIHZpZXdz CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01ODM3NAor CisgICAgICAgIFJldmVydCB0aGUgY2hhbmdlcyBtYWRlIGZvciBidWcgNTYwMjAgaW4gcjgzNjMz LCBpdCB0dXJucyBvdXQgdGhhdCB0aGUgZGVzaWduIG9mIG1ha2luZyBXZWJLaXQgY2xpZW50cwor ICAgICAgICBvbiBXaW5kb3dzIHdhaXQgdG8gY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgdW50aWwg dGhleSBrbm93IHRoYXQgV2ViS2l0IGRpZG4ndCBoYW5kbGUgdGhlIGtleSBkb3duCisgICAgICAg IGlzIHVudGVuYWJsZSwgc2luY2UgY2xpZW50cyBkb24ndCBhbHdheXMgaGF2ZSBjb250cm9sIG92 ZXIgd2hlbiBUcmFuc2xhdGVNZXNzYWdlKCkgaXMgY2FsbGVkIChlLmcuIHdoZW4KKyAgICAgICAg V2luZG93cyBwdW1wcyBtZXNzYWdlcyBpbiBEaWFsb2dCb3goKSBvciBNZXNzYWdlQm94KCkpLgor ICAgICAgICAKKyAgICAgICAgU3BlY2lmaWNhbGx5LCBtYWtlIHRoZSBNaW5pQnJvd3NlciBhbHdh eXMgY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgaW1tZWRpYXRlbHkgYWdhaW4sIGFuZCByZW1vdmUg dGhlIG5vdy1vYnNvbGV0ZQorICAgICAgICB0ZXN0IGZvciB0aGUgcHJldmlvdXMgZGVzaWduLgor ICAgICAgICAKKyAgICAgICAgQWRkIGEgbmV3IEtleUV2ZW50SGFuZGxpbmcgdGVzdCBhbmQgdXBk YXRlZCB0aGUgU3BhY2ViYXJTY3JvbGxpbmcgdGVzdCBmb3IgdGhlIG5ldyBrZXkgaGFuZGxpbmcg ZGVzaWduLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg ICogTWluaUJyb3dzZXIvd2luL21haW4uY3BwOiBSZW1vdmVkIHNob3VsZFRyYW5zbGF0ZU1lc3Nh Z2UoKS4KKyAgICAgICAgKF90V2luTWFpbik6IEFsd2F5cyBjYWxsIFRyYW5zbGF0ZU1lc3NhZ2Uo KSBpbW1lZGlhdGVseSBhZ2Fpbi4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvUGxhdGZvcm1V dGlsaXRpZXMuaDogUmVtb3ZlZCBzaG91bGRUcmFuc2xhdGVNZXNzYWdlKCkgYW5kIGFkZGVkIHJ1 blVudGlsKCkgb24gV2luZG93cy4KKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1BsYXRmb3JtV2Vi Vmlldy5oOiBSZW1vdmVkIHNpbXVsYXRlQUtleURvd24oKSBhbmQgYWRkZWQgdmFyaW91cyBmdW5j dGlvbnMgZm9yIHNpbXVsYXRpbmcgdGFiIGtleS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkv VGVzdHMvV2ViS2l0Mi9TcGFjZWJhclNjcm9sbGluZy5jcHA6CisgICAgICAgIChUZXN0V2ViS2l0 QVBJOjpURVNUKTogVXNlIHJ1blVudGlsKCkgdG8gZ2l2ZSBXZWJLaXQgYSBjaGFuY2UgdG8gZmlu aXNoIGtleSBoYW5kbGluZyBiZWZvcmUgdGVzdGluZyByZXN1bHRzLgorICAgICAgICAKKyAgICAg ICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvd2luL0tleUV2ZW50SGFuZGxpbmcuY3Bw OiBBZGRlZC4KKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OmRpZEZpbmlzaExvYWRGb3JGcmFtZSk6 IEFkZGVkLgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6IEFkZGVkLgorCisgICAgICAg ICogVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9UcmFuc2xhdGVNZXNzYWdlR2VuZXJh dGVzV01DaGFyLmNwcDogUmVtb3ZlZC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMv V2ViS2l0Mi93aW4va2V5LWV2ZW50LWhhbmRsaW5nLmh0bWw6IEFkZGVkLgorCisgICAgICAgICog VGVzdFdlYktpdEFQSS93aW4vUGxhdGZvcm1VdGlsaXRpZXNXaW4uY3BwOgorICAgICAgICAoVGVz dFdlYktpdEFQSTo6VXRpbDo6cnVuKTogQWx3YXlzIGNhbGwgVHJhbnNsYXRlTWVzc2FnZSgpIGlt bWVkaWF0ZWx5IGFnYWluLgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuVW50aWwp OiBBZGRlZC4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvd2luL1BsYXRmb3JtV2ViVmlld1dp bi5jcHA6IFJlbW92ZWQgc2ltdWxhdGVBS2V5RG93bigpLgorICAgICAgICAoVGVzdFdlYktpdEFQ STo6UGxhdGZvcm1XZWJWaWV3OjpzaW11bGF0ZVRhYktleVByZXNzKTogQWRkZWQuCisgICAgICAg IChUZXN0V2ViS2l0QVBJOjpQbGF0Zm9ybVdlYlZpZXc6OnNpbXVsYXRlVGFiQ2hhcik6IEFkZGVk LgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS93aW4vVGVzdFdlYktpdEFQSS52Y3Byb2o6IFJl bW92ZWQgVHJhbnNsYXRlTWVzc2FnZUdlbmVyYXRlc1dNQ2hhci5jcHAgYW5kIGFkZGVkIEtleUV2 ZW50SGFuZGxpbmcuY3BwIGFuZCBrZXktZXZlbnQtaGFuZGxpbmcuaHRtbC4KKyAgICAgICAgCisg ICAgICAgICogVGVzdFdlYktpdEFQSS93aW4vY29weS1yZXNvdXJjZXMuY21kOiBDb3B5IGtleS1l dmVudC1oYW5kbGluZy5odG1sLgorCiAyMDExLTA3LTIyICBPamFuIFZhZmFpICA8b2phbkBjaHJv bWl1bS5vcmc+CiAKICAgICAgICAgRml4IGJ1ZyB3aGVuIHN3aXRjaGluZyBmcm9tIGxheW91dC10 ZXN0cyB0byBhbm90aGVyIHRlc3QtdHlwZSBpZgpJbmRleDogVG9vbHMvTWluaUJyb3dzZXIvd2lu L21haW4uY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL01pbmlCcm93c2VyL3dpbi9tYWluLmNwcAko cmV2aXNpb24gOTE1NjkpCisrKyBUb29scy9NaW5pQnJvd3Nlci93aW4vbWFpbi5jcHAJKHdvcmtp bmcgY29weSkKQEAgLTQxLDIyICs0MSw2IEBACiAKICNwcmFnbWEgY29tbWVudChsaW5rZXIsICIv bWFuaWZlc3RkZXBlbmRlbmN5OlwidHlwZT0nd2luMzInIG5hbWU9J01pY3Jvc29mdC5XaW5kb3dz LkNvbW1vbi1Db250cm9scycgdmVyc2lvbj0nNi4wLjAuMCcgcHJvY2Vzc29yQXJjaGl0ZWN0dXJl PSciIFBST0NFU1NPUkFSQ0hJVEVDVFVSRSAiJyBwdWJsaWNLZXlUb2tlbj0nNjU5NWI2NDE0NGNj ZjFkZicgbGFuZ3VhZ2U9JyonXCIiKQogCi1zdGF0aWMgYm9vbCBzaG91bGRUcmFuc2xhdGVNZXNz YWdlKGNvbnN0IE1TRyYgbXNnKQotewotICAgIC8vIE9ubHkgdGhlc2UgZm91ciBtZXNzYWdlcyBh cmUgYWN0dWFsbHkgdHJhbnNsYXRlZCBieSA6OlRyYW5zbGF0ZU1lc3NhZ2Ugb3IgOjpUcmFuc2xh dGVBY2NlbGVyYXRvci4KLSAgICAvLyBJdCdzIHVzZWxlc3MgKHRob3VnaCBoYXJtbGVzcykgdG8g Y2FsbCB0aG9zZSBmdW5jdGlvbnMgZm9yIG90aGVyIG1lc3NhZ2VzLCBzbyB3ZSBhbHdheXMgYWxs b3cgb3RoZXIgbWVzc2FnZXMgdG8gYmUgdHJhbnNsYXRlZC4KLSAgICBpZiAobXNnLm1lc3NhZ2Ug IT0gV01fS0VZRE9XTiAmJiBtc2cubWVzc2FnZSAhPSBXTV9TWVNLRVlET1dOICYmIG1zZy5tZXNz YWdlICE9IFdNX0tFWVVQICYmIG1zZy5tZXNzYWdlICE9IFdNX1NZU0tFWVVQKQotICAgICAgICBy ZXR1cm4gdHJ1ZTsKLSAgICAKLSAgICB3Y2hhcl90IGNsYXNzTmFtZVsyNTZdOwotICAgIGlmICgh OjpHZXRDbGFzc05hbWVXKG1zZy5od25kLCBjbGFzc05hbWUsIEFSUkFZU0laRShjbGFzc05hbWUp KSkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0KLSAgICAvLyBEb24ndCBjYWxsIFRyYW5zbGF0ZU1l c3NhZ2UoKSBvbiBrZXkgZXZlbnRzIGRlc3RpbmVkIGZvciBhIFdlYktpdDIgdmlldywgV2ViS2l0 IHdpbGwgZG8gdGhpcyBpZiBpdCBkb2Vzbid0IGhhbmRsZSB0aGUgbWVzc2FnZS4KLSAgICAvLyBJ dCB3b3VsZCBiZSBuaWNlIHRvIHVzZSBzb21lIEFQSSBoZXJlIGluc3RlYWQgb2YgaGFyZC1jb2Rp bmcgdGhlIHdpbmRvdyBjbGFzcyBuYW1lLgotICAgIHJldHVybiB3Y3NjbXAoY2xhc3NOYW1lLCBM IldlYktpdDJXZWJWaWV3V2luZG93Q2xhc3MiKTsKLX0KLQogaW50IFdJTkFQSSBfdFdpbk1haW4o SElOU1RBTkNFIGhJbnN0YW5jZSwgSElOU1RBTkNFIGhQcmV2SW5zdGFuY2UsIExQVFNUUiBscHN0 ckNtZExpbmUsIGludCBuQ21kU2hvdykKIHsKICAgICBNaW5pQnJvd3Nlcjo6c2hhcmVkKCkuaW5p dGlhbGl6ZShoSW5zdGFuY2UpOwpAQCAtNjgsOSArNTIsNyBAQCBpbnQgV0lOQVBJIF90V2luTWFp bihISU5TVEFOQ0UgaEluc3RhbmNlCiAgICAgd2hpbGUgKEJPT0wgcmVzdWx0ID0gOjpHZXRNZXNz YWdlKCZtZXNzYWdlLCAwLCAwLCAwKSkgewogICAgICAgICBpZiAocmVzdWx0ID09IC0xKQogICAg ICAgICAgICAgYnJlYWs7Ci0gICAgICAgIAotICAgICAgICBpZiAoc2hvdWxkVHJhbnNsYXRlTWVz c2FnZShtZXNzYWdlKSkKLSAgICAgICAgICAgIDo6VHJhbnNsYXRlTWVzc2FnZSgmbWVzc2FnZSk7 CisgICAgICAgIDo6VHJhbnNsYXRlTWVzc2FnZSgmbWVzc2FnZSk7CiAKICAgICAgICAgaWYgKCFN aW5pQnJvd3Nlcjo6c2hhcmVkKCkuaGFuZGxlTWVzc2FnZSgmbWVzc2FnZSkpCiAgICAgICAgICAg ICA6OkRpc3BhdGNoTWVzc2FnZSgmbWVzc2FnZSk7CkluZGV4OiBUb29scy9UZXN0V2ViS2l0QVBJ L1BsYXRmb3JtVXRpbGl0aWVzLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMvVGVzdFdlYktpdEFQSS9Q bGF0Zm9ybVV0aWxpdGllcy5oCShyZXZpc2lvbiA5MTU2OSkKKysrIFRvb2xzL1Rlc3RXZWJLaXRB UEkvUGxhdGZvcm1VdGlsaXRpZXMuaAkod29ya2luZyBjb3B5KQpAQCAtMzksNyArMzksNyBAQCBu YW1lc3BhY2UgVXRpbCB7CiB2b2lkIHJ1bihib29sKiBkb25lKTsKIAogI2lmIFBMQVRGT1JNKFdJ TikKLWJvb2wgc2hvdWxkVHJhbnNsYXRlTWVzc2FnZShjb25zdCBNU0cmKTsKK3ZvaWQgcnVuVW50 aWwoZG91YmxlKTsKICNlbmRpZgogCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKTsKSW5kZXg6 IFRvb2xzL1Rlc3RXZWJLaXRBUEkvUGxhdGZvcm1XZWJWaWV3LmgKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9v bHMvVGVzdFdlYktpdEFQSS9QbGF0Zm9ybVdlYlZpZXcuaAkocmV2aXNpb24gOTE1NjkpCisrKyBU b29scy9UZXN0V2ViS2l0QVBJL1BsYXRmb3JtV2ViVmlldy5oCSh3b3JraW5nIGNvcHkpCkBAIC02 OSw3ICs2OSw4IEBAIHB1YmxpYzoKICAgICB2b2lkIHNpbXVsYXRlTW91c2VNb3ZlKHVuc2lnbmVk IHgsIHVuc2lnbmVkIHkpOwogCiAjaWYgUExBVEZPUk0oV0lOKQotICAgIHZvaWQgc2ltdWxhdGVB S2V5RG93bigpOworICAgIHZvaWQgc2ltdWxhdGVUYWJLZXlQcmVzcygpOworICAgIHZvaWQgc2lt dWxhdGVUYWJDaGFyKCk7CiAgICAgdm9pZCBzZXRQYXJlbnRXaW5kb3dNZXNzYWdlT2JzZXJ2ZXIo V2luZG93TWVzc2FnZU9ic2VydmVyKiBvYnNlcnZlcikgeyBtX3BhcmVudFdpbmRvd01lc3NhZ2VP YnNlcnZlciA9IG9ic2VydmVyOyB9CiAjZW5kaWYKIApJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XZWJLaXQyL1NwYWNlYmFyU2Nyb2xsaW5nLmNwcAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29s cy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvU3BhY2ViYXJTY3JvbGxpbmcuY3BwCShyZXZp c2lvbiA5MTU2OSkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi9TcGFjZWJh clNjcm9sbGluZy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTczLDYgKzczLDExIEBAIFRFU1QoV2Vi S2l0MiwgU3BhY2ViYXJTY3JvbGxpbmcpCiAKICAgICB3ZWJWaWV3LnNpbXVsYXRlU3BhY2ViYXJL ZXlQcmVzcygpOwogCisjaWYgUExBVEZPUk0oV0lOKQorICAgIC8vIE9uIFdpbmRvd3MsIFdlYktp dCdzIGtleSBoYW5kbGluZyBjYW4gaW50cm9kdWNlIGFkZGl0aW9uYWwgbGF0ZW5jeSwgc28gZ2l2 ZSBpdCB0aW1lIHRvIGZpbmlzaC4KKyAgICBVdGlsOjpydW5VbnRpbCgxMDApOworI2VuZGlmCisK ICAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5wYWdlKCksICJpc0RvY3VtZW50U2Ny b2xsZWQoKSIsICJmYWxzZSIpKTsKICAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5w YWdlKCksICJ0ZXh0RmllbGRDb250YWluc1NwYWNlKCkiLCAidHJ1ZSIpKTsKIApAQCAtOTAsNiAr OTUsMTEgQEAgVEVTVChXZWJLaXQyLCBTcGFjZWJhclNjcm9sbGluZykKICAgICBkaWROb3RIYW5k bGVLZXlEb3duRXZlbnQgPSBmYWxzZTsKICAgICB3ZWJWaWV3LnNpbXVsYXRlU3BhY2ViYXJLZXlQ cmVzcygpOwogCisjaWYgUExBVEZPUk0oV0lOKQorICAgIC8vIE9uIFdpbmRvd3MsIFdlYktpdCdz IGtleSBoYW5kbGluZyBjYW4gaW50cm9kdWNlIGFkZGl0aW9uYWwgbGF0ZW5jeSwgc28gZ2l2ZSBp dCB0aW1lIHRvIGZpbmlzaC4KKyAgICBVdGlsOjpydW5VbnRpbCgxMDApOworI2VuZGlmCisKICAg ICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5wYWdlKCksICJpc0RvY3VtZW50U2Nyb2xs ZWQoKSIsICJ0cnVlIikpOwogICAgIEVYUEVDVF9UUlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2Uo KSwgInRleHRGaWVsZENvbnRhaW5zU3BhY2UoKSIsICJ0cnVlIikpOwogCkluZGV4OiBUb29scy9U ZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvd2luL0tleUV2ZW50SGFuZGxpbmcuY3BwCj09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi93aW4vS2V5RXZlbnRI YW5kbGluZy5jcHAJKHJldmlzaW9uIDApCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dl YktpdDIvd2luL0tleUV2ZW50SGFuZGxpbmcuY3BwCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDc1 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDExIEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEu IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9s bG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICog ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExF IElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnCisgKiBBTkQgQU5ZIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAq IFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUworICogQkUgTElBQkxFIEZPUiBBTlkg RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUgorICog Q09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YKKyAqIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNF LCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUworICogSU5URVJSVVBUSU9OKSBIT1dFVkVS IENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4KKyAqIENP TlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpCisgKiBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GCisgKiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VD SCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgIlRlc3QuaCIKKworI2luY2x1ZGUgIkphdmFTY3Jp cHRUZXN0LmgiCisjaW5jbHVkZSAiUGxhdGZvcm1VdGlsaXRpZXMuaCIKKyNpbmNsdWRlICJQbGF0 Zm9ybVdlYlZpZXcuaCIKKyNpbmNsdWRlIDxXZWJLaXQyL1dLUmV0YWluUHRyLmg+CisKK25hbWVz cGFjZSBUZXN0V2ViS2l0QVBJIHsKKworc3RhdGljIGJvb2wgZGlkRmluaXNoTG9hZDsKKworc3Rh dGljIHZvaWQgZGlkRmluaXNoTG9hZEZvckZyYW1lKFdLUGFnZVJlZiwgV0tGcmFtZVJlZiwgV0tU eXBlUmVmLCBjb25zdCB2b2lkKikKK3sKKyAgICBkaWRGaW5pc2hMb2FkID0gdHJ1ZTsKK30KKwor VEVTVChXZWJLaXQyLCBLZXlFdmVudEhhbmRsaW5nKQoreworICAgIFdLUmV0YWluUHRyPFdLQ29u dGV4dFJlZj4gY29udGV4dChBZG9wdFdLLCBXS0NvbnRleHRDcmVhdGUoKSk7CisgICAgUGxhdGZv cm1XZWJWaWV3IHdlYlZpZXcoY29udGV4dC5nZXQoKSk7CisKKyAgICBXS1BhZ2VMb2FkZXJDbGll bnQgbG9hZGVyQ2xpZW50OworICAgIG1lbXNldCgmbG9hZGVyQ2xpZW50LCAwLCBzaXplb2YobG9h ZGVyQ2xpZW50KSk7CisgICAgCisgICAgbG9hZGVyQ2xpZW50LnZlcnNpb24gPSAwOworICAgIGxv YWRlckNsaWVudC5kaWRGaW5pc2hMb2FkRm9yRnJhbWUgPSBkaWRGaW5pc2hMb2FkRm9yRnJhbWU7 CisgICAgV0tQYWdlU2V0UGFnZUxvYWRlckNsaWVudCh3ZWJWaWV3LnBhZ2UoKSwgJmxvYWRlckNs aWVudCk7CisKKyAgICBXS1JldGFpblB0cjxXS1VSTFJlZj4gdXJsKEFkb3B0V0ssIFV0aWw6OmNy ZWF0ZVVSTEZvclJlc291cmNlKCJrZXktZXZlbnQtaGFuZGxpbmciLCAiaHRtbCIpKTsKKyAgICBX S1BhZ2VMb2FkVVJMKHdlYlZpZXcucGFnZSgpLCB1cmwuZ2V0KCkpOworICAgIFV0aWw6OnJ1bigm ZGlkRmluaXNoTG9hZCk7CisgICAgCisgICAgRVhQRUNUX1RSVUUocnVuSlNUZXN0KHdlYlZpZXcu cGFnZSgpLCAiaXNGaWVsZDFGb2N1c2VkKCkiLCAidHJ1ZSIpKTsKKworICAgIC8vIFRhYiBzaG91 bGQgbW92ZSBmb2N1cyBmcm9tIGZpZWxkIDEgdG8gZmllbGQgMiwgYW5kIG5vdCBlbnRlciBhIHRh YiBjaGFyYWN0ZXIgaW50byB0aGUgZmllbGQuCisgICAgd2ViVmlldy5zaW11bGF0ZVRhYktleVBy ZXNzKCk7CisgICAgRVhQRUNUX1RSVUUocnVuSlNUZXN0KHdlYlZpZXcucGFnZSgpLCAiaXNGaWVs ZDJGb2N1c2VkKCkiLCAidHJ1ZSIpKTsKKyAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmll dy5wYWdlKCksICJhbnlGaWVsZENvbnRhaW5zVGFiKCkiLCAiZmFsc2UiKSk7CisgICAgCisgICAg Ly8gU2V0IGZvY3VzIGJhY2sgdG8gZmllbGQgMS4KKyAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qo d2ViVmlldy5wYWdlKCksICJzZXRGb2N1c1RvRmllbGQxKCkiLCAidW5kZWZpbmVkIikpOworICAg IEVYUEVDVF9UUlVFKHJ1bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImlzRmllbGQxRm9jdXNlZCgp IiwgInRydWUiKSk7CisgICAgCisgICAgLy8gU2VuZCBhIHRhYiBXTV9DSEFSLCB3aGljaCBXZWJL aXQgc2hvdWxkIHRyZWF0IGFzIGEgY2hhcmFjdGVyIGZvciB0aGUgZmllbGQuCisgICAgd2ViVmll dy5zaW11bGF0ZVRhYkNoYXIoKTsKKyAgICBFWFBFQ1RfVFJVRShydW5KU1Rlc3Qod2ViVmlldy5w YWdlKCksICJpc0ZpZWxkMUZvY3VzZWQoKSIsICJ0cnVlIikpOworICAgIEVYUEVDVF9UUlVFKHJ1 bkpTVGVzdCh3ZWJWaWV3LnBhZ2UoKSwgImZpZWxkMUNvbnRhaW5zVGFiKCkiLCAidHJ1ZSIpKTsK K30KKworfSAvLyBuYW1lc3BhY2UgVGVzdFdlYktpdEFQSQpJbmRleDogVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9UcmFuc2xhdGVNZXNzYWdlR2VuZXJhdGVzV01DaGFyLmNw cAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvd2luL1Ry YW5zbGF0ZU1lc3NhZ2VHZW5lcmF0ZXNXTUNoYXIuY3BwCShyZXZpc2lvbiA5MTU2OSkKKysrIFRv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Mi93aW4vVHJhbnNsYXRlTWVzc2FnZUdlbmVy YXRlc1dNQ2hhci5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTEsOTEgKzAsMCBAQAotLyoKLSAqIENv cHlyaWdodCAoQykgMjAxMSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCi0gKgotICog UmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBv ciB3aXRob3V0Ci0gKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0 aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKLSAqIGFyZSBtZXQ6Ci0gKiAxLiBSZWRpc3RyaWJ1dGlv bnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAotICogICAg bm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFp bWVyLgotICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKLSAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKLSAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u Ci0gKgotICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMg Q09OVFJJQlVUT1JTIGBgQVMgSVMnJwotICogQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCi0gKiBUSEUgSU1QTElFRCBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS Ci0gKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMu IE9SIElUUyBDT05UUklCVVRPUlMKLSAqIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IKLSAqIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GCi0g KiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MKLSAqIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOCi0gKiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKQot ICogQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMgU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRgotICogVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgotICov Ci0KLSNpbmNsdWRlICJUZXN0LmgiCi0KLSNpbmNsdWRlICJQbGF0Zm9ybVV0aWxpdGllcy5oIgot I2luY2x1ZGUgIlBsYXRmb3JtV2ViVmlldy5oIgotI2luY2x1ZGUgIldpbmRvd01lc3NhZ2VPYnNl cnZlci5oIgotI2luY2x1ZGUgPFdlYktpdDIvV0tSZXRhaW5QdHIuaD4KLQotbmFtZXNwYWNlIFRl c3RXZWJLaXRBUEkgewotCi1zdGF0aWMgYm9vbCBkaWRTZWVXTUNoYXI7Ci1zdGF0aWMgYm9vbCBk aWROb3RIYW5kbGVLZXlFdmVudENhbGxlZDsKLQotc3RhdGljIHZvaWQgZGlkTm90SGFuZGxlS2V5 RXZlbnRDYWxsYmFjayhXS1BhZ2VSZWYsIFdLTmF0aXZlRXZlbnRQdHIgZXZlbnQsIGNvbnN0IHZv aWQqKQotewotICAgIGlmIChldmVudC0+bWVzc2FnZSAhPSBXTV9LRVlET1dOKQotICAgICAgICBy ZXR1cm47Ci0gICAgCi0gICAgLy8gRG9uJ3QgY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgaGVyZSBz byBhIFdNX0NIQVIgaXNuJ3QgZ2VuZXJhdGVkLgotICAgIGRpZE5vdEhhbmRsZUtleUV2ZW50Q2Fs bGVkID0gdHJ1ZTsKLX0KLQotc3RhdGljIHZvaWQgcnVuQW5kV2F0Y2hGb3JXTUNoYXIoYm9vbCog ZG9uZSkKLXsKLSAgICB3aGlsZSAoISpkb25lKSB7Ci0gICAgICAgIE1TRyBtc2c7Ci0gICAgICAg IEJPT0wgcmVzdWx0ID0gOjpHZXRNZXNzYWdlVygmbXNnLCAwLCAwLCAwKTsKLSAgICAgICAgaWYg KCFyZXN1bHQgfHwgcmVzdWx0ID09IC0xKQotICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIAot ICAgICAgICBpZiAobXNnLm1lc3NhZ2UgPT0gV01fQ0hBUikKLSAgICAgICAgICAgIGRpZFNlZVdN Q2hhciA9IHRydWU7Ci0gICAgICAgIAotICAgICAgICBpZiAoVXRpbDo6c2hvdWxkVHJhbnNsYXRl TWVzc2FnZShtc2cpKQotICAgICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKCZtc2cpOwotICAg ICAgICAKLSAgICAgICAgOjpEaXNwYXRjaE1lc3NhZ2UoJm1zZyk7Ci0gICAgfQotfQotCi1URVNU KFdlYktpdDIsIFRyYW5zbGF0ZU1lc3NhZ2VHZW5lcmF0ZXNXTUNoYXIpCi17Ci0gICAgV0tSZXRh aW5QdHI8V0tDb250ZXh0UmVmPiBjb250ZXh0KEFkb3B0V0ssIFdLQ29udGV4dENyZWF0ZSgpKTsK LSAgICBQbGF0Zm9ybVdlYlZpZXcgd2ViVmlldyhjb250ZXh0LmdldCgpKTsKLQotICAgIHdlYlZp ZXcuc2ltdWxhdGVBS2V5RG93bigpOwotCi0gICAgLy8gV2ViS2l0IHNob3VsZCBjYWxsIFRyYW5z bGF0ZU1lc3NhZ2UoKSBvbiB0aGUgV01fS0VZRE9XTiBtZXNzYWdlIHRvIGdlbmVyYXRlIHRoZSBX TV9DSEFSIG1lc3NhZ2UuCi0gICAgcnVuQW5kV2F0Y2hGb3JXTUNoYXIoJmRpZFNlZVdNQ2hhcik7 Ci0gICAgCi0gICAgZGlkU2VlV01DaGFyID0gZmFsc2U7Ci0KLSAgICBXS1BhZ2VVSUNsaWVudCB1 aUNsaWVudDsKLSAgICBtZW1zZXQoJnVpQ2xpZW50LCAwLCBzaXplb2YodWlDbGllbnQpKTsKLQot ICAgIHVpQ2xpZW50LmRpZE5vdEhhbmRsZUtleUV2ZW50ID0gZGlkTm90SGFuZGxlS2V5RXZlbnRD YWxsYmFjazsKLSAgICBXS1BhZ2VTZXRQYWdlVUlDbGllbnQod2ViVmlldy5wYWdlKCksICZ1aUNs aWVudCk7Ci0KLSAgICB3ZWJWaWV3LnNpbXVsYXRlQUtleURvd24oKTsKLQotICAgIHJ1bkFuZFdh dGNoRm9yV01DaGFyKCZkaWROb3RIYW5kbGVLZXlFdmVudENhbGxlZCk7Ci0KLSAgICAvLyBXZWJL aXQgc2hvdWxkIG5vdCBoYXZlIGNhbGxlZCBUcmFuc2xhdGVNZXNzYWdlKCkgb24gdGhlIFdNX0tF WURPV04gbWVzc2FnZSBzaW5jZSB3ZSBpbnN0YWxsZWQgYSBkaWROb3RIYW5kbGVLZXlFdmVudCBj YWxsYmFjay4KLSAgICBFWFBFQ1RfRkFMU0UoZGlkU2VlV01DaGFyKTsKLX0KLQotfSAvLyBuYW1l c3BhY2UgVGVzdFdlYktpdEFQSQpJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJL aXQyL3dpbi9rZXktZXZlbnQtaGFuZGxpbmcuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0 V2ViS2l0QVBJL1Rlc3RzL1dlYktpdDIvd2luL2tleS1ldmVudC1oYW5kbGluZy5odG1sCShyZXZp c2lvbiAwKQorKysgVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXQyL3dpbi9rZXktZXZl bnQtaGFuZGxpbmcuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw0MSBAQAorPCFET0NUWVBF IGh0bWw+Cis8c2NyaXB0PgorICAgIGZ1bmN0aW9uIHNldEZvY3VzVG9GaWVsZDEoKQorICAgIHsK KyAgICAgICAgZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiI2ZpZWxkMSIpLmZvY3VzKCk7CisgICAg fQorICAgIAorICAgIGZ1bmN0aW9uIGlzRmllbGQxRm9jdXNlZCgpCisgICAgeworICAgICAgICBy ZXR1cm4gZG9jdW1lbnQuYWN0aXZlRWxlbWVudCA9PSBkb2N1bWVudC5xdWVyeVNlbGVjdG9yKCIj ZmllbGQxIik7CisgICAgfQorCisgICAgZnVuY3Rpb24gaXNGaWVsZDJGb2N1c2VkKCkKKyAgICB7 CisgICAgICAgIHJldHVybiBkb2N1bWVudC5hY3RpdmVFbGVtZW50ID09IGRvY3VtZW50LnF1ZXJ5 U2VsZWN0b3IoIiNmaWVsZDIiKTsKKyAgICB9CisKKyAgICBmdW5jdGlvbiBmaWVsZDFDb250YWlu c1RhYigpCisgICAgeworICAgICAgICByZXR1cm4gZG9jdW1lbnQucXVlcnlTZWxlY3RvcigiI2Zp ZWxkMSIpLnZhbHVlLmluZGV4T2YoIlx0IikgIT0gLTE7CisgICAgfQorICAgIAorICAgIGZ1bmN0 aW9uIGZpZWxkMkNvbnRhaW5zVGFiKCkKKyAgICB7CisgICAgICAgIHJldHVybiBkb2N1bWVudC5x dWVyeVNlbGVjdG9yKCIjZmllbGQyIikudmFsdWUuaW5kZXhPZigiXHQiKSAhPSAtMTsKKyAgICB9 CisgICAgCisgICAgZnVuY3Rpb24gYW55RmllbGRDb250YWluc1RhYigpCisgICAgeworICAgICAg ICByZXR1cm4gZmllbGQxQ29udGFpbnNUYWIoKSB8fCBmaWVsZDJDb250YWluc1RhYigpOworICAg IH0KKyAgICAKKyAgICBmdW5jdGlvbiBsb2FkZWQoKQorICAgIHsKKyAgICAgICAgc2V0Rm9jdXNU b0ZpZWxkMSgpOworICAgIH0KKworICAgIGFkZEV2ZW50TGlzdGVuZXIoImxvYWQiLCBsb2FkZWQp OworPC9zY3JpcHQ+CitGaWVsZCAxOiA8aW5wdXQgaWQ9ImZpZWxkMSI+PGJyLz4KK0ZpZWxkIDI6 IDxpbnB1dCBpZD0iZmllbGQyIj4KSW5kZXg6IFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1BsYXRm b3JtVXRpbGl0aWVzV2luLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL3dp bi9QbGF0Zm9ybVV0aWxpdGllc1dpbi5jcHAJKHJldmlzaW9uIDkxNTY5KQorKysgVG9vbHMvVGVz dFdlYktpdEFQSS93aW4vUGxhdGZvcm1VdGlsaXRpZXNXaW4uY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0yNyw2ICsyNyw3IEBACiAKICNpbmNsdWRlIDxXZWJLaXQyL1dLU3RyaW5nQ0YuaD4KICNpbmNs dWRlIDxXZWJLaXQyL1dLVVJMQ0YuaD4KKyNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KICNp bmNsdWRlIDx3dGYvUmV0YWluUHRyLmg+CiAKICNpZiBVU0UoQ0ZORVRXT1JLKQpAQCAtNDksMjcg KzUwLDM3IEBAIHZvaWQgcnVuKGJvb2wqIGRvbmUpCiAgICAgICAgIEJPT0wgcmVzdWx0ID0gOjpH ZXRNZXNzYWdlVygmbXNnLCAwLCAwLCAwKTsKICAgICAgICAgaWYgKCFyZXN1bHQgfHwgcmVzdWx0 ID09IC0xKQogICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIAotICAgICAgICBpZiAoc2hvdWxk VHJhbnNsYXRlTWVzc2FnZShtc2cpKQotICAgICAgICAgICAgOjpUcmFuc2xhdGVNZXNzYWdlKCZt c2cpOworCisgICAgICAgIDo6VHJhbnNsYXRlTWVzc2FnZSgmbXNnKTsKICAgICAgICAgOjpEaXNw YXRjaE1lc3NhZ2UoJm1zZyk7CiAgICAgfQogfQogCi1ib29sIHNob3VsZFRyYW5zbGF0ZU1lc3Nh Z2UoY29uc3QgTVNHJiBtc2cpCit2b2lkIHJ1blVudGlsKGRvdWJsZSB0aW1lb3V0SW5NUykKIHsK LSAgICAvLyBPbmx5IHRoZXNlIGZvdXIgbWVzc2FnZXMgYXJlIGFjdHVhbGx5IHRyYW5zbGF0ZWQg YnkgOjpUcmFuc2xhdGVNZXNzYWdlIG9yIDo6VHJhbnNsYXRlQWNjZWxlcmF0b3IuCi0gICAgLy8g SXQncyB1c2VsZXNzICh0aG91Z2ggaGFybWxlc3MpIHRvIGNhbGwgdGhvc2UgZnVuY3Rpb25zIGZv ciBvdGhlciBtZXNzYWdlcywgc28gd2UgYWx3YXlzIGFsbG93IG90aGVyIG1lc3NhZ2VzIHRvIGJl IHRyYW5zbGF0ZWQuCi0gICAgaWYgKG1zZy5tZXNzYWdlICE9IFdNX0tFWURPV04gJiYgbXNnLm1l c3NhZ2UgIT0gV01fU1lTS0VZRE9XTiAmJiBtc2cubWVzc2FnZSAhPSBXTV9LRVlVUCAmJiBtc2cu bWVzc2FnZSAhPSBXTV9TWVNLRVlVUCkKLSAgICAgICAgcmV0dXJuIHRydWU7Ci0gICAgCi0gICAg d2NoYXJfdCBjbGFzc05hbWVbMjU2XTsKLSAgICBpZiAoITo6R2V0Q2xhc3NOYW1lVyhtc2cuaHdu ZCwgY2xhc3NOYW1lLCBBUlJBWVNJWkUoY2xhc3NOYW1lKSkpCi0gICAgICAgIHJldHVybiB0cnVl OwotCi0gICAgLy8gRG9uJ3QgY2FsbCBUcmFuc2xhdGVNZXNzYWdlKCkgb24ga2V5IGV2ZW50cyBk ZXN0aW5lZCBmb3IgYSBXZWJLaXQyIHZpZXcsIFdlYktpdCB3aWxsIGRvIHRoaXMgaWYgaXQgZG9l c24ndCBoYW5kbGUgdGhlIG1lc3NhZ2UuCi0gICAgLy8gSXQgd291bGQgYmUgbmljZSB0byB1c2Ug c29tZSBBUEkgaGVyZSBpbnN0ZWFkIG9mIGhhcmQtY29kaW5nIHRoZSB3aW5kb3cgY2xhc3MgbmFt ZS4KLSAgICByZXR1cm4gd2NzY21wKGNsYXNzTmFtZSwgTCJXZWJLaXQyV2ViVmlld1dpbmRvd0Ns YXNzIik7CisgICAgZG91YmxlIGVuZFRpbWUgPSBjdXJyZW50VGltZU1TKCkgKyB0aW1lb3V0SW5N UzsKKworICAgIHdoaWxlICh0cnVlKSB7CisgICAgICAgIERXT1JEIG5vdyA9IGN1cnJlbnRUaW1l TVMoKTsKKyAgICAgICAgaWYgKG5vdyA+IGVuZFRpbWUpCisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgICAgICAKKyAgICAgICAgRFdPUkQgcmVzdWx0ID0gOjpNc2dXYWl0Rm9yTXVsdGlwbGVP YmplY3RzRXgoMCwgMCwgZW5kVGltZS1ub3csIFFTX0FMTElOUFVULCBNV01PX0lOUFVUQVZBSUxB QkxFKTsKKyAgICAgICAgaWYgKHJlc3VsdCA9PSBXQUlUX1RJTUVPVVQpCisgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgIAorICAgICAgICBpZiAocmVzdWx0ICE9IFdBSVRfT0JKRUNUXzApIHsK KyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgcmV0dXJuOwor ICAgICAgICB9CisKKyAgICAgICAgLy8gVGhlcmUgYXJlIG1lc3NhZ2VzIGluIHRoZSBxdWV1ZS4g UHJvY2VzcyB0aGVtLgorICAgICAgICBNU0cgbXNnOworICAgICAgICB3aGlsZSAoOjpQZWVrTWVz c2FnZVcoJm1zZywgMCwgMCwgMCwgUE1fUkVNT1ZFKSkgeworICAgICAgICAgICAgOjpUcmFuc2xh dGVNZXNzYWdlKCZtc2cpOworICAgICAgICAgICAgOjpEaXNwYXRjaE1lc3NhZ2VXKCZtc2cpOwor ICAgICAgICB9CisgICAgfQogfQogCiB2b2lkIHNsZWVwKGRvdWJsZSBzZWNvbmRzKQpJbmRleDog VG9vbHMvVGVzdFdlYktpdEFQSS93aW4vUGxhdGZvcm1XZWJWaWV3V2luLmNwcAo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9QbGF0Zm9ybVdlYlZpZXdXaW4uY3BwCShyZXZp c2lvbiA5MTU2OSkKKysrIFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2luL1BsYXRmb3JtV2ViVmlld1dp bi5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTkyLDEyICs5MiwyMiBAQCB2b2lkIFBsYXRmb3JtV2Vi Vmlldzo6c2ltdWxhdGVTcGFjZWJhcktlCiAgICAgOjpTZW5kTWVzc2FnZVcod2luZG93LCBXTV9L RVlVUCwgVktfU1BBQ0UsICgxIDw8IHJlcGVhdENvdW50Qml0T2Zmc2V0KSB8ICgzOSA8PCBzY2Fu Q29kZUJpdE9mZnNldCkgfCAoMSA8PCBwcmV2aW91c1N0YXRlQml0T2Zmc2V0KSB8ICgxIDw8IHRy YW5zaXRpb25TdGF0ZUJpdE9mZnNldCkpOwogfQogCi12b2lkIFBsYXRmb3JtV2ViVmlldzo6c2lt dWxhdGVBS2V5RG93bigpCit2b2lkIFBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVUYWJLZXlQcmVz cygpCiB7CiAgICAgSFdORCB3aW5kb3cgPSBXS1ZpZXdHZXRXaW5kb3cobV92aWV3KTsKICAgICAK LSAgICAvLyBUaGVzZSB2YWx1ZXMgbWF0Y2ggd2hhdCBoYXBwZW5zIHdoZW4geW91IHByZXNzIHRo ZSAnQScga2V5IGluIE5vdGVwYWQsIGFzIG9ic2VydmVkIGJ5IFNweSsrLgotICAgIDo6U2VuZE1l c3NhZ2VXKHdpbmRvdywgV01fS0VZRE9XTiwgJ0EnLCAoMSA8PCByZXBlYXRDb3VudEJpdE9mZnNl dCkgfCAoMzAgPDwgc2NhbkNvZGVCaXRPZmZzZXQpKTsKKyAgICAvLyBUaGVzZSB2YWx1ZXMgbWF0 Y2ggd2hhdCBoYXBwZW5zIHdoZW4geW91IHByZXNzIHRoZSB0YWIga2V5IGluIE5vdGVwYWQsIGFz IG9ic2VydmVkIGJ5IFNweSsrLgorICAgIDo6U2VuZE1lc3NhZ2VXKHdpbmRvdywgV01fS0VZRE9X TiwgVktfVEFCLCAoMSA8PCByZXBlYXRDb3VudEJpdE9mZnNldCkgfCAoMTUgPDwgc2NhbkNvZGVC aXRPZmZzZXQpKTsKKyAgICA6OlNlbmRNZXNzYWdlVyh3aW5kb3csIFdNX0NIQVIsIDB4MDksICgx IDw8IHJlcGVhdENvdW50Qml0T2Zmc2V0KSB8ICgxNSA8PCBzY2FuQ29kZUJpdE9mZnNldCkpOwor ICAgIDo6U2VuZE1lc3NhZ2VXKHdpbmRvdywgV01fS0VZVVAsIFZLX1RBQiwgKDEgPDwgcmVwZWF0 Q291bnRCaXRPZmZzZXQpIHwgKDE1IDw8IHNjYW5Db2RlQml0T2Zmc2V0KSB8ICgxIDw8IHByZXZp b3VzU3RhdGVCaXRPZmZzZXQpIHwgKDEgPDwgdHJhbnNpdGlvblN0YXRlQml0T2Zmc2V0KSk7Cit9 CisKK3ZvaWQgUGxhdGZvcm1XZWJWaWV3OjpzaW11bGF0ZVRhYkNoYXIoKQoreworICAgIEhXTkQg d2luZG93ID0gV0tWaWV3R2V0V2luZG93KG1fdmlldyk7CisgICAgCisgICAgLy8gVGhpcyB2YWx1 ZSBtYXRjaGVzIHdoYXQgaGFwcGVucyB3aGVuIHlvdSBwcmVzcyB0aGUgdGFiIGtleSBpbiBOb3Rl cGFkLCBhcyBvYnNlcnZlZCBieSBTcHkrKy4KKyAgICA6OlNlbmRNZXNzYWdlVyh3aW5kb3csIFdN X0NIQVIsIDB4MDksICgxIDw8IHJlcGVhdENvdW50Qml0T2Zmc2V0KSB8ICgxNSA8PCBzY2FuQ29k ZUJpdE9mZnNldCkpOwogfQogCiB2b2lkIFBsYXRmb3JtV2ViVmlldzo6c2ltdWxhdGVBbHRLZXlQ cmVzcygpCkluZGV4OiBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9UZXN0V2ViS2l0QVBJLnZjcHJv ago9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09Ci0tLSBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9UZXN0V2ViS2l0QVBJLnZj cHJvagkocmV2aXNpb24gOTE1NjkpCisrKyBUb29scy9UZXN0V2ViS2l0QVBJL3dpbi9UZXN0V2Vi S2l0QVBJLnZjcHJvagkod29ya2luZyBjb3B5KQpAQCAtNTcxLDExICs1NzEsMTUgQEAKIAkJCQkJ CT4KIAkJCQkJPC9GaWxlPgogCQkJCQk8RmlsZQotCQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxUZXN0 c1xXZWJLaXQyXHdpblxSZXNpemVWaWV3V2hpbGVIaWRkZW4uY3BwIgorCQkJCQkJUmVsYXRpdmVQ YXRoPSIuLlxUZXN0c1xXZWJLaXQyXHdpblxrZXktZXZlbnQtaGFuZGxpbmcuaHRtbCIKIAkJCQkJ CT4KIAkJCQkJPC9GaWxlPgogCQkJCQk8RmlsZQotCQkJCQkJUmVsYXRpdmVQYXRoPSIuLlxUZXN0 c1xXZWJLaXQyXHdpblxUcmFuc2xhdGVNZXNzYWdlR2VuZXJhdGVzV01DaGFyLmNwcCIKKwkJCQkJ CVJlbGF0aXZlUGF0aD0iLi5cVGVzdHNcV2ViS2l0Mlx3aW5cS2V5RXZlbnRIYW5kbGluZy5jcHAi CisJCQkJCQk+CisJCQkJCTwvRmlsZT4KKwkJCQkJPEZpbGUKKwkJCQkJCVJlbGF0aXZlUGF0aD0i Li5cVGVzdHNcV2ViS2l0Mlx3aW5cUmVzaXplVmlld1doaWxlSGlkZGVuLmNwcCIKIAkJCQkJCT4K IAkJCQkJPC9GaWxlPgogCQkJCQk8RmlsZQpJbmRleDogVG9vbHMvVGVzdFdlYktpdEFQSS93aW4v Y29weS1yZXNvdXJjZXMuY21kCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL1Rlc3RXZWJLaXRBUEkvd2lu L2NvcHktcmVzb3VyY2VzLmNtZAkocmV2aXNpb24gOTE1NjkpCisrKyBUb29scy9UZXN0V2ViS2l0 QVBJL3dpbi9jb3B5LXJlc291cmNlcy5jbWQJKHdvcmtpbmcgY29weSkKQEAgLTE3LDYgKzE3LDcg QEAgZm9yICUlZiBpbiAoCiAgICAgLi5cVGVzdHNcV2ViS2l0MlxzaW1wbGUtYWNjZWxlcmF0ZWQt Y29tcG9zaXRpbmcuaHRtbAogICAgIC4uXFRlc3RzXFdlYktpdDJcc2ltcGxlLWZvcm0uaHRtbAog ICAgIC4uXFRlc3RzXFdlYktpdDJcc3BhY2ViYXItc2Nyb2xsaW5nLmh0bWwKKyAgICAuLlxUZXN0 c1xXZWJLaXQyXHdpblxrZXktZXZlbnQtaGFuZGxpbmcuaHRtbAogKSBkbyAoCiAgICAgeGNvcHkg L3kgL2QgJSVmICIlUmVzb3VyY2VzRGlyZWN0b3J5JSIKICkK