222098 2021-02-18 02:30:59 -0800 Regression: Raw AudioBufferSourceNode playback causes repeated crackling sound 2021-06-21 08:21:09 -0700 1 1 1 Unclassified WebKit Web Audio Safari Technology Preview Mac (Intel) Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=226358 InRadar P2 Normal --- 1 jujjyl cdumez aakash_jain anthony.bowker cdumez darin eric.amram eric.carlson ews-watchlist ggaren glenn jer.noble keith_miller kris mark.lam peng.liu6 philipj saam sergio webkit-bot-watchers-bugzilla webkit-bug-importer oldest_to_newest 1730797 0 jujjyl 2021-02-18 02:30:59 -0800 STR: Visit and play https://smashkarts.io/webgl2/ for some minutes Audio playback will begin to crackle. Earlier Safari versions work ok. More information can be found in this thread: https://forum.unity.com/threads/request-for-help-does-your-webgl-2-game-render-correctly-in-safari-tech-preview.1050890/#post-6839972 along with a video of the issue. Unity uses Web Audio with uncompressed AudioBufferSourceNodes to play back audio, so scheduling audio samples is done inside the browser. The uncompressed audio nodes contain the "full" audio clips without JS/Wasm software mixing that would be applied. 1731719 1 webkit-bug-importer 2021-02-19 18:34:46 -0800 <rdar://problem/74546471> 1732343 2 cdumez 2021-02-22 15:44:43 -0800 I can reproduce with the latest build on WebKit indeed. 1732358 3 cdumez 2021-02-22 16:04:39 -0800 It does not appear to be a super recent WebKit regression. I went as far back as r269041 (from Oct 2020) and could already reproduce the issue. Older WebKit builds do not run on my build of macOS. 1760726 4 jujjyl 2021-05-17 04:54:28 -0700 This issue has been since reported a number of times, it looks like it affects a lot of Unity users on the web. Any chance any updates on this? 1760796 5 cdumez 2021-05-17 10:08:18 -0700 (In reply to jujjyl from comment #4) > This issue has been since reported a number of times, it looks like it > affects a lot of Unity users on the web. Any chance any updates on this? A reduced test case would be very helpful. 1761854 6 jujjyl 2021-05-20 00:03:34 -0700 The projects at https://github.com/Unity-Technologies/ProjectTinySamples/ have also been reported to exhibit the same issue. Those are somewhat smaller than the classic Unity builds. 1762608 7 kris 2021-05-21 15:01:13 -0700 Our JS web game (not Unity-based) is also having this issues since Safari 14.1 on both Mac and IOS devices. Here's a simple JSFiddle that shows the issue by playing a ton of sounds. Click on the 'Start Adding Sounds' button, and after roughly 10 seconds the crackling sounds begins. Note - this issue does not occur on MacOS Chrome browsers. https://jsfiddle.net/KrisJohnson/s5vL24o1/123/ I've reduced the code as much as possible and it appears to happen when using panner objects. Let me know if I can be of help. 1764388 8 eric.amram 2021-05-27 10:23:09 -0700 Same on latest iOS 14.5.1 1764392 9 cdumez 2021-05-27 10:26:24 -0700 (In reply to kris from comment #7) > Our JS web game (not Unity-based) is also having this issues since Safari > 14.1 on both Mac and IOS devices. > > Here's a simple JSFiddle that shows the issue by playing a ton of sounds. > Click on the 'Start Adding Sounds' button, and after roughly 10 seconds the > crackling sounds begins. Note - this issue does not occur on MacOS Chrome > browsers. > > https://jsfiddle.net/KrisJohnson/s5vL24o1/123/ > > I've reduced the code as much as possible and it appears to happen when > using panner objects. Let me know if I can be of help. Thanks for the reduced test case, I'll look into it soon. 1764402 10 cdumez 2021-05-27 10:37:29 -0700 (In reply to Chris Dumez from comment #9) > (In reply to kris from comment #7) > > Our JS web game (not Unity-based) is also having this issues since Safari > > 14.1 on both Mac and IOS devices. > > > > Here's a simple JSFiddle that shows the issue by playing a ton of sounds. > > Click on the 'Start Adding Sounds' button, and after roughly 10 seconds the > > crackling sounds begins. Note - this issue does not occur on MacOS Chrome > > browsers. > > > > https://jsfiddle.net/KrisJohnson/s5vL24o1/123/ > > > > I've reduced the code as much as possible and it appears to happen when > > using panner objects. Let me know if I can be of help. > > Thanks for the reduced test case, I'll look into it soon. I am totally able to reproduce with the provided test case on my system Safari. This should help me a lot. 1764406 11 cdumez 2021-05-27 10:45:43 -0700 (In reply to Chris Dumez from comment #10) > (In reply to Chris Dumez from comment #9) > > (In reply to kris from comment #7) > > > Our JS web game (not Unity-based) is also having this issues since Safari > > > 14.1 on both Mac and IOS devices. > > > > > > Here's a simple JSFiddle that shows the issue by playing a ton of sounds. > > > Click on the 'Start Adding Sounds' button, and after roughly 10 seconds the > > > crackling sounds begins. Note - this issue does not occur on MacOS Chrome > > > browsers. > > > > > > https://jsfiddle.net/KrisJohnson/s5vL24o1/123/ > > > > > > I've reduced the code as much as possible and it appears to happen when > > > using panner objects. Let me know if I can be of help. > > > > Thanks for the reduced test case, I'll look into it soon. > > I am totally able to reproduce with the provided test case on my system > Safari. This should help me a lot. Interestingly, the issue seems to stop reproducing when dropping the PannerNode from the graph so maybe the issue is not strictly related to AudioBufferSourceNode. 1764567 12 cdumez 2021-05-27 16:15:22 -0700 I initially see us destroying AudioBufferSourceNode / PannerNode objects as they finish playing. However, after a little while, we stop destroying them (or at least we can't keep up with the rate at which they are created). When we end up with ~2000 AudioBufferSourceNode, the audio gets bad. I haven't figured out yet why the nodes aren't getting deallocated promptly but it is a start. 1764751 13 kris 2021-05-28 07:06:12 -0700 It makes me wonder if my test case identifies a separate issue or if it's another way to expose the problem, as our application and I imagine others are using far fewer than 2000 simultaneous AudioBufferSourceNodes. In our case (and it appears similar to the OP), we play various audio samples of varying lengths, some of which are looping. Then after roughly ~10 seconds, the crackling starts. 1764752 14 kris 2021-05-28 07:12:43 -0700 And to clarify, the crackling only happens when using PannerNodes. 1764759 15 cdumez 2021-05-28 08:11:26 -0700 The javascript wrappers are no longer getting garbage collected in a timely fashion after a while. As a result, our implementation nodes aren't either. It could be a JSC garbage collection issue or an issue with AudioScheduledSourceNode::virtualHasPendingActivity() as the wrapper stays alive as long as this function returns true. The implementation of AudioScheduledSourceNode::virtualHasPendingActivity() seems sensible though: ``` bool AudioScheduledSourceNode::virtualHasPendingActivity() const { return m_hasEndedEventListener && m_playbackState != FINISHED_STATE && !isMarkedForDeletion() && !context().isClosed(); } ``` And from my logging, I do see m_playbackState becoming FINISHED_STATE in a timely fashion. 1764760 16 cdumez 2021-05-28 08:25:51 -0700 It definitely seems there is a garbage collection issue here. When I start playing, I see some calls to AudioScheduledSourceNode::virtualHasPendingActivity(), which return false and I see JS wrappers getting garbage collection. HOWEVER, after this initial period, we go for an extended period of time without AudioScheduledSourceNode::virtualHasPendingActivity() getting called (which seems to indicate the JS wrapper aren't getting visited). Since the JS is constructing JS wrappers very aggressively and since we are not collecting them, the number of JS wrappers grows pretty quickly, once we reach ~12k-15k JS wrappers, the audio quality starts to deteriorate and craters very quickly. I could use some help from our GC experts here to understand why our nodes aren't getting visited in a timely fashion, allowing the number of wrappers to grow so quickly. 1764761 17 cdumez 2021-05-28 08:28:15 -0700 (In reply to Chris Dumez from comment #16) > It definitely seems there is a garbage collection issue here. When I start > playing, I see some calls to > AudioScheduledSourceNode::virtualHasPendingActivity(), which return false > and I see JS wrappers getting garbage collection. HOWEVER, after this > initial period, we go for an extended period of time without > AudioScheduledSourceNode::virtualHasPendingActivity() getting called (which > seems to indicate the JS wrapper aren't getting visited). Since the JS is > constructing JS wrappers very aggressively and since we are not collecting > them, the number of JS wrappers grows pretty quickly, once we reach ~12k-15k > JS wrappers, the audio quality starts to deteriorate and craters very > quickly. > > I could use some help from our GC experts here to understand why our nodes > aren't getting visited in a timely fashion, allowing the number of wrappers > to grow so quickly. The visitor logic is in generated bindings code, here: ``` bool JSAudioScheduledSourceNodeOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC::Unknown> handle, void*, AbstractSlotVisitor& visitor, const char** reason) { auto* jsAudioScheduledSourceNode = jsCast<JSAudioScheduledSourceNode*>(handle.slot()->asCell()); auto& wrapped = jsAudioScheduledSourceNode->wrapped(); if (!wrapped.isContextStopped() && wrapped.hasPendingActivity()) { if (UNLIKELY(reason)) *reason = "ActiveDOMObject with pending activity"; return true; } if (jsAudioScheduledSourceNode->wrapped().isFiringEventListeners()) { if (UNLIKELY(reason)) *reason = "EventTarget firing event listeners"; return true; } UNUSED_PARAM(visitor); UNUSED_PARAM(reason); return false; } ``` 1764762 18 cdumez 2021-05-28 08:37:52 -0700 (In reply to Chris Dumez from comment #17) > (In reply to Chris Dumez from comment #16) > > It definitely seems there is a garbage collection issue here. When I start > > playing, I see some calls to > > AudioScheduledSourceNode::virtualHasPendingActivity(), which return false > > and I see JS wrappers getting garbage collection. HOWEVER, after this > > initial period, we go for an extended period of time without > > AudioScheduledSourceNode::virtualHasPendingActivity() getting called (which > > seems to indicate the JS wrapper aren't getting visited). Since the JS is > > constructing JS wrappers very aggressively and since we are not collecting > > them, the number of JS wrappers grows pretty quickly, once we reach ~12k-15k > > JS wrappers, the audio quality starts to deteriorate and craters very > > quickly. > > > > I could use some help from our GC experts here to understand why our nodes > > aren't getting visited in a timely fashion, allowing the number of wrappers > > to grow so quickly. > > The visitor logic is in generated bindings code, here: > ``` > bool > JSAudioScheduledSourceNodeOwner::isReachableFromOpaqueRoots(JSC::Handle<JSC:: > Unknown> handle, void*, AbstractSlotVisitor& visitor, const char** reason) > { > auto* jsAudioScheduledSourceNode = > jsCast<JSAudioScheduledSourceNode*>(handle.slot()->asCell()); > auto& wrapped = jsAudioScheduledSourceNode->wrapped(); > if (!wrapped.isContextStopped() && wrapped.hasPendingActivity()) { > if (UNLIKELY(reason)) > *reason = "ActiveDOMObject with pending activity"; > return true; > } > if (jsAudioScheduledSourceNode->wrapped().isFiringEventListeners()) { > if (UNLIKELY(reason)) > *reason = "EventTarget firing event listeners"; > return true; > } > UNUSED_PARAM(visitor); > UNUSED_PARAM(reason); > return false; > } > ``` Thinking about this more, it may be acceptable from GC's point of view to not collect if the memory usage doesn't get too high. I think part of the issue may be that our WebAudio implementation relies on the AudioNodes's JS wrappers to get collected promptly to maintain performance. I suspect the issue may be that AudioScheduledSourceNodes don't break their connections to other nodes when finishing (until their ref count goes to 0, which cannot happen while the JS wrapper is alive). As a result, the audio graph becomes very large very quickly and we have to traverse this very large audio graph for every render quantum, thus the big perf hit. I'll see if I can take the AudioScheduledSourceNode out of the graph as soon as it's finished playing. 1764797 19 cdumez 2021-05-28 09:38:53 -0700 (In reply to kris from comment #14) > And to clarify, the crackling only happens when using PannerNodes. Actually, you can actually replace the PannerNode in your demo with a DelayNode and the same issue will happen. I think it is about the AudioBufferSourceNode not being connected directly to the listenerGain somehow. 1764811 20 cdumez 2021-05-28 10:01:10 -0700 (In reply to Chris Dumez from comment #19) > (In reply to kris from comment #14) > > And to clarify, the crackling only happens when using PannerNodes. > > Actually, you can actually replace the PannerNode in your demo with a > DelayNode and the same issue will happen. I think it is about the > AudioBufferSourceNode not being connected directly to the listenerGain > somehow. Ok, some progress, if I make PannerNode::requiresTailProcessing() return false then the issue no longer reproduces. So the issue likely only reproduces if the AudioBufferSource is connected to a node that requires tail processing (Both Delay and Panner nodes) require tail processing. I think it is related to this code in AudioNode::disableOutputsIfNecessary(): ``` if (m_connectionRefCount <= 1 && !m_isDisabled) { if (!requiresTailProcessing()) disableOutputs(); } ``` disableOutputs() is not getting called because requiresTailProcessing() returns true. disableOutputsIfNecessary() gets called when the AudioNode loses its last connection. 1764827 21 cdumez 2021-05-28 10:47:46 -0700 (In reply to Chris Dumez from comment #20) > (In reply to Chris Dumez from comment #19) > > (In reply to kris from comment #14) > > > And to clarify, the crackling only happens when using PannerNodes. > > > > Actually, you can actually replace the PannerNode in your demo with a > > DelayNode and the same issue will happen. I think it is about the > > AudioBufferSourceNode not being connected directly to the listenerGain > > somehow. > > Ok, some progress, if I make PannerNode::requiresTailProcessing() return > false then the issue no longer reproduces. So the issue likely only > reproduces if the AudioBufferSource is connected to a node that requires > tail processing (Both Delay and Panner nodes) require tail processing. > > I think it is related to this code in AudioNode::disableOutputsIfNecessary(): > ``` > if (m_connectionRefCount <= 1 && !m_isDisabled) { > if (!requiresTailProcessing()) > disableOutputs(); > } > ``` > > disableOutputs() is not getting called because requiresTailProcessing() > returns true. > disableOutputsIfNecessary() gets called when the AudioNode loses its last > connection. Seems to indicate we need to keep track of the nodes doing tail processing and disable their outputs once they're done processing their tail. I am working on a patch. 1764914 22 430049 cdumez 2021-05-28 13:56:03 -0700 Created attachment 430049 Patch 1764915 23 cdumez 2021-05-28 14:01:31 -0700 A temporary workaround for people until this fix ships would likely be to manually remove nodes from the graph once they are no longer useful. 1764920 24 eric.amram 2021-05-28 14:12:24 -0700 (In reply to Chris Dumez from comment #22) > Created attachment 430049 [details] > Patch Great news, congrats for the patch Chris! Looking forward to testing it on iOS too. 1764959 25 430049 darin 2021-05-28 15:13:44 -0700 Comment on attachment 430049 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430049&action=review The WinCairo build failure looks real. > Source/WebCore/Modules/webaudio/BaseAudioContext.cpp:629 > + // Heap allocations are forbidden on the audio thread for performance reasons so we need to > + // explicitly allow the following allocation(s). What makes the following allocation OK? Just that it’s one of only a few? Comment should make that clear too. This restriction isn’t great if we are constantly disabling it. I’d like clearer explanation when we do of what’s special. > Source/WebCore/Modules/webaudio/BaseAudioContext.cpp:661 > + // Heap allocations are forbidden on the audio thread for performance reasons so we need to > + // explicitly allow the following allocation(s). > + DisableMallocRestrictionsForCurrentThreadScope disableMallocRestrictions; Ditto. > Source/WebCore/Modules/webaudio/BaseAudioContext.cpp:677 > + // Heap allocations are forbidden on the audio thread for performance reasons so we need to > + // explicitly allow the following allocation(s). > + DisableMallocRestrictionsForCurrentThreadScope disableMallocRestrictions; Ditto. > Source/WebCore/Modules/webaudio/BaseAudioContext.h:325 > + TailProcessingNode(TailProcessingNode&& other) > + : m_node(std::exchange(other.m_node, nullptr)) > + { } If we used Ref instead of RefPtr, I think this exact move constructor would be generated for us, automatically without us having to write this code. We probably need to delete the copy constructor, assignment operator, and move-assignment operator. If any of them were used, setIsTailProcessing would get out of whack. Maybe the copy constructor is automatically deleted because we are explicitly providing a move constructor. The same is not true of the assignment operators, though. > Source/WebCore/Modules/webaudio/BaseAudioContext.h:329 > + if (m_node) > + m_node->setIsTailProcessing(false); This would be a little harder to write if we did that, but we could just use m_node.ptr(). I think it’s good on balance to switch to Ref. 1764962 26 430049 cdumez 2021-05-28 15:19:04 -0700 Comment on attachment 430049 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430049&action=review >> Source/WebCore/Modules/webaudio/BaseAudioContext.cpp:629 >> + // explicitly allow the following allocation(s). > > What makes the following allocation OK? Just that it’s one of only a few? Comment should make that clear too. This restriction isn’t great if we are constantly disabling it. I’d like clearer explanation when we do of what’s special. Vector appends don't always allocate. The assertions help us make sure we keep allocations to a minimum. >> Source/WebCore/Modules/webaudio/BaseAudioContext.h:325 >> + { } > > If we used Ref instead of RefPtr, I think this exact move constructor would be generated for us, automatically without us having to write this code. > > We probably need to delete the copy constructor, assignment operator, and move-assignment operator. If any of them were used, setIsTailProcessing would get out of whack. Maybe the copy constructor is automatically deleted because we are explicitly providing a move constructor. The same is not true of the assignment operators, though. Since we have a custom destructor so no move constructor would get generated by default unless I forced it. I guess `TailProcessingNode(TailProcessingNode&&) = default;` would do the trick. >> Source/WebCore/Modules/webaudio/BaseAudioContext.h:329 >> + m_node->setIsTailProcessing(false); > > This would be a little harder to write if we did that, but we could just use m_node.ptr(). I think it’s good on balance to switch to Ref. Are you suggested I use a Ref<> that's already been moved out here? If so, I don't like the idea and Ref::ptr() would hit an assertion. 1764964 27 430049 peng.liu6 2021-05-28 15:29:34 -0700 Comment on attachment 430049 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430049&action=review > Source/WebCore/ChangeLog:25 > + The issue was that once those nodes had finished processing their tail, we wouldn't come Can we let the node which just finished processing its tail to put itself into some list? I guess that will make the job of clean up the list a bit easier. Not sure it is better/feasible though. 1764988 28 430049 darin 2021-05-28 16:25:24 -0700 Comment on attachment 430049 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430049&action=review >>> Source/WebCore/Modules/webaudio/BaseAudioContext.h:325 >>> + { } >> >> If we used Ref instead of RefPtr, I think this exact move constructor would be generated for us, automatically without us having to write this code. >> >> We probably need to delete the copy constructor, assignment operator, and move-assignment operator. If any of them were used, setIsTailProcessing would get out of whack. Maybe the copy constructor is automatically deleted because we are explicitly providing a move constructor. The same is not true of the assignment operators, though. > > Since we have a custom destructor so no move constructor would get generated by default unless I forced it. I guess `TailProcessingNode(TailProcessingNode&&) = default;` would do the trick. Makes sense. Maybe the copy constructor is not a problem, and the assignment operator is the remaining problem. I think it should be deleted for completeness even though there’s little practical risk of it being used by accident. Not sure if you need to delete one or both of the assignment operators. Probably only one. >>> Source/WebCore/Modules/webaudio/BaseAudioContext.h:329 >>> + m_node->setIsTailProcessing(false); >> >> This would be a little harder to write if we did that, but we could just use m_node.ptr(). I think it’s good on balance to switch to Ref. > > Are you suggested I use a Ref<> that's already been moved out here? If so, I don't like the idea and Ref::ptr() would hit an assertion. OK, then Ref<> makes the move constructor automatically correct, but makes the destructor impossible to write. Too bad! 1764997 29 430049 cdumez 2021-05-28 16:32:29 -0700 Comment on attachment 430049 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430049&action=review >>>> Source/WebCore/Modules/webaudio/BaseAudioContext.h:325 >>>> + { } >>> >>> If we used Ref instead of RefPtr, I think this exact move constructor would be generated for us, automatically without us having to write this code. >>> >>> We probably need to delete the copy constructor, assignment operator, and move-assignment operator. If any of them were used, setIsTailProcessing would get out of whack. Maybe the copy constructor is automatically deleted because we are explicitly providing a move constructor. The same is not true of the assignment operators, though. >> >> Since we have a custom destructor so no move constructor would get generated by default unless I forced it. I guess `TailProcessingNode(TailProcessingNode&&) = default;` would do the trick. > > Makes sense. Maybe the copy constructor is not a problem, and the assignment operator is the remaining problem. I think it should be deleted for completeness even though there’s little practical risk of it being used by accident. Not sure if you need to delete one or both of the assignment operators. Probably only one. You said switching to Ref<> would make the generated move constructor correct. However, I don't understand what would be the issue the the default move constructor generated if my data member is a RefPtr<>. My understanding is that it would be identical to what I wrote. I still decided to write it out because I thought it was clearer. 1765006 30 430049 darin 2021-05-28 16:42:59 -0700 Comment on attachment 430049 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=430049&action=review >>>>> Source/WebCore/Modules/webaudio/BaseAudioContext.h:325 >>>>> + { } >>>> >>>> If we used Ref instead of RefPtr, I think this exact move constructor would be generated for us, automatically without us having to write this code. >>>> >>>> We probably need to delete the copy constructor, assignment operator, and move-assignment operator. If any of them were used, setIsTailProcessing would get out of whack. Maybe the copy constructor is automatically deleted because we are explicitly providing a move constructor. The same is not true of the assignment operators, though. >>> >>> Since we have a custom destructor so no move constructor would get generated by default unless I forced it. I guess `TailProcessingNode(TailProcessingNode&&) = default;` would do the trick. >> >> Makes sense. Maybe the copy constructor is not a problem, and the assignment operator is the remaining problem. I think it should be deleted for completeness even though there’s little practical risk of it being used by accident. Not sure if you need to delete one or both of the assignment operators. Probably only one. > > You said switching to Ref<> would make the generated move constructor correct. However, I don't understand what would be the issue the the default move constructor generated if my data member is a RefPtr<>. My understanding is that it would be identical to what I wrote. I still decided to write it out because I thought it was clearer. I agree that it’s clearer, because we require the "exchange" semantic here, where RefPtr is making a design choice that could change some day in theory (although in practice we won’t change it). I missed that angle before, but now I see it, thanks to your patient explanation. 1765020 31 kris 2021-05-28 17:07:05 -0700 (In reply to Chris Dumez from comment #23) > A temporary workaround for people until this fix ships would likely be to > manually remove nodes from the graph once they are no longer useful. Thanks Chris, your workaround fixes the crackle for us! 1765021 32 cdumez 2021-05-28 17:08:00 -0700 (In reply to kris from comment #31) > (In reply to Chris Dumez from comment #23) > > A temporary workaround for people until this fix ships would likely be to > > manually remove nodes from the graph once they are no longer useful. > > Thanks Chris, your workaround fixes the crackle for us! Great news! I understand people want to get things working ASAP :) 1765022 33 430076 cdumez 2021-05-28 17:12:03 -0700 Created attachment 430076 Patch 1765047 34 ews-feeder 2021-05-28 18:28:19 -0700 Committed r278233 (238270@main): <https://commits.webkit.org/238270@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 430076. 1765283 35 cdumez 2021-05-30 17:58:19 -0700 Tiny follow-up assertion fix in <https://commits.webkit.org/238300@main>. 1765494 36 aakash_jain 2021-05-31 19:40:08 -0700 (In reply to EWS from comment #34) > Committed r278233 (238270@main): <https://commits.webkit.org/238270@main> This broke imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https.html which still seems to be broken on iOS after the follow-up fix. History: https://results.webkit.org/?suite=layout-tests&test=imported%2Fw3c%2Fweb-platform-tests%2Fwebaudio%2Fthe-audio-api%2Fthe-convolvernode-interface%2Factive-processing.https.html 1765495 37 cdumez 2021-05-31 19:40:55 -0700 (In reply to Aakash Jain from comment #36) > (In reply to EWS from comment #34) > > Committed r278233 (238270@main): <https://commits.webkit.org/238270@main> > This broke > imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode- > interface/active-processing.https.html which still seems to be broken on iOS > after the follow-up fix. > > History: > https://results.webkit.org/?suite=layout-tests&test=imported%2Fw3c%2Fweb- > platform-tests%2Fwebaudio%2Fthe-audio-api%2Fthe-convolvernode- > interface%2Factive-processing.https.html Ok, looking now 1765498 38 cdumez 2021-05-31 19:45:07 -0700 (In reply to Chris Dumez from comment #37) > (In reply to Aakash Jain from comment #36) > > (In reply to EWS from comment #34) > > > Committed r278233 (238270@main): <https://commits.webkit.org/238270@main> > > This broke > > imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode- > > interface/active-processing.https.html which still seems to be broken on iOS > > after the follow-up fix. > > > > History: > > https://results.webkit.org/?suite=layout-tests&test=imported%2Fw3c%2Fweb- > > platform-tests%2Fwebaudio%2Fthe-audio-api%2Fthe-convolvernode- > > interface%2Factive-processing.https.html > > Ok, looking now Looks like a potential progression: --- /Volumes/Data/worker/ios-simulator-14-debug-tests-wk2/build/layout-test-results/imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https-expected.txt +++ /Volumes/Data/worker/ios-simulator-14-debug-tests-wk2/build/layout-test-results/imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https-actual.txt @@ -8,7 +8,8 @@ PASS < [initialize] All assertions passed. (total 1 assertions) PASS > [test] PASS Test 0: Number of convolver output channels is equal to 2. -FAIL X Number of distinct values is not equal to 2. Got 1. assert_true: expected true got false -FAIL < [test] 1 out of 2 assertions were failed. assert_true: expected true got false +FAIL X Test 1: Number of convolver output channels is not equal to 1. Got 0. assert_true: expected true got false +PASS Number of distinct values is equal to 2. +FAIL < [test] 1 out of 3 assertions were failed. assert_true: expected true got false FAIL # AUDIT TASK RUNNER FINISHED: 1 out of 2 tasks were failed. assert_true: expected true got false 1765499 39 cdumez 2021-05-31 19:46:38 -0700 (In reply to Chris Dumez from comment #38) > (In reply to Chris Dumez from comment #37) > > (In reply to Aakash Jain from comment #36) > > > (In reply to EWS from comment #34) > > > > Committed r278233 (238270@main): <https://commits.webkit.org/238270@main> > > > This broke > > > imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode- > > > interface/active-processing.https.html which still seems to be broken on iOS > > > after the follow-up fix. > > > > > > History: > > > https://results.webkit.org/?suite=layout-tests&test=imported%2Fw3c%2Fweb- > > > platform-tests%2Fwebaudio%2Fthe-audio-api%2Fthe-convolvernode- > > > interface%2Factive-processing.https.html > > > > Ok, looking now > > Looks like a potential progression: > --- > /Volumes/Data/worker/ios-simulator-14-debug-tests-wk2/build/layout-test- > results/imported/w3c/web-platform-tests/webaudio/the-audio-api/the- > convolvernode-interface/active-processing.https-expected.txt > +++ > /Volumes/Data/worker/ios-simulator-14-debug-tests-wk2/build/layout-test- > results/imported/w3c/web-platform-tests/webaudio/the-audio-api/the- > convolvernode-interface/active-processing.https-actual.txt > @@ -8,7 +8,8 @@ > PASS < [initialize] All assertions passed. (total 1 assertions) > PASS > [test] > PASS Test 0: Number of convolver output channels is equal to 2. > -FAIL X Number of distinct values is not equal to 2. Got 1. assert_true: > expected true got false > -FAIL < [test] 1 out of 2 assertions were failed. assert_true: expected true > got false > +FAIL X Test 1: Number of convolver output channels is not equal to 1. Got > 0. assert_true: expected true got false > +PASS Number of distinct values is equal to 2. > +FAIL < [test] 1 out of 3 assertions were failed. assert_true: expected true > got false > FAIL # AUDIT TASK RUNNER FINISHED: 1 out of 2 tasks were failed. > assert_true: expected true got false We didn't see it on Mac because this test is already marked as flaky on that platform: LayoutTests/platform/mac/TestExpectations:webkit.org/b/225421 imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode-interface/active-processing.https.html [ Pass Failure ] 1765500 40 cdumez 2021-05-31 19:56:35 -0700 (In reply to Chris Dumez from comment #39) > (In reply to Chris Dumez from comment #38) > > (In reply to Chris Dumez from comment #37) > > > (In reply to Aakash Jain from comment #36) > > > > (In reply to EWS from comment #34) > > > > > Committed r278233 (238270@main): <https://commits.webkit.org/238270@main> > > > > This broke > > > > imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode- > > > > interface/active-processing.https.html which still seems to be broken on iOS > > > > after the follow-up fix. > > > > > > > > History: > > > > https://results.webkit.org/?suite=layout-tests&test=imported%2Fw3c%2Fweb- > > > > platform-tests%2Fwebaudio%2Fthe-audio-api%2Fthe-convolvernode- > > > > interface%2Factive-processing.https.html > > > > > > Ok, looking now > > > > Looks like a potential progression: > > --- > > /Volumes/Data/worker/ios-simulator-14-debug-tests-wk2/build/layout-test- > > results/imported/w3c/web-platform-tests/webaudio/the-audio-api/the- > > convolvernode-interface/active-processing.https-expected.txt > > +++ > > /Volumes/Data/worker/ios-simulator-14-debug-tests-wk2/build/layout-test- > > results/imported/w3c/web-platform-tests/webaudio/the-audio-api/the- > > convolvernode-interface/active-processing.https-actual.txt > > @@ -8,7 +8,8 @@ > > PASS < [initialize] All assertions passed. (total 1 assertions) > > PASS > [test] > > PASS Test 0: Number of convolver output channels is equal to 2. > > -FAIL X Number of distinct values is not equal to 2. Got 1. assert_true: > > expected true got false > > -FAIL < [test] 1 out of 2 assertions were failed. assert_true: expected true > > got false > > +FAIL X Test 1: Number of convolver output channels is not equal to 1. Got > > 0. assert_true: expected true got false > > +PASS Number of distinct values is equal to 2. > > +FAIL < [test] 1 out of 3 assertions were failed. assert_true: expected true > > got false > > FAIL # AUDIT TASK RUNNER FINISHED: 1 out of 2 tasks were failed. > > assert_true: expected true got false > > We didn't see it on Mac because this test is already marked as flaky on that > platform: > LayoutTests/platform/mac/TestExpectations:webkit.org/b/225421 > imported/w3c/web-platform-tests/webaudio/the-audio-api/the-convolvernode- > interface/active-processing.https.html [ Pass Failure ] Rebaselined test in <https://commits.webkit.org/r278293>. 1771287 41 kris 2021-06-21 08:21:09 -0700 (In reply to Chris Dumez from comment #32) > (In reply to kris from comment #31) > > (In reply to Chris Dumez from comment #23) > > > A temporary workaround for people until this fix ships would likely be to > > > manually remove nodes from the graph once they are no longer useful. > > > > Thanks Chris, your workaround fixes the crackle for us! > > Great news! I understand people want to get things working ASAP :) Hey Chris, we're hearing the crackling issue again using your workaround in our product. Was the originally reported link tested and working correctly with your patch? This problem is such a show stopper for us I just want to confirm it's not a separate issue. Thanks! Original reported issue: STR: Visit and play https://smashkarts.io/webgl2/ for some minutes 430049 2021-05-28 13:56:03 -0700 2021-05-28 17:12:00 -0700 Patch bug-222098-20210528135602.patch text/plain 14455 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc4MTk2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZmU4ODJiMjM4YWI4MTNk MjNhZjRhZTkxMzA0NTIzZDFiZTg4NGYzZC4uMzZhOTg3OTE0YzBjNjlmMGJjYTI2NzYwNDYzMDFm YTQzODJjNjQ2NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY0IEBACisyMDIxLTA1LTI4ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgUmVncmVzc2lvbjogUmF3IEF1 ZGlvQnVmZmVyU291cmNlTm9kZSBwbGF5YmFjayBjYXVzZXMgcmVwZWF0ZWQgY3JhY2tsaW5nIHNv dW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjIw OTgKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzc0NTQ2NDcxPgorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSBpc3N1ZSB3YXMgZHVlIHRvIGNlcnRh aW4gYXVkaW8gbm9kZXMgKHN1Y2ggYXMgQXVkaW9CdWZmZXJTb3VyY2VOb2RlKSBzdGF5aW5nIGlu IHRoZSBhdWRpbworICAgICAgICBncmFwaCBhZnRlciB0aGV5IHdlcmUgbm8gbG9uZ2VyIG5lZWRl ZC4gQXMgYSByZXN1bHQsIHRoZSBhdWRpbyBncmFwaCB3YXMgYmVjb21pbmcgbGFyZ2VyIGFuZAor ICAgICAgICBsYXJnZXIgYW5kIHRoZSBhdWRpbyBwZXJmb3JtYW5jZSBzaG91bGQgZGVncmFkZSBk dWUgdG8gdXMgdHJhdmVyc2luZyB0aGlzIGluY3JlYXNpbmdseSBsYXJnZQorICAgICAgICBncmFw aC4KKworICAgICAgICBUaGUgYXVkaW8gbm9kZXMgdGhhdCBoYWQgdHJvdWJsZSBnZXR0aW5nIHJl bW92ZWQgZnJvbSB0aGUgZ3JhcGhzIHdlcmUgdGFpbCBwcm9jZXNzaW5nIG5vZGVzLgorICAgICAg ICBUaG9zZSBhcmUgbm9kZXMgdGhhdCBtYXkgc3RpbGwgcHJvZHVjZSBvdXRwdXQgZm9yIGEgd2hp bGUgYWZ0ZXIgdGhleSBubyBsb25nZXIgaGF2ZSBhbnkKKyAgICAgICAgaW5wdXRzLiBQYW5uZXJO b2RlIGFuZCBEZWxheU5vZGUgYXJlIGV4YW1wbGUgb2Ygc3VjaCBub2Rlcy4KKworICAgICAgICBX aGVuIGEgTm9kZSBpcyBubyBsb25nZXIgdXNlZnVsICh0aGUgbm9kZSBubyBsb25nZXIgaGFzIGFu eSBjb25uZWN0aW9ucywgbV9jb25uZWN0aW9uUmVmQ291bnQKKyAgICAgICAgaXMgMCksIHdlIGNh bGwgZGlzYWJsZU91dHB1dHNJZk5lY2Vzc2FyeSgpIG9uIGl0IHRvIGRpc2FibGUgaXRzIG91dHB1 dHMgYW5kIGF2b2lkIGRvaW5nIGFueQorICAgICAgICBwcm9jZXNzaW5nIG9mIHRoZXNlIG91dHB1 dHMgc2luY2UgdGhleSBubyBsb25nZXIgaGF2ZSBhbiBpbnB1dC4gZGlzYWJsZU91dHB1dHNJZk5l Y2Vzc2FyeSgpCisgICAgICAgIHdvdWxkIG5vcm1hbGx5IGNhbGwgZGlzYWJsZU91dHB1dHMoKSAo aWYgbm90IGFscmVhZHkgZGlzYWJsZWQpIGJ1dCB0aGVyZSB3YXMgYW4gZXhjZXB0aW9uCisgICAg ICAgIGluIHRoZSBjYXNlIHdoZXJlIHRoZSBub2RlIHJlcXVpcmVzIHRhaWwgcHJvY2Vzc2luZy4g Rm9yIHN1Y2ggbm9kZXMsIHlvdSB3b3VsZG4ndCB3YW50IHRvCisgICAgICAgIGRpc2FibGUgdGhl bSB1bnRpbCB0aGV5J3ZlIGZpbmlzaGVkIHByb2Nlc3NpbmcgdGhlaXIgdGFpbC4KKworICAgICAg ICBUaGUgaXNzdWUgd2FzIHRoYXQgb25jZSB0aG9zZSBub2RlcyBoYWQgZmluaXNoZWQgcHJvY2Vz c2luZyB0aGVpciB0YWlsLCB3ZSB3b3VsZG4ndCBjb21lCisgICAgICAgIGJhY2sgdG8gdGhlbSBh bmQgZGlzYWJsZSB0aGVpciBvdXRwdXRzIGxhdGVyIG9uLiBBcyBhIHJlc3VsdCwgd2Ugd291bGQg cHJvY2VzcyBtb3JlIGFuZAorICAgICAgICBtb3JlIChzaWxlbnQpIG5vZGVzIGFuZCB0aGUgYXVk aW8gcGVyZm9ybWFuY2Ugd291bGQgc2VyaW91c2x5IGRldGVyaW9yYXRlLgorCisgICAgICAgIFRv IGFkZHJlc3MgdGhpcywgd2Ugbm93IGFkZCB0aGUgbm9kZSB0byB0aGUgY29udGV4dCdzIGxpc3Qg b2YgdGFpbCBwcm9jZXNzaW5nIG5vZGVzIGluCisgICAgICAgIGRpc2FibGVPdXRwdXRzSWZOZWNl c3NhcnkoKSBpZiB0aGUgbm9kZSByZXF1aXJlcyB0YWlsIHByb2Nlc3NpbmcuIEFmdGVyIGVhY2gg cmVuZGVyaW5nCisgICAgICAgIHF1YW50dW0sIHdlIGdvIHRocm91Z2ggdGhvc2UgdGFpbCBwcm9j ZXNzaW5nIG5vZGVzIGFuZCBjaGVjayBpZiB0aGV5IGhhdmUgZmluaXNoZWQKKyAgICAgICAgcHJv Y2Vzc2luZyB0aGVpciB0YWlsLiBJZiB0aGV5IGhhdmUsIHdlIGdvIGFoZWFkIGFuZCBkaXNhYmxl IHRoZWlyIG91dHB1dHMgYXQgdGhpcyBwb2ludAorICAgICAgICBhbmQgcmVtb3ZlIHRoZW0gZnJv bSB0aGUgbGlzdC4KKworICAgICAgICBUaGlzIGlzIG1vZGVsZWQgYWZ0ZXIgd2hhdCBCbGluayBp cyBkb2luZyBmb3IgdGFpbCBwcm9jZXNzaW5nIG5vZGVzIGluOgorICAgICAgICAtIGh0dHBzOi8v Z2l0aHViLmNvbS9jaHJvbWl1bS9jaHJvbWl1bS9ibG9iL21hc3Rlci90aGlyZF9wYXJ0eS9ibGlu ay9yZW5kZXJlci9tb2R1bGVzL3dlYmF1ZGlvL2RlZmVycmVkX3Rhc2tfaGFuZGxlci5jYworCisg ICAgICAgIEkgaGF2ZSB2ZXJpZmllZCB0aGF0IG9uIHRoZSBmb2xsb3dpbmcgZGVtbywgdGhlIHBl cmZvcm1hbmNlIG5vIGxvbmdlciBkZXRlcmlvcmF0ZXMgYWZ0ZXIKKyAgICAgICAgYSB3aGlsZToK KyAgICAgICAgLSBodHRwczovL2pzZmlkZGxlLm5ldC9LcmlzSm9obnNvbi9zNXZMMjRvMS8xMjMv CisKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb05vZGU6OmVuYWJsZU91dHB1dHNJZk5lY2Vzc2FyeSk6CisgICAgICAgIChX ZWJDb3JlOjpBdWRpb05vZGU6OmRpc2FibGVPdXRwdXRzSWZOZWNlc3NhcnkpOgorICAgICAgICAq IE1vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmg6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05v ZGU6OmlzVGFpbFByb2Nlc3NpbmcgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2Rl OjpzZXRJc1RhaWxQcm9jZXNzaW5nKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0Jhc2VB dWRpb0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6dW5p bml0aWFsaXplKToKKyAgICAgICAgKFdlYkNvcmU6OkJhc2VBdWRpb0NvbnRleHQ6OmhhbmRsZVBv c3RSZW5kZXJUYXNrcyk6CisgICAgICAgIChXZWJDb3JlOjpCYXNlQXVkaW9Db250ZXh0OjphZGRU YWlsUHJvY2Vzc2luZ05vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6 cmVtb3ZlVGFpbFByb2Nlc3NpbmdOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkJhc2VBdWRpb0Nv bnRleHQ6OnVwZGF0ZVRhaWxQcm9jZXNzaW5nTm9kZXMpOgorICAgICAgICAoV2ViQ29yZTo6QmFz ZUF1ZGlvQ29udGV4dDo6ZGlzYWJsZU91dHB1dHNGb3JGaW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9k ZXMpOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6ZmluaXNoVGFpbFByb2Nl c3NpbmcpOgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5oOgor ICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6VGFpbFByb2Nlc3NpbmdOb2RlOjpU YWlsUHJvY2Vzc2luZ05vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6 VGFpbFByb2Nlc3NpbmdOb2RlOjp+VGFpbFByb2Nlc3NpbmdOb2RlKToKKyAgICAgICAgKFdlYkNv cmU6OkJhc2VBdWRpb0NvbnRleHQ6OlRhaWxQcm9jZXNzaW5nTm9kZTo6b3BlcmF0b3ItPiBjb25z dCk6CisgICAgICAgIChXZWJDb3JlOjpCYXNlQXVkaW9Db250ZXh0OjpUYWlsUHJvY2Vzc2luZ05v ZGU6Om9wZXJhdG9yPT0gY29uc3QpOgorCiAyMDIxLTA1LTI3ICBDaHJpcyBEdW1leiAgPGNkdW1l ekBhcHBsZS5jb20+CiAKICAgICAgICAgRGVsYXlEU1BLZXJuZWw6OnByb2Nlc3MoKSBpcyBzbG93 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHAKaW5kZXgg MDYwNGY1YWM3OGZkNDc0ZDgyMTFlNDVhOWNjOTYxMmUyZTBmY2UxNS4uYjk4Zjg0ZjY2NDZjZmE2 NDZjODMwMGQ5YzY0OTQ1MzhhYzE2YzA5ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2ViYXVkaW8vQXVkaW9Ob2RlLmNwcApAQCAtNTIxLDkgKzUyMSwxMiBAQCB2b2lkIEF1ZGlvTm9k ZTo6c2lsZW5jZU91dHB1dHMoKQogCiB2b2lkIEF1ZGlvTm9kZTo6ZW5hYmxlT3V0cHV0c0lmTmVj ZXNzYXJ5KCkKIHsKKyAgICBMb2NrZXIgbG9ja2VyIHsgY29udGV4dCgpLmdyYXBoTG9jaygpIH07 CisgICAgaWYgKGlzVGFpbFByb2Nlc3NpbmcoKSkKKyAgICAgICAgY29udGV4dCgpLnJlbW92ZVRh aWxQcm9jZXNzaW5nTm9kZSgqdGhpcyk7CisKICAgICBpZiAobV9pc0Rpc2FibGVkICYmIG1fY29u bmVjdGlvblJlZkNvdW50ID4gMCkgewogICAgICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwot ICAgICAgICBMb2NrZXIgbG9ja2VyIHsgY29udGV4dCgpLmdyYXBoTG9jaygpIH07CiAKICAgICAg ICAgbV9pc0Rpc2FibGVkID0gZmFsc2U7CiAgICAgICAgIGZvciAoYXV0byYgb3V0cHV0IDogbV9v dXRwdXRzKQpAQCAtNTQ1LDEwICs1NDgsMTEgQEAgdm9pZCBBdWRpb05vZGU6OmRpc2FibGVPdXRw dXRzSWZOZWNlc3NhcnkoKQogICAgICAgICAvLyBCdXQgaW50ZXJuYWxseSBvdXIgb3V0cHV0cyBz aG91bGQgYmUgZGlzYWJsZWQgZnJvbSB0aGUgaW5wdXRzIHRoZXkncmUgY29ubmVjdGVkIHRvLgog ICAgICAgICAvLyBkaXNhYmxlKCkgY2FuIHJlY3Vyc2l2ZWx5IGRlcmVmIGNvbm5lY3Rpb25zIChh bmQgY2FsbCBkaXNhYmxlKCkpIGRvd24gYSB3aG9sZSBjaGFpbiBvZiBjb25uZWN0ZWQgbm9kZXMu CiAKLSAgICAgICAgLy8gSWYgYSBub2RlIHJlcXVpcmVzIHRhaWwgcHJvY2Vzc2luZywgd2UgZGVm ZXIgdGhlIGRpc2FibGluZyBvZgotICAgICAgICAvLyB0aGUgb3V0cHV0cyBzbyB0aGF0IHRoZSB0 YWlsIGZvciB0aGUgbm9kZSBjYW4gYmUgb3V0cHV0LgorICAgICAgICAvLyBJZiBhIG5vZGUgcmVx dWlyZXMgdGFpbCBwcm9jZXNzaW5nLCB3ZSBkZWZlciB0aGUgZGlzYWJsaW5nIG9mIHRoZSBvdXRw dXRzIHNvIHRoYXQgdGhlIHRhaWwgZm9yIHRoZSBub2RlIGNhbiBiZSBvdXRwdXQuCiAgICAgICAg IC8vIE90aGVyd2lzZSwgd2UgY2FuIGRpc2FibGUgdGhlIG91dHB1dHMgcmlnaHQgYXdheS4KLSAg ICAgICAgaWYgKCFyZXF1aXJlc1RhaWxQcm9jZXNzaW5nKCkpCisgICAgICAgIGlmIChyZXF1aXJl c1RhaWxQcm9jZXNzaW5nKCkpCisgICAgICAgICAgICBjb250ZXh0KCkuYWRkVGFpbFByb2Nlc3Np bmdOb2RlKCp0aGlzKTsKKyAgICAgICAgZWxzZQogICAgICAgICAgICAgZGlzYWJsZU91dHB1dHMo KTsKICAgICB9CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L0F1ZGlvTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUu aAppbmRleCAyMDU3MGE3MjE1ODc1YzRmMDdkNzI1NmMzM2ZkY2VjMmJiODM4ZDJkLi5hOGJmYWMy YTBjNmQyMWU0ZDRhMjc5NDI2NTEzYzhiOTBjNGZjZGI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKQEAgLTE5MSw2ICsxOTEsMTEgQEAgcHVibGljOgog ICAgIGJvb2wgaXNGaW5pc2hlZFNvdXJjZU5vZGUoKSBjb25zdCB7IHJldHVybiBtX2lzRmluaXNo ZWRTb3VyY2VOb2RlOyB9CiAgICAgdm9pZCBzZXRJc0ZpbmlzaGVkU291cmNlTm9kZSgpIHsgbV9p c0ZpbmlzaGVkU291cmNlTm9kZSA9IHRydWU7IH0KIAorICAgIC8vIEZsYWcgaW5kaWNhdGluZyB0 aGUgbm9kZSBpcyBpbiB0aGUgY29udGV4dCdzIG1fdGFpbFByb2Nlc3NpbmdOb2RlcyBvciBtX2Zp bmlzaFRhaWxQcm9jZXNzaW5nTm9kZXMuCisgICAgLy8gV2UgcmVseSBvbiB0aGlzIGZsYWcgdG8g YXZvaWQgdW5uZWNlc3NhcnkgbGluZWFyIHNlYXJjaGVzIGluIHRob3NlIHZlY3RvcnMuCisgICAg Ym9vbCBpc1RhaWxQcm9jZXNzaW5nKCkgY29uc3QgeyByZXR1cm4gbV9pc1RhaWxQcm9jZXNzaW5n OyB9CisgICAgdm9pZCBzZXRJc1RhaWxQcm9jZXNzaW5nKGJvb2wgaXNUYWlsUHJvY2Vzc2luZykg eyBtX2lzVGFpbFByb2Nlc3NpbmcgPSBpc1RhaWxQcm9jZXNzaW5nOyB9CisKIHByb3RlY3RlZDoK ICAgICAvLyBJbnB1dHMgYW5kIG91dHB1dHMgbXVzdCBiZSBjcmVhdGVkIGJlZm9yZSB0aGUgQXVk aW9Ob2RlIGlzIGluaXRpYWxpemVkLgogICAgIHZvaWQgYWRkSW5wdXQoKTsKQEAgLTI1Myw2ICsy NTgsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9pc01hcmtlZEZvckRlbGV0aW9uIHsgZmFsc2Ug fTsKICAgICBib29sIG1faXNEaXNhYmxlZCB7IGZhbHNlIH07CiAgICAgYm9vbCBtX2lzRmluaXNo ZWRTb3VyY2VOb2RlIHsgZmFsc2UgfTsKKyAgICBib29sIG1faXNUYWlsUHJvY2Vzc2luZyB7IGZh bHNlIH07CiAKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwogICAgIHN0YXRpYyBib29s IHNfaXNOb2RlQ291bnRJbml0aWFsaXplZDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1 bGVzL3dlYmF1ZGlvL0Jhc2VBdWRpb0NvbnRleHQuY3BwCmluZGV4IGUyMDJkN2QyNjJhZDA2NDdi ZGE3NmZiYTUyN2YwYTVhMTYyMWE3ODAuLjQ5MDg1Mzc0M2I3ZTY4M2JlMmJlZTcxMmMxMDM1NTAx MjBjMDg0MjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQmFz ZUF1ZGlvQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9C YXNlQXVkaW9Db250ZXh0LmNwcApAQCAtMTk4LDYgKzE5OCw4IEBAIHZvaWQgQmFzZUF1ZGlvQ29u dGV4dDo6dW5pbml0aWFsaXplKCkKICAgICAvLyBEb24ndCBhbGxvdyB0aGUgY29udGV4dCB0byBp bml0aWFsaXplIGEgc2Vjb25kIHRpbWUgYWZ0ZXIgaXQncyBhbHJlYWR5IGJlZW4gZXhwbGljaXRs eSB1bmluaXRpYWxpemVkLgogICAgIG1faXNBdWRpb1RocmVhZEZpbmlzaGVkID0gdHJ1ZTsKIAor ICAgIGZpbmlzaFRhaWxQcm9jZXNzaW5nKCk7CisKICAgICB7CiAgICAgICAgIExvY2tlciBsb2Nr ZXIgeyBncmFwaExvY2soKSB9OwogICAgICAgICAvLyBUaGlzIHNob3VsZCBoYXZlIGJlZW4gY2Fs bGVkIGZyb20gaGFuZGxlUG9zdFJlbmRlclRhc2tzKCkgYXQgdGhlIGVuZCBvZiByZW5kZXJpbmcu CkBAIC02MDMsNiArNjA1LDcgQEAgdm9pZCBCYXNlQXVkaW9Db250ZXh0OjpoYW5kbGVQb3N0UmVu ZGVyVGFza3MoKQogICAgIGhhbmRsZURpcnR5QXVkaW9Ob2RlT3V0cHV0cygpOwogCiAgICAgdXBk YXRlQXV0b21hdGljUHVsbE5vZGVzKCk7CisgICAgdXBkYXRlVGFpbFByb2Nlc3NpbmdOb2Rlcygp OwogfQogCiB2b2lkIEJhc2VBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkRGVjcmVtZW50Q29u bmVjdGlvbkNvdW50cygpCkBAIC02MTQsNiArNjE3LDkyIEBAIHZvaWQgQmFzZUF1ZGlvQ29udGV4 dDo6aGFuZGxlRGVmZXJyZWREZWNyZW1lbnRDb25uZWN0aW9uQ291bnRzKCkKICAgICBtX2RlZmVy cmVkQnJlYWtDb25uZWN0aW9uTGlzdC5jbGVhcigpOwogfQogCit2b2lkIEJhc2VBdWRpb0NvbnRl eHQ6OmFkZFRhaWxQcm9jZXNzaW5nTm9kZShBdWRpb05vZGUmIG5vZGUpCit7CisgICAgQVNTRVJU KGlzR3JhcGhPd25lcigpKTsKKyAgICBpZiAobm9kZS5pc1RhaWxQcm9jZXNzaW5nKCkpIHsKKyAg ICAgICAgQVNTRVJUKG1fdGFpbFByb2Nlc3NpbmdOb2Rlcy5jb250YWlucyhub2RlKSk7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvLyBIZWFwIGFsbG9jYXRpb25zIGFyZSBmb3JiaWRk ZW4gb24gdGhlIGF1ZGlvIHRocmVhZCBmb3IgcGVyZm9ybWFuY2UgcmVhc29ucyBzbyB3ZSBuZWVk IHRvCisgICAgLy8gZXhwbGljaXRseSBhbGxvdyB0aGUgZm9sbG93aW5nIGFsbG9jYXRpb24ocyku CisgICAgRGlzYWJsZU1hbGxvY1Jlc3RyaWN0aW9uc0ZvckN1cnJlbnRUaHJlYWRTY29wZSBkaXNh YmxlTWFsbG9jUmVzdHJpY3Rpb25zOworICAgIEFTU0VSVCghbV90YWlsUHJvY2Vzc2luZ05vZGVz LmNvbnRhaW5zKG5vZGUpKTsKKyAgICBtX3RhaWxQcm9jZXNzaW5nTm9kZXMuYXBwZW5kKG5vZGUp OworfQorCit2b2lkIEJhc2VBdWRpb0NvbnRleHQ6OnJlbW92ZVRhaWxQcm9jZXNzaW5nTm9kZShB dWRpb05vZGUmIG5vZGUpCit7CisgICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsKKyAgICBBU1NF UlQobm9kZS5pc1RhaWxQcm9jZXNzaW5nKCkpOworCisgICAgaWYgKG1fdGFpbFByb2Nlc3NpbmdO b2Rlcy5yZW1vdmVGaXJzdChub2RlKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgLy8gUmVtb3Zl IHRoZSBub2RlIGZyb20gZmluaXNoZWQgdGFpbCBwcm9jZXNzaW5nIG5vZGVzIHNvIHdlIGRvbid0 IGVuZCB1cCBkaXNhYmxpbmcgaXRzIG91dHB1dHMgbGF0ZXIgb24gdGhlIG1haW4gdGhyZWFkLgor ICAgIEFTU0VSVChtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2Rlcy5jb250YWlucyhub2RlKSk7 CisgICAgbV9maW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMucmVtb3ZlRmlyc3Qobm9kZSk7Cit9 CisKK3ZvaWQgQmFzZUF1ZGlvQ29udGV4dDo6dXBkYXRlVGFpbFByb2Nlc3NpbmdOb2RlcygpCit7 CisgICAgQVNTRVJUKGlzQXVkaW9UaHJlYWQoKSk7CisgICAgQVNTRVJUKGlzR3JhcGhPd25lcigp KTsKKyAgICAvLyBHbyBiYWNrd2FyZHMgYXMgdGhlIGN1cnJlbnQgbm9kZSBtYXkgYmUgcmVtb3Zl ZCBmcm9tIG1fdGFpbFByb2Nlc3NpbmdOb2RlcyBhcyB3ZSBpdGVyYXRlLgorICAgIC8vIFdlIGFy ZSBvbiB0aGUgYXVkaW8gdGhyZWFkIHNvIHdlIHdhbnQgdG8gYXZvaWQgYWxsb2NhdGlvbnMgYXMg bXVjaCBhcyBwb3NzaWJsZS4KKyAgICBmb3IgKGF1dG8gaSA9IG1fdGFpbFByb2Nlc3NpbmdOb2Rl cy5zaXplKCk7IGkgPiAwOyAtLWkpIHsKKyAgICAgICAgYXV0byYgbm9kZSA9IG1fdGFpbFByb2Nl c3NpbmdOb2Rlc1tpIC0gMV07CisgICAgICAgIGlmICghbm9kZS0+cHJvcGFnYXRlc1NpbGVuY2Uo KSkKKyAgICAgICAgICAgIGNvbnRpbnVlOyAvLyBOb2RlIGlzIG5vdCBkb25lIHByb2Nlc3Npbmcg aXRzIHRhaWwuCisKKyAgICAgICAgLy8gSGVhcCBhbGxvY2F0aW9ucyBhcmUgZm9yYmlkZGVuIG9u IHRoZSBhdWRpbyB0aHJlYWQgZm9yIHBlcmZvcm1hbmNlIHJlYXNvbnMgc28gd2UgbmVlZCB0bwor ICAgICAgICAvLyBleHBsaWNpdGx5IGFsbG93IHRoZSBmb2xsb3dpbmcgYWxsb2NhdGlvbihzKS4K KyAgICAgICAgRGlzYWJsZU1hbGxvY1Jlc3RyaWN0aW9uc0ZvckN1cnJlbnRUaHJlYWRTY29wZSBk aXNhYmxlTWFsbG9jUmVzdHJpY3Rpb25zOworCisgICAgICAgIC8vIERpc2FibGluZyBvZiBvdXRw dXRzIHNob3VsZCBoYXBwZW4gb24gdGhlIG1haW4gdGhyZWFkIHdlIGFkZCB0aGUgbm9kZSB0byBt X2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2RlcworICAgICAgICAvLyBmb3IgZGlzYWJsZU91dHB1 dHNGb3JGaW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMoKSB0byBwcm9jZXNzIGxhdGVyIG9uIHRo ZSBtYWluIHRocmVhZC4KKyAgICAgICAgQVNTRVJUKCFtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdO b2Rlcy5jb250YWlucyhub2RlKSk7CisgICAgICAgIG1fZmluaXNoZWRUYWlsUHJvY2Vzc2luZ05v ZGVzLmFwcGVuZChXVEZNb3ZlKG5vZGUpKTsKKyAgICAgICAgbV90YWlsUHJvY2Vzc2luZ05vZGVz LnJlbW92ZShpIC0gMSk7CisgICAgfQorCisgICAgaWYgKG1fZmluaXNoZWRUYWlsUHJvY2Vzc2lu Z05vZGVzLmlzRW1wdHkoKSB8fCBtX2Rpc2FibGVPdXRwdXRzRm9yVGFpbFByb2Nlc3NpbmdTY2hl ZHVsZWQpCisgICAgICAgIHJldHVybjsKKworICAgIG1fZGlzYWJsZU91dHB1dHNGb3JUYWlsUHJv Y2Vzc2luZ1NjaGVkdWxlZCA9IHRydWU7CisKKyAgICAvLyBIZWFwIGFsbG9jYXRpb25zIGFyZSBm b3JiaWRkZW4gb24gdGhlIGF1ZGlvIHRocmVhZCBmb3IgcGVyZm9ybWFuY2UgcmVhc29ucyBzbyB3 ZSBuZWVkIHRvCisgICAgLy8gZXhwbGljaXRseSBhbGxvdyB0aGUgZm9sbG93aW5nIGFsbG9jYXRp b24ocykuCisgICAgRGlzYWJsZU1hbGxvY1Jlc3RyaWN0aW9uc0ZvckN1cnJlbnRUaHJlYWRTY29w ZSBkaXNhYmxlTWFsbG9jUmVzdHJpY3Rpb25zOworICAgIGNhbGxPbk1haW5UaHJlYWQoW3RoaXMs IHByb3RlY3RlZFRoaXMgPSBtYWtlUmVmKCp0aGlzKV0oKSBtdXRhYmxlIHsKKyAgICAgICAgTG9j a2VyIGxvY2tlciB7IGdyYXBoTG9jaygpIH07CisgICAgICAgIGRpc2FibGVPdXRwdXRzRm9yRmlu aXNoZWRUYWlsUHJvY2Vzc2luZ05vZGVzKCk7CisgICAgICAgIG1fZGlzYWJsZU91dHB1dHNGb3JU YWlsUHJvY2Vzc2luZ1NjaGVkdWxlZCA9IGZhbHNlOworICAgIH0pOworfQorCit2b2lkIEJhc2VB dWRpb0NvbnRleHQ6OmRpc2FibGVPdXRwdXRzRm9yRmluaXNoZWRUYWlsUHJvY2Vzc2luZ05vZGVz KCkKK3sKKyAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOworICAgIEFTU0VSVChpc0dyYXBoT3du ZXIoKSk7CisgICAgZm9yIChhdXRvJiBmaW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZSA6IHN0ZDo6 ZXhjaGFuZ2UobV9maW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMsIHsgfSkpCisgICAgICAgIGZp bmlzaGVkVGFpbFByb2Nlc3NpbmdOb2RlLT5kaXNhYmxlT3V0cHV0cygpOworfQorCit2b2lkIEJh c2VBdWRpb0NvbnRleHQ6OmZpbmlzaFRhaWxQcm9jZXNzaW5nKCkKK3sKKyAgICBBU1NFUlQoaXNN YWluVGhyZWFkKCkpOworICAgIExvY2tlciBsb2NrZXIgeyBncmFwaExvY2soKSB9OworCisgICAg Ly8gZGlzYWJsZU91dHB1dHMoKSBjYW4gY2F1c2UgbmV3IG5vZGVzIHRvIHN0YXJ0IHRhaWwgcHJv Y2Vzc2luZyBzbyB3ZSBuZWVkIHRvIGxvb3AgdW50aWwgYm90aCB2ZWN0b3JzIGFyZSBlbXB0eS4K KyAgICB3aGlsZSAoIW1fdGFpbFByb2Nlc3NpbmdOb2Rlcy5pc0VtcHR5KCkgfHwgIW1fZmluaXNo ZWRUYWlsUHJvY2Vzc2luZ05vZGVzLmlzRW1wdHkoKSkgeworICAgICAgICBmb3IgKGF1dG8mIHRh aWxQcm9jZXNzaW5nTm9kZSA6IHN0ZDo6ZXhjaGFuZ2UobV90YWlsUHJvY2Vzc2luZ05vZGVzLCB7 IH0pKQorICAgICAgICAgICAgdGFpbFByb2Nlc3NpbmdOb2RlLT5kaXNhYmxlT3V0cHV0cygpOwor ICAgICAgICBkaXNhYmxlT3V0cHV0c0ZvckZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2RlcygpOwor ICAgIH0KK30KKwogdm9pZCBCYXNlQXVkaW9Db250ZXh0OjptYXJrRm9yRGVsZXRpb24oQXVkaW9O b2RlJiBub2RlKQogewogICAgIEFTU0VSVChpc0dyYXBoT3duZXIoKSk7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0Jhc2VBdWRpb0NvbnRleHQuaCBiL1NvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5oCmluZGV4IDMyZmEy Y2M2OWJiZTQyMjdlZTk3YmI5NGE5NGMxMDU5ZDUwMmM0YzIuLjc1MjkxOTFiMjI1YTgwZTFkNzE1 ZGJlZDU4MWQ4N2Y2ZTMzN2Y3MzUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMv d2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5oCkBAIC0xNjAsNiArMTYwLDkgQEAgcHVibGljOgog ICAgIHZvaWQgbWFya0ZvckRlbGV0aW9uKEF1ZGlvTm9kZSYpOwogICAgIHZvaWQgZGVsZXRlTWFy a2VkTm9kZXMoKTsKIAorICAgIHZvaWQgYWRkVGFpbFByb2Nlc3NpbmdOb2RlKEF1ZGlvTm9kZSYp OworICAgIHZvaWQgcmVtb3ZlVGFpbFByb2Nlc3NpbmdOb2RlKEF1ZGlvTm9kZSYpOworCiAgICAg Ly8gQXVkaW9Db250ZXh0IGNhbiBwdWxsIG5vZGUocykgYXQgdGhlIGVuZCBvZiBlYWNoIHJlbmRl ciBxdWFudHVtIGV2ZW4gd2hlbiB0aGV5IGFyZSBub3QgY29ubmVjdGVkIHRvIGFueSBkb3duc3Ry ZWFtIG5vZGVzLgogICAgIC8vIFRoZXNlIHR3byBtZXRob2RzIGFyZSBjYWxsZWQgYnkgdGhlIG5v ZGVzIHdobyB3YW50IHRvIGFkZC9yZW1vdmUgdGhlbXNlbHZlcyBpbnRvL2Zyb20gdGhlIGF1dG9t YXRpYyBwdWxsIGxpc3RzLgogICAgIHZvaWQgYWRkQXV0b21hdGljUHVsbE5vZGUoQXVkaW9Ob2Rl Jik7CkBAIC0yODUsNiArMjg4LDkgQEAgcHJpdmF0ZToKICAgICB2b2lkIGhhbmRsZURpcnR5QXVk aW9Ob2RlT3V0cHV0cygpOwogCiAgICAgdm9pZCB1cGRhdGVBdXRvbWF0aWNQdWxsTm9kZXMoKTsK KyAgICB2b2lkIHVwZGF0ZVRhaWxQcm9jZXNzaW5nTm9kZXMoKTsKKyAgICB2b2lkIGZpbmlzaFRh aWxQcm9jZXNzaW5nKCk7CisgICAgdm9pZCBkaXNhYmxlT3V0cHV0c0ZvckZpbmlzaGVkVGFpbFBy b2Nlc3NpbmdOb2RlcygpOwogCiAjaWYgIVJFTEVBU0VfTE9HX0RJU0FCTEVECiAgICAgUmVmPExv Z2dlcj4gbV9sb2dnZXI7CkBAIC0zMDYsNiArMzEyLDM1IEBAIHByaXZhdGU6CiAgICAgLy8gKHdo ZW4gaGFuZGxlUG9zdFJlbmRlclRhc2tzKCkgaGFzIGNvbXBsZXRlZCkuCiAgICAgVmVjdG9yPEF1 ZGlvTm9kZSo+IG1fbm9kZXNNYXJrZWRGb3JEZWxldGlvbjsKIAorICAgIGNsYXNzIFRhaWxQcm9j ZXNzaW5nTm9kZSB7CisgICAgcHVibGljOgorICAgICAgICBUYWlsUHJvY2Vzc2luZ05vZGUoQXVk aW9Ob2RlJiBub2RlKQorICAgICAgICAgICAgOiBtX25vZGUoJm5vZGUpCisgICAgICAgIHsKKyAg ICAgICAgICAgIEFTU0VSVCghbm9kZS5pc1RhaWxQcm9jZXNzaW5nKCkpOworICAgICAgICAgICAg bm9kZS5zZXRJc1RhaWxQcm9jZXNzaW5nKHRydWUpOworICAgICAgICB9CisgICAgICAgIFRhaWxQ cm9jZXNzaW5nTm9kZShUYWlsUHJvY2Vzc2luZ05vZGUmJiBvdGhlcikKKyAgICAgICAgICAgIDog bV9ub2RlKHN0ZDo6ZXhjaGFuZ2Uob3RoZXIubV9ub2RlLCBudWxscHRyKSkKKyAgICAgICAgeyB9 CisgICAgICAgIH5UYWlsUHJvY2Vzc2luZ05vZGUoKQorICAgICAgICB7CisgICAgICAgICAgICBp ZiAobV9ub2RlKQorICAgICAgICAgICAgICAgIG1fbm9kZS0+c2V0SXNUYWlsUHJvY2Vzc2luZyhm YWxzZSk7CisgICAgICAgIH0KKyAgICAgICAgQXVkaW9Ob2RlKiBvcGVyYXRvci0+KCkgY29uc3Qg eyByZXR1cm4gbV9ub2RlLmdldCgpOyB9CisgICAgICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBU YWlsUHJvY2Vzc2luZ05vZGUmIG90aGVyKSBjb25zdCB7IHJldHVybiBtX25vZGUgPT0gb3RoZXIu bV9ub2RlOyB9CisgICAgICAgIGJvb2wgb3BlcmF0b3I9PShjb25zdCBBdWRpb05vZGUmIG5vZGUp IGNvbnN0IHsgcmV0dXJuIG1fbm9kZSA9PSAmbm9kZTsgfQorICAgIHByaXZhdGU6CisgICAgICAg IFJlZlB0cjxBdWRpb05vZGU+IG1fbm9kZTsKKyAgICB9OworCisgICAgLy8gTm9kZXMgdGhhdCBh cmUgY3VycmVudGx5IHByb2Nlc3NpbmcgdGhlaXIgdGFpbC4KKyAgICBWZWN0b3I8VGFpbFByb2Nl c3NpbmdOb2RlPiBtX3RhaWxQcm9jZXNzaW5nTm9kZXM7CisKKyAgICAvLyBOb2RlcyB0aGF0IGhh dmUgZmluaXNoZWQgcHJvY2Vzc2luZyB0aGVpciB0YWlsIGFuZCB3YWl0aW5nIGZvciB0aGVpciBv dXRwdXRzIHRvIGdldCBkaXNhYmxlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgVmVjdG9yPFRh aWxQcm9jZXNzaW5nTm9kZT4gbV9maW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXM7CisKICAgICAv LyBUaGV5IHdpbGwgYmUgc2NoZWR1bGVkIGZvciBkZWxldGlvbiAob24gdGhlIG1haW4gdGhyZWFk KSBhdCB0aGUgZW5kIG9mIGEgcmVuZGVyIGN5Y2xlIChpbiByZWFsdGltZSB0aHJlYWQpLgogICAg IFZlY3RvcjxBdWRpb05vZGUqPiBtX25vZGVzVG9EZWxldGU7CiAKQEAgLTM0OCw2ICszODMsNyBA QCBwcml2YXRlOgogICAgIHVuc2lnbmVkIG1fY29ubmVjdGlvbkNvdW50IHsgMCB9OwogICAgIFN0 YXRlIG1fc3RhdGUgeyBTdGF0ZTo6U3VzcGVuZGVkIH07CiAgICAgYm9vbCBtX2lzRGVsZXRpb25T Y2hlZHVsZWQgeyBmYWxzZSB9OworICAgIGJvb2wgbV9kaXNhYmxlT3V0cHV0c0ZvclRhaWxQcm9j ZXNzaW5nU2NoZWR1bGVkIHsgZmFsc2UgfTsKICAgICBib29sIG1faXNTdG9wU2NoZWR1bGVkIHsg ZmFsc2UgfTsKICAgICBib29sIG1faXNJbml0aWFsaXplZCB7IGZhbHNlIH07CiAgICAgYm9vbCBt X2lzQXVkaW9UaHJlYWRGaW5pc2hlZCB7IGZhbHNlIH07Cg== 430076 2021-05-28 17:12:03 -0700 2021-05-28 18:28:21 -0700 Patch bug-222098-20210528171202.patch text/plain 14613 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjc4MjI5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggM2ZmMjMwYjhjNGU1OGJj ZGRjNTA3MDk3MTQxNGQ2YmQyOWQ5NWNhMi4uNzkyMDNlOTdmYjk2ZjM1MDhlOWEyZGU3ZWMxNzU0 YzVhNDc0NTA0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDY0IEBACisyMDIxLTA1LTI4ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgUmVncmVzc2lvbjogUmF3IEF1 ZGlvQnVmZmVyU291cmNlTm9kZSBwbGF5YmFjayBjYXVzZXMgcmVwZWF0ZWQgY3JhY2tsaW5nIHNv dW5kCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjIw OTgKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzc0NTQ2NDcxPgorCisgICAgICAgIFJldmlld2Vk IGJ5IERhcmluIEFkbGVyLgorCisgICAgICAgIFRoZSBpc3N1ZSB3YXMgZHVlIHRvIGNlcnRhaW4g YXVkaW8gbm9kZXMgKHN1Y2ggYXMgQXVkaW9CdWZmZXJTb3VyY2VOb2RlKSBzdGF5aW5nIGluIHRo ZSBhdWRpbworICAgICAgICBncmFwaCBhZnRlciB0aGV5IHdlcmUgbm8gbG9uZ2VyIG5lZWRlZC4g QXMgYSByZXN1bHQsIHRoZSBhdWRpbyBncmFwaCB3YXMgYmVjb21pbmcgbGFyZ2VyIGFuZAorICAg ICAgICBsYXJnZXIgYW5kIHRoZSBhdWRpbyBwZXJmb3JtYW5jZSBzaG91bGQgZGVncmFkZSBkdWUg dG8gdXMgdHJhdmVyc2luZyB0aGlzIGluY3JlYXNpbmdseSBsYXJnZQorICAgICAgICBncmFwaC4K KworICAgICAgICBUaGUgYXVkaW8gbm9kZXMgdGhhdCBoYWQgdHJvdWJsZSBnZXR0aW5nIHJlbW92 ZWQgZnJvbSB0aGUgZ3JhcGhzIHdlcmUgdGFpbCBwcm9jZXNzaW5nIG5vZGVzLgorICAgICAgICBU aG9zZSBhcmUgbm9kZXMgdGhhdCBtYXkgc3RpbGwgcHJvZHVjZSBvdXRwdXQgZm9yIGEgd2hpbGUg YWZ0ZXIgdGhleSBubyBsb25nZXIgaGF2ZSBhbnkKKyAgICAgICAgaW5wdXRzLiBQYW5uZXJOb2Rl IGFuZCBEZWxheU5vZGUgYXJlIGV4YW1wbGUgb2Ygc3VjaCBub2Rlcy4KKworICAgICAgICBXaGVu IGEgTm9kZSBpcyBubyBsb25nZXIgdXNlZnVsICh0aGUgbm9kZSBubyBsb25nZXIgaGFzIGFueSBj b25uZWN0aW9ucywgbV9jb25uZWN0aW9uUmVmQ291bnQKKyAgICAgICAgaXMgMCksIHdlIGNhbGwg ZGlzYWJsZU91dHB1dHNJZk5lY2Vzc2FyeSgpIG9uIGl0IHRvIGRpc2FibGUgaXRzIG91dHB1dHMg YW5kIGF2b2lkIGRvaW5nIGFueQorICAgICAgICBwcm9jZXNzaW5nIG9mIHRoZXNlIG91dHB1dHMg c2luY2UgdGhleSBubyBsb25nZXIgaGF2ZSBhbiBpbnB1dC4gZGlzYWJsZU91dHB1dHNJZk5lY2Vz c2FyeSgpCisgICAgICAgIHdvdWxkIG5vcm1hbGx5IGNhbGwgZGlzYWJsZU91dHB1dHMoKSAoaWYg bm90IGFscmVhZHkgZGlzYWJsZWQpIGJ1dCB0aGVyZSB3YXMgYW4gZXhjZXB0aW9uCisgICAgICAg IGluIHRoZSBjYXNlIHdoZXJlIHRoZSBub2RlIHJlcXVpcmVzIHRhaWwgcHJvY2Vzc2luZy4gRm9y IHN1Y2ggbm9kZXMsIHlvdSB3b3VsZG4ndCB3YW50IHRvCisgICAgICAgIGRpc2FibGUgdGhlbSB1 bnRpbCB0aGV5J3ZlIGZpbmlzaGVkIHByb2Nlc3NpbmcgdGhlaXIgdGFpbC4KKworICAgICAgICBU aGUgaXNzdWUgd2FzIHRoYXQgb25jZSB0aG9zZSBub2RlcyBoYWQgZmluaXNoZWQgcHJvY2Vzc2lu ZyB0aGVpciB0YWlsLCB3ZSB3b3VsZG4ndCBjb21lCisgICAgICAgIGJhY2sgdG8gdGhlbSBhbmQg ZGlzYWJsZSB0aGVpciBvdXRwdXRzIGxhdGVyIG9uLiBBcyBhIHJlc3VsdCwgd2Ugd291bGQgcHJv Y2VzcyBtb3JlIGFuZAorICAgICAgICBtb3JlIChzaWxlbnQpIG5vZGVzIGFuZCB0aGUgYXVkaW8g cGVyZm9ybWFuY2Ugd291bGQgc2VyaW91c2x5IGRldGVyaW9yYXRlLgorCisgICAgICAgIFRvIGFk ZHJlc3MgdGhpcywgd2Ugbm93IGFkZCB0aGUgbm9kZSB0byB0aGUgY29udGV4dCdzIGxpc3Qgb2Yg dGFpbCBwcm9jZXNzaW5nIG5vZGVzIGluCisgICAgICAgIGRpc2FibGVPdXRwdXRzSWZOZWNlc3Nh cnkoKSBpZiB0aGUgbm9kZSByZXF1aXJlcyB0YWlsIHByb2Nlc3NpbmcuIEFmdGVyIGVhY2ggcmVu ZGVyaW5nCisgICAgICAgIHF1YW50dW0sIHdlIGdvIHRocm91Z2ggdGhvc2UgdGFpbCBwcm9jZXNz aW5nIG5vZGVzIGFuZCBjaGVjayBpZiB0aGV5IGhhdmUgZmluaXNoZWQKKyAgICAgICAgcHJvY2Vz c2luZyB0aGVpciB0YWlsLiBJZiB0aGV5IGhhdmUsIHdlIGdvIGFoZWFkIGFuZCBkaXNhYmxlIHRo ZWlyIG91dHB1dHMgYXQgdGhpcyBwb2ludAorICAgICAgICBhbmQgcmVtb3ZlIHRoZW0gZnJvbSB0 aGUgbGlzdC4KKworICAgICAgICBUaGlzIGlzIG1vZGVsZWQgYWZ0ZXIgd2hhdCBCbGluayBpcyBk b2luZyBmb3IgdGFpbCBwcm9jZXNzaW5nIG5vZGVzIGluOgorICAgICAgICAtIGh0dHBzOi8vZ2l0 aHViLmNvbS9jaHJvbWl1bS9jaHJvbWl1bS9ibG9iL21hc3Rlci90aGlyZF9wYXJ0eS9ibGluay9y ZW5kZXJlci9tb2R1bGVzL3dlYmF1ZGlvL2RlZmVycmVkX3Rhc2tfaGFuZGxlci5jYworCisgICAg ICAgIEkgaGF2ZSB2ZXJpZmllZCB0aGF0IG9uIHRoZSBmb2xsb3dpbmcgZGVtbywgdGhlIHBlcmZv cm1hbmNlIG5vIGxvbmdlciBkZXRlcmlvcmF0ZXMgYWZ0ZXIKKyAgICAgICAgYSB3aGlsZToKKyAg ICAgICAgLSBodHRwczovL2pzZmlkZGxlLm5ldC9LcmlzSm9obnNvbi9zNXZMMjRvMS8xMjMvCisK KyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5jcHA6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb05vZGU6OmVuYWJsZU91dHB1dHNJZk5lY2Vzc2FyeSk6CisgICAgICAgIChXZWJD b3JlOjpBdWRpb05vZGU6OmRpc2FibGVPdXRwdXRzSWZOZWNlc3NhcnkpOgorICAgICAgICAqIE1v ZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmg6CisgICAgICAgIChXZWJDb3JlOjpBdWRpb05vZGU6 OmlzVGFpbFByb2Nlc3NpbmcgY29uc3QpOgorICAgICAgICAoV2ViQ29yZTo6QXVkaW9Ob2RlOjpz ZXRJc1RhaWxQcm9jZXNzaW5nKToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL0Jhc2VBdWRp b0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6dW5pbml0 aWFsaXplKToKKyAgICAgICAgKFdlYkNvcmU6OkJhc2VBdWRpb0NvbnRleHQ6OmhhbmRsZVBvc3RS ZW5kZXJUYXNrcyk6CisgICAgICAgIChXZWJDb3JlOjpCYXNlQXVkaW9Db250ZXh0OjphZGRUYWls UHJvY2Vzc2luZ05vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6cmVt b3ZlVGFpbFByb2Nlc3NpbmdOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6OkJhc2VBdWRpb0NvbnRl eHQ6OnVwZGF0ZVRhaWxQcm9jZXNzaW5nTm9kZXMpOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1 ZGlvQ29udGV4dDo6ZGlzYWJsZU91dHB1dHNGb3JGaW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMp OgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6ZmluaXNoVGFpbFByb2Nlc3Np bmcpOgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5oOgorICAg ICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6VGFpbFByb2Nlc3NpbmdOb2RlOjpUYWls UHJvY2Vzc2luZ05vZGUpOgorICAgICAgICAoV2ViQ29yZTo6QmFzZUF1ZGlvQ29udGV4dDo6VGFp bFByb2Nlc3NpbmdOb2RlOjp+VGFpbFByb2Nlc3NpbmdOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6 OkJhc2VBdWRpb0NvbnRleHQ6OlRhaWxQcm9jZXNzaW5nTm9kZTo6b3BlcmF0b3ItPiBjb25zdCk6 CisgICAgICAgIChXZWJDb3JlOjpCYXNlQXVkaW9Db250ZXh0OjpUYWlsUHJvY2Vzc2luZ05vZGU6 Om9wZXJhdG9yPT0gY29uc3QpOgorCiAyMDIxLTA1LTI4ICBDaHJpcyBEdW1leiAgPGNkdW1lekBh cHBsZS5jb20+CiAKICAgICAgICAgU3RvcCB1c2luZyBVbmNoZWNrZWRMb2NrIGluIEpTRE9NR2xv YmFsT2JqZWN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1 ZGlvTm9kZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5j cHAKaW5kZXggMDYwNGY1YWM3OGZkNDc0ZDgyMTFlNDVhOWNjOTYxMmUyZTBmY2UxNS4uYjk4Zjg0 ZjY2NDZjZmE2NDZjODMwMGQ5YzY0OTQ1MzhhYzE2YzA5ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy93ZWJhdWRpby9BdWRpb05vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmNwcApAQCAtNTIxLDkgKzUyMSwxMiBAQCB2b2lk IEF1ZGlvTm9kZTo6c2lsZW5jZU91dHB1dHMoKQogCiB2b2lkIEF1ZGlvTm9kZTo6ZW5hYmxlT3V0 cHV0c0lmTmVjZXNzYXJ5KCkKIHsKKyAgICBMb2NrZXIgbG9ja2VyIHsgY29udGV4dCgpLmdyYXBo TG9jaygpIH07CisgICAgaWYgKGlzVGFpbFByb2Nlc3NpbmcoKSkKKyAgICAgICAgY29udGV4dCgp LnJlbW92ZVRhaWxQcm9jZXNzaW5nTm9kZSgqdGhpcyk7CisKICAgICBpZiAobV9pc0Rpc2FibGVk ICYmIG1fY29ubmVjdGlvblJlZkNvdW50ID4gMCkgewogICAgICAgICBBU1NFUlQoaXNNYWluVGhy ZWFkKCkpOwotICAgICAgICBMb2NrZXIgbG9ja2VyIHsgY29udGV4dCgpLmdyYXBoTG9jaygpIH07 CiAKICAgICAgICAgbV9pc0Rpc2FibGVkID0gZmFsc2U7CiAgICAgICAgIGZvciAoYXV0byYgb3V0 cHV0IDogbV9vdXRwdXRzKQpAQCAtNTQ1LDEwICs1NDgsMTEgQEAgdm9pZCBBdWRpb05vZGU6OmRp c2FibGVPdXRwdXRzSWZOZWNlc3NhcnkoKQogICAgICAgICAvLyBCdXQgaW50ZXJuYWxseSBvdXIg b3V0cHV0cyBzaG91bGQgYmUgZGlzYWJsZWQgZnJvbSB0aGUgaW5wdXRzIHRoZXkncmUgY29ubmVj dGVkIHRvLgogICAgICAgICAvLyBkaXNhYmxlKCkgY2FuIHJlY3Vyc2l2ZWx5IGRlcmVmIGNvbm5l Y3Rpb25zIChhbmQgY2FsbCBkaXNhYmxlKCkpIGRvd24gYSB3aG9sZSBjaGFpbiBvZiBjb25uZWN0 ZWQgbm9kZXMuCiAKLSAgICAgICAgLy8gSWYgYSBub2RlIHJlcXVpcmVzIHRhaWwgcHJvY2Vzc2lu Zywgd2UgZGVmZXIgdGhlIGRpc2FibGluZyBvZgotICAgICAgICAvLyB0aGUgb3V0cHV0cyBzbyB0 aGF0IHRoZSB0YWlsIGZvciB0aGUgbm9kZSBjYW4gYmUgb3V0cHV0LgorICAgICAgICAvLyBJZiBh IG5vZGUgcmVxdWlyZXMgdGFpbCBwcm9jZXNzaW5nLCB3ZSBkZWZlciB0aGUgZGlzYWJsaW5nIG9m IHRoZSBvdXRwdXRzIHNvIHRoYXQgdGhlIHRhaWwgZm9yIHRoZSBub2RlIGNhbiBiZSBvdXRwdXQu CiAgICAgICAgIC8vIE90aGVyd2lzZSwgd2UgY2FuIGRpc2FibGUgdGhlIG91dHB1dHMgcmlnaHQg YXdheS4KLSAgICAgICAgaWYgKCFyZXF1aXJlc1RhaWxQcm9jZXNzaW5nKCkpCisgICAgICAgIGlm IChyZXF1aXJlc1RhaWxQcm9jZXNzaW5nKCkpCisgICAgICAgICAgICBjb250ZXh0KCkuYWRkVGFp bFByb2Nlc3NpbmdOb2RlKCp0aGlzKTsKKyAgICAgICAgZWxzZQogICAgICAgICAgICAgZGlzYWJs ZU91dHB1dHMoKTsKICAgICB9CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL0F1ZGlvTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9B dWRpb05vZGUuaAppbmRleCAyMDU3MGE3MjE1ODc1YzRmMDdkNzI1NmMzM2ZkY2VjMmJiODM4ZDJk Li5hOGJmYWMyYTBjNmQyMWU0ZDRhMjc5NDI2NTEzYzhiOTBjNGZjZGI5IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0F1ZGlvTm9kZS5oCisrKyBiL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQXVkaW9Ob2RlLmgKQEAgLTE5MSw2ICsxOTEsMTEgQEAg cHVibGljOgogICAgIGJvb2wgaXNGaW5pc2hlZFNvdXJjZU5vZGUoKSBjb25zdCB7IHJldHVybiBt X2lzRmluaXNoZWRTb3VyY2VOb2RlOyB9CiAgICAgdm9pZCBzZXRJc0ZpbmlzaGVkU291cmNlTm9k ZSgpIHsgbV9pc0ZpbmlzaGVkU291cmNlTm9kZSA9IHRydWU7IH0KIAorICAgIC8vIEZsYWcgaW5k aWNhdGluZyB0aGUgbm9kZSBpcyBpbiB0aGUgY29udGV4dCdzIG1fdGFpbFByb2Nlc3NpbmdOb2Rl cyBvciBtX2ZpbmlzaFRhaWxQcm9jZXNzaW5nTm9kZXMuCisgICAgLy8gV2UgcmVseSBvbiB0aGlz IGZsYWcgdG8gYXZvaWQgdW5uZWNlc3NhcnkgbGluZWFyIHNlYXJjaGVzIGluIHRob3NlIHZlY3Rv cnMuCisgICAgYm9vbCBpc1RhaWxQcm9jZXNzaW5nKCkgY29uc3QgeyByZXR1cm4gbV9pc1RhaWxQ cm9jZXNzaW5nOyB9CisgICAgdm9pZCBzZXRJc1RhaWxQcm9jZXNzaW5nKGJvb2wgaXNUYWlsUHJv Y2Vzc2luZykgeyBtX2lzVGFpbFByb2Nlc3NpbmcgPSBpc1RhaWxQcm9jZXNzaW5nOyB9CisKIHBy b3RlY3RlZDoKICAgICAvLyBJbnB1dHMgYW5kIG91dHB1dHMgbXVzdCBiZSBjcmVhdGVkIGJlZm9y ZSB0aGUgQXVkaW9Ob2RlIGlzIGluaXRpYWxpemVkLgogICAgIHZvaWQgYWRkSW5wdXQoKTsKQEAg LTI1Myw2ICsyNTgsNyBAQCBwcml2YXRlOgogICAgIGJvb2wgbV9pc01hcmtlZEZvckRlbGV0aW9u IHsgZmFsc2UgfTsKICAgICBib29sIG1faXNEaXNhYmxlZCB7IGZhbHNlIH07CiAgICAgYm9vbCBt X2lzRmluaXNoZWRTb3VyY2VOb2RlIHsgZmFsc2UgfTsKKyAgICBib29sIG1faXNUYWlsUHJvY2Vz c2luZyB7IGZhbHNlIH07CiAKICNpZiBERUJVR19BVURJT05PREVfUkVGRVJFTkNFUwogICAgIHN0 YXRpYyBib29sIHNfaXNOb2RlQ291bnRJbml0aWFsaXplZDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYmF1ZGlvL0Jhc2VBdWRpb0NvbnRleHQuY3BwCmluZGV4IGUyMDJkN2Qy NjJhZDA2NDdiZGE3NmZiYTUyN2YwYTVhMTYyMWE3ODAuLjBlM2QzZjg3MWNjNjMyM2U2MDQ3MmI2 ZWVmNzZkNjNkZDljYzBmMzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2Vi YXVkaW8vQmFzZUF1ZGlvQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93 ZWJhdWRpby9CYXNlQXVkaW9Db250ZXh0LmNwcApAQCAtMTk4LDYgKzE5OCw4IEBAIHZvaWQgQmFz ZUF1ZGlvQ29udGV4dDo6dW5pbml0aWFsaXplKCkKICAgICAvLyBEb24ndCBhbGxvdyB0aGUgY29u dGV4dCB0byBpbml0aWFsaXplIGEgc2Vjb25kIHRpbWUgYWZ0ZXIgaXQncyBhbHJlYWR5IGJlZW4g ZXhwbGljaXRseSB1bmluaXRpYWxpemVkLgogICAgIG1faXNBdWRpb1RocmVhZEZpbmlzaGVkID0g dHJ1ZTsKIAorICAgIGZpbmlzaFRhaWxQcm9jZXNzaW5nKCk7CisKICAgICB7CiAgICAgICAgIExv Y2tlciBsb2NrZXIgeyBncmFwaExvY2soKSB9OwogICAgICAgICAvLyBUaGlzIHNob3VsZCBoYXZl IGJlZW4gY2FsbGVkIGZyb20gaGFuZGxlUG9zdFJlbmRlclRhc2tzKCkgYXQgdGhlIGVuZCBvZiBy ZW5kZXJpbmcuCkBAIC02MDMsNiArNjA1LDcgQEAgdm9pZCBCYXNlQXVkaW9Db250ZXh0OjpoYW5k bGVQb3N0UmVuZGVyVGFza3MoKQogICAgIGhhbmRsZURpcnR5QXVkaW9Ob2RlT3V0cHV0cygpOwog CiAgICAgdXBkYXRlQXV0b21hdGljUHVsbE5vZGVzKCk7CisgICAgdXBkYXRlVGFpbFByb2Nlc3Np bmdOb2RlcygpOwogfQogCiB2b2lkIEJhc2VBdWRpb0NvbnRleHQ6OmhhbmRsZURlZmVycmVkRGVj cmVtZW50Q29ubmVjdGlvbkNvdW50cygpCkBAIC02MTQsNiArNjE3LDkyIEBAIHZvaWQgQmFzZUF1 ZGlvQ29udGV4dDo6aGFuZGxlRGVmZXJyZWREZWNyZW1lbnRDb25uZWN0aW9uQ291bnRzKCkKICAg ICBtX2RlZmVycmVkQnJlYWtDb25uZWN0aW9uTGlzdC5jbGVhcigpOwogfQogCit2b2lkIEJhc2VB dWRpb0NvbnRleHQ6OmFkZFRhaWxQcm9jZXNzaW5nTm9kZShBdWRpb05vZGUmIG5vZGUpCit7Cisg ICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsKKyAgICBpZiAobm9kZS5pc1RhaWxQcm9jZXNzaW5n KCkpIHsKKyAgICAgICAgQVNTRVJUKG1fdGFpbFByb2Nlc3NpbmdOb2Rlcy5jb250YWlucyhub2Rl KSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvLyBJZGVhbGx5IHdlJ2QgZmluZCBh IHdheSB0byBhdm9pZCB0aGlzIHZlY3RvciBhcHBlbmQgc2luY2Ugd2UgdHJ5IHRvIGF2b2lkIHBv dGVudGlhbCBoZWFwIGFsbG9jYXRpb25zCisgICAgLy8gb24gdGhlIGF1ZGlvIHRocmVhZCBmb3Ig cGVyZm9ybWFuY2UgcmVhc29ucy4KKyAgICBEaXNhYmxlTWFsbG9jUmVzdHJpY3Rpb25zRm9yQ3Vy cmVudFRocmVhZFNjb3BlIGRpc2FibGVNYWxsb2NSZXN0cmljdGlvbnM7CisgICAgQVNTRVJUKCFt X3RhaWxQcm9jZXNzaW5nTm9kZXMuY29udGFpbnMobm9kZSkpOworICAgIG1fdGFpbFByb2Nlc3Np bmdOb2Rlcy5hcHBlbmQobm9kZSk7Cit9CisKK3ZvaWQgQmFzZUF1ZGlvQ29udGV4dDo6cmVtb3Zl VGFpbFByb2Nlc3NpbmdOb2RlKEF1ZGlvTm9kZSYgbm9kZSkKK3sKKyAgICBBU1NFUlQoaXNHcmFw aE93bmVyKCkpOworICAgIEFTU0VSVChub2RlLmlzVGFpbFByb2Nlc3NpbmcoKSk7CisKKyAgICBp ZiAobV90YWlsUHJvY2Vzc2luZ05vZGVzLnJlbW92ZUZpcnN0KG5vZGUpKQorICAgICAgICByZXR1 cm47CisKKyAgICAvLyBSZW1vdmUgdGhlIG5vZGUgZnJvbSBmaW5pc2hlZCB0YWlsIHByb2Nlc3Np bmcgbm9kZXMgc28gd2UgZG9uJ3QgZW5kIHVwIGRpc2FibGluZyBpdHMgb3V0cHV0cyBsYXRlciBv biB0aGUgbWFpbiB0aHJlYWQuCisgICAgQVNTRVJUKG1fZmluaXNoZWRUYWlsUHJvY2Vzc2luZ05v ZGVzLmNvbnRhaW5zKG5vZGUpKTsKKyAgICBtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2Rlcy5y ZW1vdmVGaXJzdChub2RlKTsKK30KKwordm9pZCBCYXNlQXVkaW9Db250ZXh0Ojp1cGRhdGVUYWls UHJvY2Vzc2luZ05vZGVzKCkKK3sKKyAgICBBU1NFUlQoaXNBdWRpb1RocmVhZCgpKTsKKyAgICBB U1NFUlQoaXNHcmFwaE93bmVyKCkpOworICAgIC8vIEdvIGJhY2t3YXJkcyBhcyB0aGUgY3VycmVu dCBub2RlIG1heSBiZSByZW1vdmVkIGZyb20gbV90YWlsUHJvY2Vzc2luZ05vZGVzIGFzIHdlIGl0 ZXJhdGUuCisgICAgLy8gV2UgYXJlIG9uIHRoZSBhdWRpbyB0aHJlYWQgc28gd2Ugd2FudCB0byBh dm9pZCBhbGxvY2F0aW9ucyBhcyBtdWNoIGFzIHBvc3NpYmxlLgorICAgIGZvciAoYXV0byBpID0g bV90YWlsUHJvY2Vzc2luZ05vZGVzLnNpemUoKTsgaSA+IDA7IC0taSkgeworICAgICAgICBhdXRv JiBub2RlID0gbV90YWlsUHJvY2Vzc2luZ05vZGVzW2kgLSAxXTsKKyAgICAgICAgaWYgKCFub2Rl LT5wcm9wYWdhdGVzU2lsZW5jZSgpKQorICAgICAgICAgICAgY29udGludWU7IC8vIE5vZGUgaXMg bm90IGRvbmUgcHJvY2Vzc2luZyBpdHMgdGFpbC4KKworICAgICAgICAvLyBJZGVhbGx5IHdlJ2Qg ZmluZCBhIHdheSB0byBhdm9pZCB0aGlzIHZlY3RvciBhcHBlbmQgc2luY2Ugd2UgdHJ5IHRvIGF2 b2lkIHBvdGVudGlhbCBoZWFwIGFsbG9jYXRpb25zCisgICAgICAgIC8vIG9uIHRoZSBhdWRpbyB0 aHJlYWQgZm9yIHBlcmZvcm1hbmNlIHJlYXNvbnMuCisgICAgICAgIERpc2FibGVNYWxsb2NSZXN0 cmljdGlvbnNGb3JDdXJyZW50VGhyZWFkU2NvcGUgZGlzYWJsZU1hbGxvY1Jlc3RyaWN0aW9uczsK KworICAgICAgICAvLyBEaXNhYmxpbmcgb2Ygb3V0cHV0cyBzaG91bGQgaGFwcGVuIG9uIHRoZSBt YWluIHRocmVhZCB3ZSBhZGQgdGhlIG5vZGUgdG8gbV9maW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9k ZXMKKyAgICAgICAgLy8gZm9yIGRpc2FibGVPdXRwdXRzRm9yRmluaXNoZWRUYWlsUHJvY2Vzc2lu Z05vZGVzKCkgdG8gcHJvY2VzcyBsYXRlciBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgICAgIEFT U0VSVCghbV9maW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMuY29udGFpbnMobm9kZSkpOworICAg ICAgICBtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2Rlcy5hcHBlbmQoV1RGTW92ZShub2RlKSk7 CisgICAgICAgIG1fdGFpbFByb2Nlc3NpbmdOb2Rlcy5yZW1vdmUoaSAtIDEpOworICAgIH0KKwor ICAgIGlmIChtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2Rlcy5pc0VtcHR5KCkgfHwgbV9kaXNh YmxlT3V0cHV0c0ZvclRhaWxQcm9jZXNzaW5nU2NoZWR1bGVkKQorICAgICAgICByZXR1cm47CisK KyAgICBtX2Rpc2FibGVPdXRwdXRzRm9yVGFpbFByb2Nlc3NpbmdTY2hlZHVsZWQgPSB0cnVlOwor CisgICAgLy8gV2UgdHJ5IHRvIGF2b2lkIGhlYXAgYWxsb2NhdGlvbnMgb24gdGhlIGF1ZGlvIHRo cmVhZCBidXQgdGhlcmUgaXMgbm8gd2F5IHRvIGRvIGEgbWFpbiB0aHJlYWQgZGlzcGF0Y2gKKyAg ICAvLyB3aXRob3V0IG9uZS4KKyAgICBEaXNhYmxlTWFsbG9jUmVzdHJpY3Rpb25zRm9yQ3VycmVu dFRocmVhZFNjb3BlIGRpc2FibGVNYWxsb2NSZXN0cmljdGlvbnM7CisgICAgY2FsbE9uTWFpblRo cmVhZChbdGhpcywgcHJvdGVjdGVkVGhpcyA9IG1ha2VSZWYoKnRoaXMpXSgpIG11dGFibGUgewor ICAgICAgICBMb2NrZXIgbG9ja2VyIHsgZ3JhcGhMb2NrKCkgfTsKKyAgICAgICAgZGlzYWJsZU91 dHB1dHNGb3JGaW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMoKTsKKyAgICAgICAgbV9kaXNhYmxl T3V0cHV0c0ZvclRhaWxQcm9jZXNzaW5nU2NoZWR1bGVkID0gZmFsc2U7CisgICAgfSk7Cit9CisK K3ZvaWQgQmFzZUF1ZGlvQ29udGV4dDo6ZGlzYWJsZU91dHB1dHNGb3JGaW5pc2hlZFRhaWxQcm9j ZXNzaW5nTm9kZXMoKQoreworICAgIEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgQVNTRVJU KGlzR3JhcGhPd25lcigpKTsKKyAgICBmb3IgKGF1dG8mIGZpbmlzaGVkVGFpbFByb2Nlc3NpbmdO b2RlIDogc3RkOjpleGNoYW5nZShtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2RlcywgeyB9KSkK KyAgICAgICAgZmluaXNoZWRUYWlsUHJvY2Vzc2luZ05vZGUtPmRpc2FibGVPdXRwdXRzKCk7Cit9 CisKK3ZvaWQgQmFzZUF1ZGlvQ29udGV4dDo6ZmluaXNoVGFpbFByb2Nlc3NpbmcoKQoreworICAg IEFTU0VSVChpc01haW5UaHJlYWQoKSk7CisgICAgTG9ja2VyIGxvY2tlciB7IGdyYXBoTG9jaygp IH07CisKKyAgICAvLyBkaXNhYmxlT3V0cHV0cygpIGNhbiBjYXVzZSBuZXcgbm9kZXMgdG8gc3Rh cnQgdGFpbCBwcm9jZXNzaW5nIHNvIHdlIG5lZWQgdG8gbG9vcCB1bnRpbCBib3RoIHZlY3RvcnMg YXJlIGVtcHR5LgorICAgIHdoaWxlICghbV90YWlsUHJvY2Vzc2luZ05vZGVzLmlzRW1wdHkoKSB8 fCAhbV9maW5pc2hlZFRhaWxQcm9jZXNzaW5nTm9kZXMuaXNFbXB0eSgpKSB7CisgICAgICAgIGZv ciAoYXV0byYgdGFpbFByb2Nlc3NpbmdOb2RlIDogc3RkOjpleGNoYW5nZShtX3RhaWxQcm9jZXNz aW5nTm9kZXMsIHsgfSkpCisgICAgICAgICAgICB0YWlsUHJvY2Vzc2luZ05vZGUtPmRpc2FibGVP dXRwdXRzKCk7CisgICAgICAgIGRpc2FibGVPdXRwdXRzRm9yRmluaXNoZWRUYWlsUHJvY2Vzc2lu Z05vZGVzKCk7CisgICAgfQorfQorCiB2b2lkIEJhc2VBdWRpb0NvbnRleHQ6Om1hcmtGb3JEZWxl dGlvbihBdWRpb05vZGUmIG5vZGUpCiB7CiAgICAgQVNTRVJUKGlzR3JhcGhPd25lcigpKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vQmFzZUF1ZGlvQ29udGV4 dC5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9CYXNlQXVkaW9Db250ZXh0LmgK aW5kZXggMzJmYTJjYzY5YmJlNDIyN2VlOTdiYjk0YTk0YzEwNTlkNTAyYzRjMi4uZjNlNjhiMWIz Y2ZmY2RlNWVlODBlYWUzZGI3ZjkyNzdiZTY4ODRiNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJhdWRpby9CYXNlQXVkaW9Db250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJhdWRpby9CYXNlQXVkaW9Db250ZXh0LmgKQEAgLTE2MCw2ICsxNjAsOSBA QCBwdWJsaWM6CiAgICAgdm9pZCBtYXJrRm9yRGVsZXRpb24oQXVkaW9Ob2RlJik7CiAgICAgdm9p ZCBkZWxldGVNYXJrZWROb2RlcygpOwogCisgICAgdm9pZCBhZGRUYWlsUHJvY2Vzc2luZ05vZGUo QXVkaW9Ob2RlJik7CisgICAgdm9pZCByZW1vdmVUYWlsUHJvY2Vzc2luZ05vZGUoQXVkaW9Ob2Rl Jik7CisKICAgICAvLyBBdWRpb0NvbnRleHQgY2FuIHB1bGwgbm9kZShzKSBhdCB0aGUgZW5kIG9m IGVhY2ggcmVuZGVyIHF1YW50dW0gZXZlbiB3aGVuIHRoZXkgYXJlIG5vdCBjb25uZWN0ZWQgdG8g YW55IGRvd25zdHJlYW0gbm9kZXMuCiAgICAgLy8gVGhlc2UgdHdvIG1ldGhvZHMgYXJlIGNhbGxl ZCBieSB0aGUgbm9kZXMgd2hvIHdhbnQgdG8gYWRkL3JlbW92ZSB0aGVtc2VsdmVzIGludG8vZnJv bSB0aGUgYXV0b21hdGljIHB1bGwgbGlzdHMuCiAgICAgdm9pZCBhZGRBdXRvbWF0aWNQdWxsTm9k ZShBdWRpb05vZGUmKTsKQEAgLTI4NSw2ICsyODgsOSBAQCBwcml2YXRlOgogICAgIHZvaWQgaGFu ZGxlRGlydHlBdWRpb05vZGVPdXRwdXRzKCk7CiAKICAgICB2b2lkIHVwZGF0ZUF1dG9tYXRpY1B1 bGxOb2RlcygpOworICAgIHZvaWQgdXBkYXRlVGFpbFByb2Nlc3NpbmdOb2RlcygpOworICAgIHZv aWQgZmluaXNoVGFpbFByb2Nlc3NpbmcoKTsKKyAgICB2b2lkIGRpc2FibGVPdXRwdXRzRm9yRmlu aXNoZWRUYWlsUHJvY2Vzc2luZ05vZGVzKCk7CiAKICNpZiAhUkVMRUFTRV9MT0dfRElTQUJMRUQK ICAgICBSZWY8TG9nZ2VyPiBtX2xvZ2dlcjsKQEAgLTMwNiw2ICszMTIsMzcgQEAgcHJpdmF0ZToK ICAgICAvLyAod2hlbiBoYW5kbGVQb3N0UmVuZGVyVGFza3MoKSBoYXMgY29tcGxldGVkKS4KICAg ICBWZWN0b3I8QXVkaW9Ob2RlKj4gbV9ub2Rlc01hcmtlZEZvckRlbGV0aW9uOwogCisgICAgY2xh c3MgVGFpbFByb2Nlc3NpbmdOb2RlIHsKKyAgICBwdWJsaWM6CisgICAgICAgIFRhaWxQcm9jZXNz aW5nTm9kZShBdWRpb05vZGUmIG5vZGUpCisgICAgICAgICAgICA6IG1fbm9kZSgmbm9kZSkKKyAg ICAgICAgeworICAgICAgICAgICAgQVNTRVJUKCFub2RlLmlzVGFpbFByb2Nlc3NpbmcoKSk7Cisg ICAgICAgICAgICBub2RlLnNldElzVGFpbFByb2Nlc3NpbmcodHJ1ZSk7CisgICAgICAgIH0KKyAg ICAgICAgVGFpbFByb2Nlc3NpbmdOb2RlKFRhaWxQcm9jZXNzaW5nTm9kZSYmIG90aGVyKQorICAg ICAgICAgICAgOiBtX25vZGUoc3RkOjpleGNoYW5nZShvdGhlci5tX25vZGUsIG51bGxwdHIpKQor ICAgICAgICB7IH0KKyAgICAgICAgflRhaWxQcm9jZXNzaW5nTm9kZSgpCisgICAgICAgIHsKKyAg ICAgICAgICAgIGlmIChtX25vZGUpCisgICAgICAgICAgICAgICAgbV9ub2RlLT5zZXRJc1RhaWxQ cm9jZXNzaW5nKGZhbHNlKTsKKyAgICAgICAgfQorICAgICAgICBUYWlsUHJvY2Vzc2luZ05vZGUm IG9wZXJhdG9yPShjb25zdCBUYWlsUHJvY2Vzc2luZ05vZGUmKSA9IGRlbGV0ZTsKKyAgICAgICAg VGFpbFByb2Nlc3NpbmdOb2RlJiBvcGVyYXRvcj0oVGFpbFByb2Nlc3NpbmdOb2RlJiYpID0gZGVs ZXRlOworICAgICAgICBBdWRpb05vZGUqIG9wZXJhdG9yLT4oKSBjb25zdCB7IHJldHVybiBtX25v ZGUuZ2V0KCk7IH0KKyAgICAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFRhaWxQcm9jZXNzaW5n Tm9kZSYgb3RoZXIpIGNvbnN0IHsgcmV0dXJuIG1fbm9kZSA9PSBvdGhlci5tX25vZGU7IH0KKyAg ICAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IEF1ZGlvTm9kZSYgbm9kZSkgY29uc3QgeyByZXR1 cm4gbV9ub2RlID09ICZub2RlOyB9CisgICAgcHJpdmF0ZToKKyAgICAgICAgUmVmUHRyPEF1ZGlv Tm9kZT4gbV9ub2RlOworICAgIH07CisKKyAgICAvLyBOb2RlcyB0aGF0IGFyZSBjdXJyZW50bHkg cHJvY2Vzc2luZyB0aGVpciB0YWlsLgorICAgIFZlY3RvcjxUYWlsUHJvY2Vzc2luZ05vZGU+IG1f dGFpbFByb2Nlc3NpbmdOb2RlczsKKworICAgIC8vIE5vZGVzIHRoYXQgaGF2ZSBmaW5pc2hlZCBw cm9jZXNzaW5nIHRoZWlyIHRhaWwgYW5kIHdhaXRpbmcgZm9yIHRoZWlyIG91dHB1dHMgdG8gZ2V0 IGRpc2FibGVkIG9uIHRoZSBtYWluIHRocmVhZC4KKyAgICBWZWN0b3I8VGFpbFByb2Nlc3NpbmdO b2RlPiBtX2ZpbmlzaGVkVGFpbFByb2Nlc3NpbmdOb2RlczsKKwogICAgIC8vIFRoZXkgd2lsbCBi ZSBzY2hlZHVsZWQgZm9yIGRlbGV0aW9uIChvbiB0aGUgbWFpbiB0aHJlYWQpIGF0IHRoZSBlbmQg b2YgYSByZW5kZXIgY3ljbGUgKGluIHJlYWx0aW1lIHRocmVhZCkuCiAgICAgVmVjdG9yPEF1ZGlv Tm9kZSo+IG1fbm9kZXNUb0RlbGV0ZTsKIApAQCAtMzQ4LDYgKzM4NSw3IEBAIHByaXZhdGU6CiAg ICAgdW5zaWduZWQgbV9jb25uZWN0aW9uQ291bnQgeyAwIH07CiAgICAgU3RhdGUgbV9zdGF0ZSB7 IFN0YXRlOjpTdXNwZW5kZWQgfTsKICAgICBib29sIG1faXNEZWxldGlvblNjaGVkdWxlZCB7IGZh bHNlIH07CisgICAgYm9vbCBtX2Rpc2FibGVPdXRwdXRzRm9yVGFpbFByb2Nlc3NpbmdTY2hlZHVs ZWQgeyBmYWxzZSB9OwogICAgIGJvb2wgbV9pc1N0b3BTY2hlZHVsZWQgeyBmYWxzZSB9OwogICAg IGJvb2wgbV9pc0luaXRpYWxpemVkIHsgZmFsc2UgfTsKICAgICBib29sIG1faXNBdWRpb1RocmVh ZEZpbmlzaGVkIHsgZmFsc2UgfTsK