99647 2012-10-17 15:39:04 -0700 HTMLMediaPlayer should free m_player when src is set/changed 2013-04-08 11:28:10 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 101010 1 fischman fischman dglazkov eric.carlson feature-media-reviews fischman isherman webkit.review.bot oldest_to_newest 744713 0 fischman 2012-10-17 15:39:04 -0700 HTMLMediaPlayer should free m_player on error. 744715 1 169278 fischman 2012-10-17 15:41:24 -0700 Created attachment 169278 Patch 744727 2 fischman 2012-10-17 15:52:28 -0700 FTR, this issue was raised in http://crbug.com/154546 (because chrome enjoys spawning several threads per MediaPlayer, making delaying their teardown an expensive proposition). 744849 3 169278 webkit.review.bot 2012-10-17 17:42:02 -0700 Comment on attachment 169278 Patch Attachment 169278 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/14395756 New failing tests: compositing/geometry/limit-layer-bounds-transformed.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-clipping-ancestor.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-positioned.html compositing/geometry/limit-layer-bounds-clipping-ancestor.html compositing/geometry/limit-layer-bounds-fixed-positioned.html compositing/geometry/limit-layer-bounds-positioned.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-fixed-positioned.html compositing/geometry/limit-layer-bounds-transformed-overflow.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-overflow-root.html compositing/geometry/limit-layer-bounds-positioned-transition.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-transformed.html platform/chromium/virtual/softwarecompositing/layer-creation/scroll-partial-update.html compositing/geometry/limit-layer-bounds-overflow-root.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-positioned-transition.html platform/chromium/virtual/softwarecompositing/geometry/limit-layer-bounds-transformed-overflow.html compositing/layer-creation/scroll-partial-update.html 744850 4 169278 fischman 2012-10-17 17:43:15 -0700 Comment on attachment 169278 Patch (bot failures are clearly unrelated) 744865 5 169278 eric.carlson 2012-10-17 17:53:57 -0700 Comment on attachment 169278 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=169278&action=review > Source/WebCore/html/HTMLMediaElement.cpp:4324 > + if (event->type() == eventNames().errorEvent) > + m_player = nullptr; An error event doesn't mean that the media player doesn't have any valid data, eg. losing the connection to the server will fire an error event with some media engines. This will change will *always* delete the media player and lose all state. 744904 6 fischman 2012-10-17 19:22:17 -0700 (In reply to comment #5) > (From update of attachment 169278 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=169278&action=review > > > Source/WebCore/html/HTMLMediaElement.cpp:4324 > > + if (event->type() == eventNames().errorEvent) > > + m_player = nullptr; > > An error event doesn't mean that the media player doesn't have any valid data, eg. losing the connection to the server will fire an error event with some media engines. This will change will *always* delete the media player and lose all state. I see. Do you have any suggestions for where the right place to put this is? (the goal, other than "real" error handling, is to be able to know that setting mediaElement.src="" in JS means resources held by any previously-playing engine underlying mediaElement have been released). 744914 7 eric.carlson 2012-10-17 19:36:20 -0700 (In reply to comment #6) > > I see. Do you have any suggestions for where the right place to put this is? > (the goal, other than "real" error handling, is to be able to know that setting mediaElement.src="" in JS means resources held by any previously-playing engine underlying mediaElement have been released). Only clearing it when m_readyState < HAVE_METADATA should be safe, except that when ENABLE(PLUGIN_PROXY_FOR_VIDEO) is defined you should *never* delete it. You might also try clearing it in HTMLMediaElement::parseAttribute when when the src attribute is set to "", but please check the spec first to see if it has anything specific to say about what to do in that situation. 745002 8 fischman 2012-10-17 23:12:20 -0700 (In reply to comment #7) > Only clearing it when m_readyState < HAVE_METADATA should be safe, except that when ENABLE(PLUGIN_PROXY_FOR_VIDEO) is defined you should *never* delete it. That doesn't work for me, because in the case I'm concerned with m_readyState==4. Reading the spec, ISTM setting src invokes the resource load algorithm, which among other things resets readyState to HAVE_NOTHING, dismisses pending callbacks and algorithms, and generally starts from a clean slate. What am I missing that says already-downloaded state should be preserved? In fact, looking at the code a bit closer, it seems prepareForLoad() already does all this cleanup, but it is being stymied by the second clause in this test: if ((loadType & MediaResource) && !(m_pendingLoadFlags & MediaResource)) { in scheduleLoad(). Commenting out the !(m_pendingLoadFlags & MediaResource) part makes the problem go away (even without the explicit clearing of m_player). Do you know what that part is doing? > You might also try clearing it in HTMLMediaElement::parseAttribute when when the src attribute is set to "", but please check the spec first to see if it has anything specific to say about what to do in that situation. It doesn't say anything about the empty string specifically, but this triggering on parseAttribute seems strange, considering the prepareForLoad() business already seems to implement the verbiage I want to rely on from the spec. 745245 9 eric.carlson 2012-10-18 07:38:01 -0700 (In reply to comment #8) > (In reply to comment #7) > > Only clearing it when m_readyState < HAVE_METADATA should be safe, except that when ENABLE(PLUGIN_PROXY_FOR_VIDEO) is defined you should *never* delete it. > > That doesn't work for me, because in the case I'm concerned with m_readyState==4. What causes the error event to be fired when readyState is HAVE_ENOUGH_DATA? > Reading the spec, ISTM setting src invokes the resource load algorithm, which among other things resets readyState to HAVE_NOTHING, dismisses pending callbacks and algorithms, and generally starts from a clean slate. What am I missing that says already-downloaded state should be preserved? > I don't know that the spec says already downloaded state should be preserved, but it seems common sense to me. For example, I think a user would be very surprised if all media data was purged because the connection to the server was lost after downloading most of a file. > In fact, looking at the code a bit closer, it seems prepareForLoad() already does all this cleanup, but it is being stymied by the second clause in this test: > if ((loadType & MediaResource) && !(m_pendingLoadFlags & MediaResource)) { > in scheduleLoad(). Commenting out the !(m_pendingLoadFlags & MediaResource) part makes the problem go away (even without the explicit clearing of m_player). > Do you know what that part is doing? > scheduleLoad is called to set up loading of the media resource and text track(s) so m_pendingLoadFlags keeps track of which load has already been scheduled so we don't, e.g. set up to load the media resource and then do it again when we see that there are text tracks to load. It is also necessary to allow us to iterate through candidate <source> elements without resetting the state machine each time. m_pendingLoadFlags is cleared in loadTimerFired, so it *should* allow prepareForLoad to be called again when src changes. What prevents it? > > You might also try clearing it in HTMLMediaElement::parseAttribute when when the src attribute is set to "", but please check the spec first to see if it has anything specific to say about what to do in that situation. > > It doesn't say anything about the empty string specifically, but this triggering on parseAttribute seems strange, considering the prepareForLoad() business already seems to implement the verbiage I want to rely on from the spec. Looking at the code I see that parseAttribute already calls prepareForLoad when src is set to "" so my suggestion should be unnecessary. 745400 10 fischman 2012-10-18 11:13:28 -0700 (In reply to comment #9) > (In reply to comment #8) > > (In reply to comment #7) > > > Only clearing it when m_readyState < HAVE_METADATA should be safe, except that when ENABLE(PLUGIN_PROXY_FOR_VIDEO) is defined you should *never* delete it. > > That doesn't work for me, because in the case I'm concerned with m_readyState==4. > What causes the error event to be fired when readyState is HAVE_ENOUGH_DATA? I'm not sure what you're asking, but you can easily repro by dropping this in ManualTests/: <html> <head> <script> var v; function handleCanplay() { v.src = ""; } function go() { v = document.createElement('video'); v.addEventListener('canplay', handleCanplay); v.controls = "controls"; v.src = "../LayoutTests/media/content/test-25fps.mp4"; v.load(); document.body.appendChild(v); } </script> </head> <body onload="go()"> </body> </html> > > In fact, looking at the code a bit closer, it seems prepareForLoad() already does all this cleanup, but it is being stymied by the second clause in this test: > > if ((loadType & MediaResource) && !(m_pendingLoadFlags & MediaResource)) { > > in scheduleLoad(). Commenting out the !(m_pendingLoadFlags & MediaResource) part makes the problem go away (even without the explicit clearing of m_player). > > Do you know what that part is doing? > > > scheduleLoad is called to set up loading of the media resource and text track(s) so m_pendingLoadFlags keeps track of which load has already been scheduled so we don't, e.g. set up to load the media resource and then do it again when we see that there are text tracks to load. It is also necessary to allow us to iterate through candidate <source> elements without resetting the state machine each time. Hmm. Sounds like m_pLF needs to be cleared earlier, but I'm not sure where. > m_pendingLoadFlags is cleared in loadTimerFired, so it *should* allow prepareForLoad to be called again when src changes. What prevents it? I'm not sure what the intended timing is, but the above test case emits this sequence of logs (with a bit of extra LOGging added, but no logic changes from ToT): HTMLMediaElement::scheduleLoad HTMLMediaElement::prepareForLoad AMI: m_player being written; currently: (nil) HTMLMediaElement::setShouldDelayLoadEvent(true) HTMLMediaElement::prepareForLoad AMI: m_player being written; currently: 0x7f206dbbea20 HTMLMediaElement::setReadyState(0) - current state is 0, HTMLMediaElement::setReadyState(1) - current state is 0, HTMLMediaElement::setReadyState(4) - current state is 1, HTMLMediaElement::setShouldDelayLoadEvent(false) HTMLMediaElement::scheduleLoad AMI: HTMLMediaElement::loadTimerFired() HTMLMediaElement::setShouldDelayLoadEvent(true) HTMLMediaElement::setShouldDelayLoadEvent(false) AMI: loadTimerFired clearing m_pendingLoadFlags, which was: 1 I think you're saying you expect loadTimerFired to be fired before the second scheduleLoad(), so m_pLF should be 0 by the time that second scheduleLoad fires? > > > You might also try clearing it in HTMLMediaElement::parseAttribute when when the src attribute is set to "", but please check the spec first to see if it has anything specific to say about what to do in that situation. > > It doesn't say anything about the empty string specifically, but this triggering on parseAttribute seems strange, considering the prepareForLoad() business already seems to implement the verbiage I want to rely on from the spec. > Looking at the code I see that parseAttribute already calls prepareForLoad when src is set to "" so my suggestion should be unnecessary. I'm not seeing that; what I see is selectMediaResource() handling src="" specially, but not how that leads to prepareForLoad. 756647 11 fischman 2012-11-01 14:56:50 -0700 Eric, I went back to the spec and ISTM it says any set/change of the src attribute should drop all state from any previously-playing source: 4.8.10.2 says "If a src attribute of a media element is set or changed, the user agent must invoke the media element's media element load algorithm" 4.8.10.5 (step 8) says "Playback of any previously playing media resource for this element stops." Coupled with step 4 of the load algo I read this to mean discard any buffered data from a previous value of src. Given that, WDYT of simply adding dropping the player when src is set in parseAttribute? Uploading a patch that does this for discussion. 756649 12 171940 fischman 2012-11-01 14:59:12 -0700 Created attachment 171940 Patch 756663 13 171940 eric.carlson 2012-11-01 15:11:03 -0700 Comment on attachment 171940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=171940&action=review Thanks for keeping at this! > Source/WebCore/html/HTMLMediaElement.cpp:374 > + m_loadTimer.stop(); > + m_progressEventTimer.stop(); > + m_playbackProgressTimer.stop(); > + m_pendingLoadFlags &= ~MediaResource; > + m_loadState = WaitingForSource; > +#if !ENABLE(PLUGIN_PROXY_FOR_VIDEO) > + m_player.clear(); > +#endif We do all of these in HTMLMediaElement::userCancelledLoad, although m_pendingLoadFlags is set to 0. It would be nice to have both use a shared function that took a flags mask. 756676 14 171940 fischman 2012-11-01 15:20:04 -0700 Comment on attachment 171940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=171940&action=review >> Source/WebCore/html/HTMLMediaElement.cpp:374 >> +#endif > > We do all of these in HTMLMediaElement::userCancelledLoad, although m_pendingLoadFlags is set to 0. It would be nice to have both use a shared function that took a flags mask. Yeah, I thought about it, but wasn't sure about it. clearMediaLoadingState() ? Given that I only need to clear MediaResource from m_pLF (setting it to 0 here is wrong) and given uCL is already using a helper for stopping 2 of the timers (but not the third) I opted for explicitness and to leave unification to a pass that understands how these things are supposed to be related. If that's ok w/ you, please CQ+. If you want me to make a unification pass as part of this CL, let me know and I'll take a crack at it. 756688 15 171940 eric.carlson 2012-11-01 15:39:43 -0700 Comment on attachment 171940 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=171940&action=review >>> Source/WebCore/html/HTMLMediaElement.cpp:374 >>> +#endif >> >> We do all of these in HTMLMediaElement::userCancelledLoad, although m_pendingLoadFlags is set to 0. It would be nice to have both use a shared function that took a flags mask. > > Yeah, I thought about it, but wasn't sure about it. > clearMediaLoadingState() ? > Given that I only need to clear MediaResource from m_pLF (setting it to 0 here is wrong) and given uCL is already using a helper for stopping 2 of the timers (but not the third) I opted for explicitness and to leave unification to a pass that understands how these things are supposed to be related. > > If that's ok w/ you, please CQ+. > If you want me to make a unification pass as part of this CL, let me know and I'll take a crack at it. I think we might as well do it now, there is enough "fix this later" crud in HTMLMediaElement already :-) Something like this should work: void HTMLMediaElement::clearMediaPlayer(unsigned flags) { #if !ENABLE(PLUGIN_PROXY_FOR_VIDEO) m_player.clear(); #endif stopPeriodicTimers(); m_loadTimer.stop(); m_pendingLoadFlags &= ~flags; m_loadState = WaitingForSource; } 756694 16 171946 fischman 2012-11-01 15:49:13 -0700 Created attachment 171946 Patch 756696 17 fischman 2012-11-01 15:49:55 -0700 (In reply to comment #15) > I think we might as well do it now, there is enough "fix this later" crud in HTMLMediaElement already :-) Mmm :) > Something like this should work: > void HTMLMediaElement::clearMediaPlayer(unsigned flags) It requires a -1 trick, but done. 756697 18 171946 eric.carlson 2012-11-01 15:56:24 -0700 Comment on attachment 171946 Patch Thank you! 756799 19 171946 buildbot 2012-11-01 18:37:56 -0700 Comment on attachment 171946 Patch Attachment 171946 did not pass win-ews (win): Output: http://queues.webkit.org/results/14687664 756800 20 171946 webkit.review.bot 2012-11-01 18:38:51 -0700 Comment on attachment 171946 Patch Clearing flags on attachment: 171946 Committed r133252: <http://trac.webkit.org/changeset/133252> 756801 21 webkit.review.bot 2012-11-01 18:38:55 -0700 All reviewed patches have been landed. Closing bug. 756841 22 webkit.review.bot 2012-11-01 19:38:07 -0700 Re-opened since this is blocked by bug 101010 870968 23 fischman 2013-04-08 11:28:10 -0700 (the threatened rollout for which this bug was reopened was replaced with a forward-fix, so this was never reverted) 169278 2012-10-17 15:41:24 -0700 2012-11-01 14:59:10 -0700 Patch bug-99647-20121017154010.patch text/plain 3583 fischman U3VidmVyc2lvbiBSZXZpc2lvbjogMTMxNTc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjhkNmY1MjFlZTgzODI3 MzdmZWRlYjk4YTRmNWYxZmRiZDhhYzBmOS4uODNkMTE1MjBjY2QxYWY3M2VkZGM4ZjRmNGUzNDQx NjFhYWQwM2I0OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTEwLTE3ICBBbWkg RmlzY2htYW4gIDxmaXNjaG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgSFRNTE1lZGlhUGxh eWVyIHNob3VsZCBmcmVlIG1fcGxheWVyIG9uIGVycm9yLgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTk2NDcKKworICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKworICAgICAgICBOZXcgTWFudWFsVGVzdCBhZGRlZDsgbWFudWFsIHNp bmNlIGxlYWtpbmcgbWVkaWEgcGxheWVycyBkb2Vzbid0IGhhdmUgbGF5b3V0VGVzdENvbnRyb2xs ZXItdmlzaWJsZSBlZmZlY3RzLgorCisgICAgICAgICogaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxNZWRpYUVsZW1lbnQ6OmRpc3BhdGNoRXZlbnQpOgor CiAyMDEyLTEwLTE3ICBQYXRyaWNrIEdhbnN0ZXJlciAgPHBhcm9nYUB3ZWJraXQub3JnPgogCiAg ICAgICAgIEJ1aWxkIGZpeCBmb3IgV2luQ0UgYWZ0ZXIgcjEzMTM2NS4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxNZWRpYUVsZW1lbnQuY3BwCmluZGV4IGViZWVlMWI0MDU4MGQyYmVlODc2NTQ0Y2My OGE5YjU4ZTUxZjY1ODkuLmIzODQ0ZTE5NDIyZDk2ZmMyZTBjMTdlMjAzZTJhOWU4MzJiYWUxYWUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcApAQCAtNDMyMCw2ICs0 MzIwLDkgQEAgYm9vbCBIVE1MTWVkaWFFbGVtZW50OjpkaXNwYXRjaEV2ZW50KFBhc3NSZWZQdHI8 RXZlbnQ+IGV2ZW50KQogICAgIGlmIChpc0NhblBsYXlFdmVudCkKICAgICAgICAgbV9kaXNwYXRj aGluZ0NhblBsYXlFdmVudCA9IHRydWU7CiAKKyAgICBpZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVu dE5hbWVzKCkuZXJyb3JFdmVudCkKKyAgICAgICAgbV9wbGF5ZXIgPSBudWxscHRyOworCiAgICAg ZGlzcGF0Y2hSZXN1bHQgPSBIVE1MRWxlbWVudDo6ZGlzcGF0Y2hFdmVudChldmVudCk7CiAKICAg ICBpZiAoaXNDYW5QbGF5RXZlbnQpCmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cgYi9DaGFuZ2VMb2cK aW5kZXggODM4NjYwZjYzZTVmYTkyODI4ODE5MDE2MDJlYTY3M2YyMDhkMGQ3NS4uYjA4YTcyNTM2 MzU2YzZmYWY0YWM3ZWFjNmQzMTM3ODY0MmEzNWNmNyAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisr KyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEyLTEwLTE3ICBBbWkgRmlzY2htYW4g IDxmaXNjaG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgSFRNTE1lZGlhUGxheWVyIHNob3Vs ZCBmcmVlIG1fcGxheWVyIG9uIGVycm9yLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9OTk2NDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIE1hbnVhbFRlc3RzL21lZGlhLXBsYXllcnMtYXJlLWRyb3BwZWQt b24tZXJyb3IuaHRtbDogQWRkZWQuCisgICAgICAgICAgICBWYXJpb3VzIHNjZW5hcmlvcyBhcmUg dGVzdGVkIHRvIG1ha2Ugc3VyZSBwbGF5ZXJzIGFyZW4ndAorICAgICAgICAgICAgbGVha2VkIGlu IGRpZmZlcmVudCB3YXlzIGZvciBlYWNoIG9mIHRoZW0uCisKIDIwMTItMTAtMTYgIFBhYmxvIEZs b3VyZXQgIDxwYWJsb2ZAbW90b3JvbGEuY29tPgogCiAgICAgICAgIFByZS1wcm9jZXNzIENTU0dy YW1tYXIueSBiZWZvcmUgcnVubmluZyB0aHJvdWdoIGJpc29uLgpkaWZmIC0tZ2l0IGEvTWFudWFs VGVzdHMvbWVkaWEtcGxheWVycy1hcmUtZHJvcHBlZC1vbi1lcnJvci5odG1sIGIvTWFudWFsVGVz dHMvbWVkaWEtcGxheWVycy1hcmUtZHJvcHBlZC1vbi1lcnJvci5odG1sCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA1 NTUxZDE1OTJiOWQ2ZjAxNjhjMDU1NTFhY2Q0MjM5MjExYTUyMDkKLS0tIC9kZXYvbnVsbAorKysg Yi9NYW51YWxUZXN0cy9tZWRpYS1wbGF5ZXJzLWFyZS1kcm9wcGVkLW9uLWVycm9yLmh0bWwKQEAg LTAsMCArMSw0MCBAQAorPGh0bWw+Cis8aGVhZD4KKzxzY3JpcHQ+Cit2YXIgdXJscyA9IFsKKyAg ICAiZmlsZTovLy9kb2VzIG5vdCBleGlzdCBvaCBub2VzL3Rlc3QubXA0IiwKKyAgICAiLi4vTGF5 b3V0VGVzdHMvbWVkaWEvY29udGVudC90ZXN0LTI1ZnBzLm1wNCIKK107Cit2YXIga2lja29mZkZ1 bmN0aW9ucyA9IFsKKyAgICAibG9hZCIsCisgICAgInBsYXkiCitdOworCit2YXIgbWVkaWFFbGVt ZW50SG9sZGVyID0gW107CisKK2Z1bmN0aW9uIHJlbGVhc2VBbmRBZGRNZWRpYUVsZW1lbnRzKCkg eworICAgIGZvciAodmFyIGkgPSAwOyBpIDwgbWVkaWFFbGVtZW50SG9sZGVyLmxlbmd0aDsgKytp KQorICAgICAgICBtZWRpYUVsZW1lbnRIb2xkZXJbaV0uc3JjID0gIiI7CisgICAgbWVkaWFFbGVt ZW50SG9sZGVyID0gW107CisKKyAgICBmb3IgKHZhciBpID0gMDsgaSA8IDU7ICsraSkgeworICAg ICAgICBmb3IgKHZhciB1cmwgaW4gdXJscykgeworICAgICAgICAgICAgZm9yICh2YXIga2lja29m ZkZ1bmN0aW9uIGluIGtpY2tvZmZGdW5jdGlvbnMpIHsKKyAgICAgICAgICAgICAgICB2YXIgYSA9 IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3ZpZGVvJyk7CisgICAgICAgICAgICAgICAgYS5jb250 cm9scyA9ICJjb250cm9scyI7CisgICAgICAgICAgICAgICAgYS5zcmMgPSB1cmxzW3VybF07Cisg ICAgICAgICAgICAgICAgZXZhbCgiYS4iICsga2lja29mZkZ1bmN0aW9uc1traWNrb2ZmRnVuY3Rp b25dICsgIigpOyIpOworICAgICAgICAgICAgICAgIG1lZGlhRWxlbWVudEhvbGRlci5wdXNoKGEp OworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQorfQorPC9zY3JpcHQ+Cis8L2hlYWQ+ Cis8Ym9keSBvbmxvYWQ9InNldEludGVydmFsKCdyZWxlYXNlQW5kQWRkTWVkaWFFbGVtZW50cygp JywgMTAwKSI+CisgICAgVGVzdCB0aGF0IG1lZGlhIHBsYXllcnMgYXJlbid0IGxlYWtlZCBvbiBl cnJvci4KKyAgICBMb2FkIHRoaXMgcGFnZSBhbmQgdmVyaWZ5IHRoZSBudW1iZXIgb2YgdGhyZWFk cyB1c2VkIGJ5IHRoZSBicm93c2VyIGRvZXNuJ3QKKyAgICBzZWVtIHVucmVhc29uYWJsZSAoZS5n LiBjaHJvbWUgdXNlcyA0LTUgdGhyZWFkcyBwZXIgdmlkZW8gdGFnIHNvIHN0YXlpbmcKKyAgICB1 bmRlciA4MCB0aHJlYWRzIGlzICJzdWNjZXNzIikuCis8L2JvZHk+Cis8L2h0bWw+Cg== 171940 2012-11-01 14:59:12 -0700 2012-11-01 15:49:11 -0700 Patch bug-99647-20121101145733.patch text/plain 4393 fischman U3VidmVyc2lvbiBSZXZpc2lvbjogMTMzMTQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWY5MjIwNjhjNjA2NWVh MGVmOGRjOGYwZjk1Njg5OWZmZDg4YmY3Yy4uNWRlYmRmY2E5MmNhYzJkODVhZmVhYmFjMDNjNzEx NmQ1MjdjNjM0MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTExLTAxICBBbWkg RmlzY2htYW4gIDxmaXNjaG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgSFRNTE1lZGlhUGxh eWVyIHNob3VsZCBmcmVlIG1fcGxheWVyIHdoZW4gc3JjIGlzIHNldC9jaGFuZ2VkCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05OTY0NworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIE5ldyBNYW51YWxUZXN0IGFk ZGVkOyBtYW51YWwgc2luY2UgbGVha2luZyBtZWRpYSBwbGF5ZXJzIGRvZXNuJ3QgaGF2ZSBsYXlv dXRUZXN0Q29udHJvbGxlci12aXNpYmxlIGVmZmVjdHMuCisKKyAgICAgICAgKiBodG1sL0hUTUxN ZWRpYUVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SFRNTE1lZGlhRWxlbWVudDo6cGFy c2VBdHRyaWJ1dGUpOiBjbGVhciBtX3BsYXllciB3aGVuIHNyYyBpcyBzZXQvY2hhbmdlZC4KKwog MjAxMi0xMS0wMSAgS2lob25nIEt3b24gIDxraWhvbmcua3dvbkBzYW1zdW5nLmNvbT4KIAogICAg ICAgICBBZGQgRGV2aWNlQ29udHJvbGxlciBiYXNlLWNsYXNzIHRvIHJlbW92ZSBkdXBsaWNhdGlv biBvZiBEZXZpY2VYWFhDb250cm9sZXIKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwv SFRNTE1lZGlhRWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxNZWRpYUVsZW1l bnQuY3BwCmluZGV4IGU5Y2QxYWZmYzllNjYxZDk4ZTRlNjRkOTc2NDRhOWExMWJmYmQ0MTEuLjg3 ZjI3NDA5YzlkNWJmOWE4OWM5MDEzZjQyZTliM2FjNWZkYjY0ODUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcApAQCAtMzYzLDggKzM2MywxNyBAQCB2b2lkIEhUTUxN ZWRpYUVsZW1lbnQ6OnBhcnNlQXR0cmlidXRlKGNvbnN0IEF0dHJpYnV0ZSYgYXR0cmlidXRlKQog ewogICAgIGlmIChhdHRyaWJ1dGUubmFtZSgpID09IHNyY0F0dHIpIHsKICAgICAgICAgLy8gVHJp Z2dlciBhIHJlbG9hZCwgYXMgbG9uZyBhcyB0aGUgJ3NyYycgYXR0cmlidXRlIGlzIHByZXNlbnQu Ci0gICAgICAgIGlmIChmYXN0SGFzQXR0cmlidXRlKHNyY0F0dHIpKQorICAgICAgICBpZiAoZmFz dEhhc0F0dHJpYnV0ZShzcmNBdHRyKSkgeworICAgICAgICAgICAgbV9sb2FkVGltZXIuc3RvcCgp OworICAgICAgICAgICAgbV9wcm9ncmVzc0V2ZW50VGltZXIuc3RvcCgpOworICAgICAgICAgICAg bV9wbGF5YmFja1Byb2dyZXNzVGltZXIuc3RvcCgpOworICAgICAgICAgICAgbV9wZW5kaW5nTG9h ZEZsYWdzICY9IH5NZWRpYVJlc291cmNlOworICAgICAgICAgICAgbV9sb2FkU3RhdGUgPSBXYWl0 aW5nRm9yU291cmNlOworI2lmICFFTkFCTEUoUExVR0lOX1BST1hZX0ZPUl9WSURFTykKKyAgICAg ICAgICAgIG1fcGxheWVyLmNsZWFyKCk7CisjZW5kaWYKICAgICAgICAgICAgIHNjaGVkdWxlTG9h ZChNZWRpYVJlc291cmNlKTsKKyAgICAgICAgfQogICAgIH0gZWxzZSBpZiAoYXR0cmlidXRlLm5h bWUoKSA9PSBjb250cm9sc0F0dHIpCiAgICAgICAgIGNvbmZpZ3VyZU1lZGlhQ29udHJvbHMoKTsK ICNpZiBQTEFURk9STShNQUMpCkBAIC00MjYzLDcgKzQyNzIsNyBAQCB2b2lkIEhUTUxNZWRpYUVs ZW1lbnQ6OmNyZWF0ZU1lZGlhUGxheWVyKCkKICAgICBpZiAobV9hdWRpb1NvdXJjZU5vZGUpCiAg ICAgICAgIG1fYXVkaW9Tb3VyY2VOb2RlLT5sb2NrKCk7CiAjZW5kaWYKLSAgICAgICAgCisKICAg ICBtX3BsYXllciA9IE1lZGlhUGxheWVyOjpjcmVhdGUodGhpcyk7CiAKICNpZiBFTkFCTEUoTUVE SUFfU09VUkNFKQpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IDQ1ODNj MjFmZjljMDY5YTFjMGMwZWRmNTExYzUxMTk0MGUzYzA3YTEuLjUyZTc0NTFmZjBkYTQ1YzU5YjZh MGE1ODNhNmEwMTcxOTE2MTZmOTYgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VM b2cKQEAgLTEsMyArMSwxNCBAQAorMjAxMi0xMS0wMSAgQW1pIEZpc2NobWFuICA8ZmlzY2htYW5A Y2hyb21pdW0ub3JnPgorCisgICAgICAgIEhUTUxNZWRpYVBsYXllciBzaG91bGQgZnJlZSBtX3Bs YXllciB3aGVuIHNyYyBpcyBzZXQvY2hhbmdlZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9OTk2NDcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICAqIE1hbnVhbFRlc3RzL21lZGlhLXBsYXllcnMtYXJlLWRyb3Bw ZWQtb24tZXJyb3IuaHRtbDogQWRkZWQuCisgICAgICAgICAgICBWYXJpb3VzIHNjZW5hcmlvcyBh cmUgdGVzdGVkIHRvIG1ha2Ugc3VyZSBwbGF5ZXJzIGFyZW4ndAorICAgICAgICAgICAgbGVha2Vk IGluIGRpZmZlcmVudCB3YXlzIGZvciBlYWNoIG9mIHRoZW0uCisKIDIwMTItMTAtMzEgIFRoaWFn byBNYXJjb3MgUC4gU2FudG9zICA8dGhpYWdvLnNhbnRvc0BpbnRlbC5jb20+CiAKICAgICAgICAg QWRkZWQgdmlld3BvcnQgYXQtcnVsZSB0byB0aGUgQ1NTIHBhcnNlciBhbmQgdG9rZW5pemVyCmRp ZmYgLS1naXQgYS9NYW51YWxUZXN0cy9tZWRpYS1wbGF5ZXJzLWFyZS1kcm9wcGVkLW9uLWVycm9y Lmh0bWwgYi9NYW51YWxUZXN0cy9tZWRpYS1wbGF5ZXJzLWFyZS1kcm9wcGVkLW9uLWVycm9yLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMDM4OTY2ODE2N2ZhNTA0Yjc3NzUzN2M0MDczMjNkOGE2YjViMjNlMAot LS0gL2Rldi9udWxsCisrKyBiL01hbnVhbFRlc3RzL21lZGlhLXBsYXllcnMtYXJlLWRyb3BwZWQt b24tZXJyb3IuaHRtbApAQCAtMCwwICsxLDQwIEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4K K3ZhciB1cmxzID0gWworICAgICJmaWxlOi8vL2RvZXMgbm90IGV4aXN0IG9oIG5vZXMvdGVzdC5t cDQiLAorICAgICIuLi9MYXlvdXRUZXN0cy9tZWRpYS9jb250ZW50L3Rlc3QtMjVmcHMubXA0Igor XTsKK3ZhciBraWNrb2ZmRnVuY3Rpb25zID0gWworICAgICJsb2FkIiwKKyAgICAicGxheSIKK107 CisKK3ZhciBtZWRpYUVsZW1lbnRIb2xkZXIgPSBbXTsKKworZnVuY3Rpb24gcmVsZWFzZUFuZEFk ZE1lZGlhRWxlbWVudHMoKSB7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBtZWRpYUVsZW1lbnRI b2xkZXIubGVuZ3RoOyArK2kpCisgICAgICAgIG1lZGlhRWxlbWVudEhvbGRlcltpXS5zcmMgPSAi IjsKKyAgICBtZWRpYUVsZW1lbnRIb2xkZXIgPSBbXTsKKworICAgIGZvciAodmFyIGkgPSAwOyBp IDwgNTsgKytpKSB7CisgICAgICAgIGZvciAodmFyIHVybCBpbiB1cmxzKSB7CisgICAgICAgICAg ICBmb3IgKHZhciBraWNrb2ZmRnVuY3Rpb24gaW4ga2lja29mZkZ1bmN0aW9ucykgeworICAgICAg ICAgICAgICAgIHZhciBhID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgndmlkZW8nKTsKKyAgICAg ICAgICAgICAgICBhLmNvbnRyb2xzID0gImNvbnRyb2xzIjsKKyAgICAgICAgICAgICAgICBhLnNy YyA9IHVybHNbdXJsXTsKKyAgICAgICAgICAgICAgICBldmFsKCJhLiIgKyBraWNrb2ZmRnVuY3Rp b25zW2tpY2tvZmZGdW5jdGlvbl0gKyAiKCk7Iik7CisgICAgICAgICAgICAgICAgbWVkaWFFbGVt ZW50SG9sZGVyLnB1c2goYSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9Cis8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0ic2V0SW50ZXJ2YWwoJ3JlbGVhc2VBbmRB ZGRNZWRpYUVsZW1lbnRzKCknLCAxMDApIj4KKyAgICBUZXN0IHRoYXQgbWVkaWEgcGxheWVycyBh cmVuJ3QgbGVha2VkIG9uIGVycm9yLgorICAgIExvYWQgdGhpcyBwYWdlIGFuZCB2ZXJpZnkgdGhl IG51bWJlciBvZiB0aHJlYWRzIHVzZWQgYnkgdGhlIGJyb3dzZXIgZG9lc24ndAorICAgIHNlZW0g dW5yZWFzb25hYmxlIChlLmcuIGNocm9tZSB1c2VzIDQtNSB0aHJlYWRzIHBlciB2aWRlbyB0YWcg c28gc3RheWluZworICAgIHVuZGVyIDEwMCB0aHJlYWRzIGlzICJzdWNjZXNzIiwgc2luY2UgdGhp cyBpbnN0YW50aWF0ZXMgMjAgJmx0O3ZpZGVvJmd0OyBlbGVtZW50cykuCis8L2JvZHk+Cis8L2h0 bWw+Cg== 171946 2012-11-01 15:49:13 -0700 2012-11-01 18:38:51 -0700 Patch bug-99647-20121101154734.patch text/plain 6103 fischman U3VidmVyc2lvbiBSZXZpc2lvbjogMTMzMTQzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWY5MjIwNjhjNjA2NWVh MGVmOGRjOGYwZjk1Njg5OWZmZDg4YmY3Yy4uY2E3ZWM3MzI3NDY2NThmZGI2OTI1YjUyMjNmYWRk YWFhNGRlYzA4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIxIEBACisyMDEyLTExLTAxICBBbWkg RmlzY2htYW4gIDxmaXNjaG1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgSFRNTE1lZGlhUGxh eWVyIHNob3VsZCBmcmVlIG1fcGxheWVyIHdoZW4gc3JjIGlzIHNldC9jaGFuZ2VkCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD05OTY0NworCisgICAgICAg IFJldmlld2VkIGJ5IEVyaWMgQ2FybHNvbi4KKworICAgICAgICBOZXcgTWFudWFsVGVzdCBhZGRl ZDsgbWFudWFsIHNpbmNlIGxlYWtpbmcgbWVkaWEgcGxheWVycyBkb2Vzbid0IGhhdmUgbGF5b3V0 VGVzdENvbnRyb2xsZXItdmlzaWJsZSBlZmZlY3RzLgorCisgICAgICAgICogaHRtbC9IVE1MTWVk aWFFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxNZWRpYUVsZW1lbnQ6OnBhcnNl QXR0cmlidXRlKTogY2xlYXJNZWRpYVBsYXllcigpIHdoZW4gc3JjIGlzIHNldC9jaGFuZ2VkCisg ICAgICAgIChXZWJDb3JlOjpIVE1MTWVkaWFFbGVtZW50Ojp1c2VyQ2FuY2VsbGVkTG9hZCk6IHVz ZSBuZXcgY2xlYXJNZWRpYVBsYXllcigpIGhlbHBlcgorICAgICAgICAoV2ViQ29yZTo6SFRNTE1l ZGlhRWxlbWVudDo6Y2xlYXJNZWRpYVBsYXllcik6IGNsZWFyIG1fcGxheWVyIGFuZCBhc3NvY2lh dGVkIHRpbWVycy9mbGFncworICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpI VE1MTWVkaWFFbGVtZW50OjpjcmVhdGVNZWRpYVBsYXllcik6IHdoaXRlc3BhY2Utb25seSBjaGFu Z2UKKyAgICAgICAgKiBodG1sL0hUTUxNZWRpYUVsZW1lbnQuaDogbmV3IG1ldGhvZDogY3JlYXRl TWVkaWFQbGF5ZXIoKS4KKyAgICAgICAgKEhUTUxNZWRpYUVsZW1lbnQpOgorCiAyMDEyLTExLTAx ICBLaWhvbmcgS3dvbiAgPGtpaG9uZy5rd29uQHNhbXN1bmcuY29tPgogCiAgICAgICAgIEFkZCBE ZXZpY2VDb250cm9sbGVyIGJhc2UtY2xhc3MgdG8gcmVtb3ZlIGR1cGxpY2F0aW9uIG9mIERldmlj ZVhYWENvbnRyb2xlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFF bGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVudC5jcHAKaW5k ZXggZTljZDFhZmZjOWU2NjFkOThlNGU2NGQ5NzY0NGE5YTExYmZiZDQxMS4uYzg4MmU2MjZlNWNh NDZjMDcwOGYyZDNjNThmNjE4N2U2MjRjODhmYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MTWVkaWFFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxN ZWRpYUVsZW1lbnQuY3BwCkBAIC0zNjMsOCArMzYzLDEwIEBAIHZvaWQgSFRNTE1lZGlhRWxlbWVu dDo6cGFyc2VBdHRyaWJ1dGUoY29uc3QgQXR0cmlidXRlJiBhdHRyaWJ1dGUpCiB7CiAgICAgaWYg KGF0dHJpYnV0ZS5uYW1lKCkgPT0gc3JjQXR0cikgewogICAgICAgICAvLyBUcmlnZ2VyIGEgcmVs b2FkLCBhcyBsb25nIGFzIHRoZSAnc3JjJyBhdHRyaWJ1dGUgaXMgcHJlc2VudC4KLSAgICAgICAg aWYgKGZhc3RIYXNBdHRyaWJ1dGUoc3JjQXR0cikpCisgICAgICAgIGlmIChmYXN0SGFzQXR0cmli dXRlKHNyY0F0dHIpKSB7CisgICAgICAgICAgICBjbGVhck1lZGlhUGxheWVyKE1lZGlhUmVzb3Vy Y2UpOwogICAgICAgICAgICAgc2NoZWR1bGVMb2FkKE1lZGlhUmVzb3VyY2UpOworICAgICAgICB9 CiAgICAgfSBlbHNlIGlmIChhdHRyaWJ1dGUubmFtZSgpID09IGNvbnRyb2xzQXR0cikKICAgICAg ICAgY29uZmlndXJlTWVkaWFDb250cm9scygpOwogI2lmIFBMQVRGT1JNKE1BQykKQEAgLTM2Njks MTMgKzM2NzEsNyBAQCB2b2lkIEhUTUxNZWRpYUVsZW1lbnQ6OnVzZXJDYW5jZWxsZWRMb2FkKCkK ICAgICAvLyBJZiB0aGUgbWVkaWEgZGF0YSBmZXRjaGluZyBwcm9jZXNzIGlzIGFib3J0ZWQgYnkg dGhlIHVzZXI6CiAKICAgICAvLyAxIC0gVGhlIHVzZXIgYWdlbnQgc2hvdWxkIGNhbmNlbCB0aGUg ZmV0Y2hpbmcgcHJvY2Vzcy4KLSNpZiAhRU5BQkxFKFBMVUdJTl9QUk9YWV9GT1JfVklERU8pCi0g ICAgbV9wbGF5ZXIuY2xlYXIoKTsKLSNlbmRpZgotICAgIHN0b3BQZXJpb2RpY1RpbWVycygpOwot ICAgIG1fbG9hZFRpbWVyLnN0b3AoKTsKLSAgICBtX2xvYWRTdGF0ZSA9IFdhaXRpbmdGb3JTb3Vy Y2U7Ci0gICAgbV9wZW5kaW5nTG9hZEZsYWdzID0gMDsKKyAgICBjbGVhck1lZGlhUGxheWVyKC0x KTsKIAogICAgIC8vIDIgLSBTZXQgdGhlIGVycm9yIGF0dHJpYnV0ZSB0byBhIG5ldyBNZWRpYUVy cm9yIG9iamVjdCB3aG9zZSBjb2RlIGF0dHJpYnV0ZSBpcyBzZXQgdG8gTUVESUFfRVJSX0FCT1JU RUQuCiAgICAgbV9lcnJvciA9IE1lZGlhRXJyb3I6OmNyZWF0ZShNZWRpYUVycm9yOjpNRURJQV9F UlJfQUJPUlRFRCk7CkBAIC0zNzEzLDYgKzM3MDksMTggQEAgdm9pZCBIVE1MTWVkaWFFbGVtZW50 Ojp1c2VyQ2FuY2VsbGVkTG9hZCgpCiAjZW5kaWYKIH0KIAordm9pZCBIVE1MTWVkaWFFbGVtZW50 OjpjbGVhck1lZGlhUGxheWVyKHVuc2lnbmVkIGZsYWdzKQoreworI2lmICFFTkFCTEUoUExVR0lO X1BST1hZX0ZPUl9WSURFTykKKyAgICBtX3BsYXllci5jbGVhcigpOworI2VuZGlmCisgICAgc3Rv cFBlcmlvZGljVGltZXJzKCk7CisgICAgbV9sb2FkVGltZXIuc3RvcCgpOworCisgICAgbV9wZW5k aW5nTG9hZEZsYWdzICY9IH5mbGFnczsKKyAgICBtX2xvYWRTdGF0ZSA9IFdhaXRpbmdGb3JTb3Vy Y2U7Cit9CisKIGJvb2wgSFRNTE1lZGlhRWxlbWVudDo6Y2FuU3VzcGVuZCgpIGNvbnN0CiB7CiAg ICAgcmV0dXJuIHRydWU7IApAQCAtNDI2Myw3ICs0MjcxLDcgQEAgdm9pZCBIVE1MTWVkaWFFbGVt ZW50OjpjcmVhdGVNZWRpYVBsYXllcigpCiAgICAgaWYgKG1fYXVkaW9Tb3VyY2VOb2RlKQogICAg ICAgICBtX2F1ZGlvU291cmNlTm9kZS0+bG9jaygpOwogI2VuZGlmCi0gICAgICAgIAorCiAgICAg bV9wbGF5ZXIgPSBNZWRpYVBsYXllcjo6Y3JlYXRlKHRoaXMpOwogCiAjaWYgRU5BQkxFKE1FRElB X1NPVVJDRSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTE1lZGlhRWxlbWVu dC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50LmgKaW5kZXggYzI4OWZm ZjJlNmE5OTc3NTkwNWVkMjE4Yzk5M2ZkMjg0ZWRhOTM0MS4uM2FlOWYyZjM2NDkzY2ExMjkyNWQ4 MmM0Yjk0YjQ0Zjg4M2QwNTQ0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1M TWVkaWFFbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MTWVkaWFFbGVtZW50 LmgKQEAgLTQ2NCw2ICs0NjQsNyBAQCBwcml2YXRlOgogICAgIHZvaWQgc2NoZWR1bGVOZXh0U291 cmNlQ2hpbGQoKTsKICAgICB2b2lkIGxvYWROZXh0U291cmNlQ2hpbGQoKTsKICAgICB2b2lkIHVz ZXJDYW5jZWxsZWRMb2FkKCk7CisgICAgdm9pZCBjbGVhck1lZGlhUGxheWVyKHVuc2lnbmVkIGZs YWdzKTsKICAgICBib29sIGhhdmVQb3RlbnRpYWxTb3VyY2VDaGlsZCgpOwogICAgIHZvaWQgbm9u ZVN1cHBvcnRlZCgpOwogICAgIHZvaWQgbWVkaWFFbmdpbmVFcnJvcihQYXNzUmVmUHRyPE1lZGlh RXJyb3I+IGVycik7CmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggNDU4 M2MyMWZmOWMwNjlhMWMwYzBlZGY1MTFjNTExOTQwZTNjMDdhMS4uMDdmZTlhOTJkNmU4MDcyODc1 MTk0MGEzYjNjYmUzMTkzOGY5NGEyYiAxMDA2NDQKLS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDEyLTExLTAxICBBbWkgRmlzY2htYW4gIDxmaXNjaG1h bkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgSFRNTE1lZGlhUGxheWVyIHNob3VsZCBmcmVlIG1f cGxheWVyIHdoZW4gc3JjIGlzIHNldC9jaGFuZ2VkCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD05OTY0NworCisgICAgICAgIFJldmlld2VkIGJ5IEVyaWMg Q2FybHNvbi4KKworICAgICAgICAqIE1hbnVhbFRlc3RzL21lZGlhLXBsYXllcnMtYXJlLWRyb3Bw ZWQtb24tZXJyb3IuaHRtbDogQWRkZWQuCisgICAgICAgICAgICBWYXJpb3VzIHNjZW5hcmlvcyBh cmUgdGVzdGVkIHRvIG1ha2Ugc3VyZSBwbGF5ZXJzIGFyZW4ndAorICAgICAgICAgICAgbGVha2Vk IGluIGRpZmZlcmVudCB3YXlzIGZvciBlYWNoIG9mIHRoZW0uCisKIDIwMTItMTAtMzEgIFRoaWFn byBNYXJjb3MgUC4gU2FudG9zICA8dGhpYWdvLnNhbnRvc0BpbnRlbC5jb20+CiAKICAgICAgICAg QWRkZWQgdmlld3BvcnQgYXQtcnVsZSB0byB0aGUgQ1NTIHBhcnNlciBhbmQgdG9rZW5pemVyCmRp ZmYgLS1naXQgYS9NYW51YWxUZXN0cy9tZWRpYS1wbGF5ZXJzLWFyZS1kcm9wcGVkLW9uLWVycm9y Lmh0bWwgYi9NYW51YWxUZXN0cy9tZWRpYS1wbGF5ZXJzLWFyZS1kcm9wcGVkLW9uLWVycm9yLmh0 bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uMDM4OTY2ODE2N2ZhNTA0Yjc3NzUzN2M0MDczMjNkOGE2YjViMjNlMAot LS0gL2Rldi9udWxsCisrKyBiL01hbnVhbFRlc3RzL21lZGlhLXBsYXllcnMtYXJlLWRyb3BwZWQt b24tZXJyb3IuaHRtbApAQCAtMCwwICsxLDQwIEBACis8aHRtbD4KKzxoZWFkPgorPHNjcmlwdD4K K3ZhciB1cmxzID0gWworICAgICJmaWxlOi8vL2RvZXMgbm90IGV4aXN0IG9oIG5vZXMvdGVzdC5t cDQiLAorICAgICIuLi9MYXlvdXRUZXN0cy9tZWRpYS9jb250ZW50L3Rlc3QtMjVmcHMubXA0Igor XTsKK3ZhciBraWNrb2ZmRnVuY3Rpb25zID0gWworICAgICJsb2FkIiwKKyAgICAicGxheSIKK107 CisKK3ZhciBtZWRpYUVsZW1lbnRIb2xkZXIgPSBbXTsKKworZnVuY3Rpb24gcmVsZWFzZUFuZEFk ZE1lZGlhRWxlbWVudHMoKSB7CisgICAgZm9yICh2YXIgaSA9IDA7IGkgPCBtZWRpYUVsZW1lbnRI b2xkZXIubGVuZ3RoOyArK2kpCisgICAgICAgIG1lZGlhRWxlbWVudEhvbGRlcltpXS5zcmMgPSAi IjsKKyAgICBtZWRpYUVsZW1lbnRIb2xkZXIgPSBbXTsKKworICAgIGZvciAodmFyIGkgPSAwOyBp IDwgNTsgKytpKSB7CisgICAgICAgIGZvciAodmFyIHVybCBpbiB1cmxzKSB7CisgICAgICAgICAg ICBmb3IgKHZhciBraWNrb2ZmRnVuY3Rpb24gaW4ga2lja29mZkZ1bmN0aW9ucykgeworICAgICAg ICAgICAgICAgIHZhciBhID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgndmlkZW8nKTsKKyAgICAg ICAgICAgICAgICBhLmNvbnRyb2xzID0gImNvbnRyb2xzIjsKKyAgICAgICAgICAgICAgICBhLnNy YyA9IHVybHNbdXJsXTsKKyAgICAgICAgICAgICAgICBldmFsKCJhLiIgKyBraWNrb2ZmRnVuY3Rp b25zW2tpY2tvZmZGdW5jdGlvbl0gKyAiKCk7Iik7CisgICAgICAgICAgICAgICAgbWVkaWFFbGVt ZW50SG9sZGVyLnB1c2goYSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9Cit9Cis8 L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9ubG9hZD0ic2V0SW50ZXJ2YWwoJ3JlbGVhc2VBbmRB ZGRNZWRpYUVsZW1lbnRzKCknLCAxMDApIj4KKyAgICBUZXN0IHRoYXQgbWVkaWEgcGxheWVycyBh cmVuJ3QgbGVha2VkIG9uIGVycm9yLgorICAgIExvYWQgdGhpcyBwYWdlIGFuZCB2ZXJpZnkgdGhl IG51bWJlciBvZiB0aHJlYWRzIHVzZWQgYnkgdGhlIGJyb3dzZXIgZG9lc24ndAorICAgIHNlZW0g dW5yZWFzb25hYmxlIChlLmcuIGNocm9tZSB1c2VzIDQtNSB0aHJlYWRzIHBlciB2aWRlbyB0YWcg c28gc3RheWluZworICAgIHVuZGVyIDEwMCB0aHJlYWRzIGlzICJzdWNjZXNzIiwgc2luY2UgdGhp cyBpbnN0YW50aWF0ZXMgMjAgJmx0O3ZpZGVvJmd0OyBlbGVtZW50cykuCis8L2JvZHk+Cis8L2h0 bWw+Cg==