54152 2011-02-09 16:21:28 -0800 typing enter in the input element should not fire textInput 2024-02-22 17:09:45 -0800 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 1 ojan aboxhall aboxhall adele commit-queue darin dbates enrica mike mjs morrita rniwa tkent tony zimmermann oldest_to_newest 348686 0 81891 ojan 2011-02-09 16:21:28 -0800 Created attachment 81891 test case As per spec, we should only fire this event when text is actually inserted: http://dev.w3.org/2006/webapi/DOM-Level-3-Events/html/DOM3-Events.html#event-type-textinput. 352560 1 rniwa 2011-02-16 20:01:40 -0800 I talked with Alice, who is tackling this bug. It seems like we should avoid sending textInput event in EventHandler::handleTextInputEvent or executeInsertNewline depending on the value of InputType::shouldSubmitImplicitly. Preventing calls earlier than that will result in not calling EditorClient::WebEditorClient::handleKeyboardEvent, and may break some WebKit applications. Alice wanted to know where we prevent the insertion of \n in input elements because that seems to be another appropriate place to add this kind of check but I don't know the answer. My best guess is HTMLInputElement::defaultEventHandler where we check the value of shouldSubmitImplicitly and exit early. 355030 2 83266 aboxhall 2011-02-21 21:32:55 -0800 Created attachment 83266 work in progress 355045 3 83266 rniwa 2011-02-21 21:55:36 -0800 Comment on attachment 83266 work in progress View in context: https://bugs.webkit.org/attachment.cgi?id=83266&action=review > Source/WebCore/html/HTMLInputElement.h:186 > + bool shouldSubmitImplicitly(Event* evt) { return m_inputType->shouldSubmitImplicitly(evt); } This member function as well as InputType::shouldSubmitImplicitly should be qualified as const since they don't modify anything. > Source/WebCore/page/EventHandler.cpp:2726 > + if (targetNode && targetNode->isHTMLElement() && targetNode->hasTagName(inputTag)) { I'm worried that this will leave WML broken but then I'm not even sure if we fire inputText event in WML documents. > Source/WebCore/page/EventHandler.cpp:2727 > + HTMLInputElement* targetElement = (HTMLInputElement*) targetNode; We don't use C-type casts. Please do static_cast<InputElement*>(targetNode). > Source/WebCore/page/EventHandler.cpp:2729 > + if (targetElement->shouldSubmitImplicitly(event.get())) > + event->stopPropagation(); I would have combined these two if statements as in: if (targetNode && targetNode->isHTMLElement() && targetNode->hasTagName(inputTag) && static_cast<HTMLInputElement*>(targetNode)->shouldSubmitImplicitly(event.get())) event->StopPropagation(); 355048 4 rniwa 2011-02-21 22:05:30 -0800 Nikolas, Do we fire textInput event in WML? If so, how are we submitting the form on \r? As far as I read the code in WMLInputElement::defaultEventHandler, I can't reason how it's simulating mouse click when clickDefaultFormButton is true. 355615 5 83392 aboxhall 2011-02-22 14:34:25 -0800 Created attachment 83392 work in progress 355617 6 aboxhall 2011-02-22 14:36:32 -0800 LayoutTest is still to come; meanwhile... (In reply to comment #3) > (From update of attachment 83266 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=83266&action=review > > > Source/WebCore/html/HTMLInputElement.h:186 > > + bool shouldSubmitImplicitly(Event* evt) { return m_inputType->shouldSubmitImplicitly(evt); } > > This member function as well as InputType::shouldSubmitImplicitly should be qualified as const since they don't modify anything. Done. > > Source/WebCore/page/EventHandler.cpp:2726 > > + if (targetNode && targetNode->isHTMLElement() && targetNode->hasTagName(inputTag)) { > > I'm worried that this will leave WML broken but then I'm not even sure if we fire inputText event in WML documents. Obviously, this is well outside the scope of my knowledge, so I'll wait to hear from someone who knows more. > > Source/WebCore/page/EventHandler.cpp:2727 > > + HTMLInputElement* targetElement = (HTMLInputElement*) targetNode; > > We don't use C-type casts. Please do static_cast<InputElement*>(targetNode). Done. (Oops.) > > Source/WebCore/page/EventHandler.cpp:2729 > > + if (targetElement->shouldSubmitImplicitly(event.get())) > > + event->stopPropagation(); > > I would have combined these two if statements as in: > if (targetNode && targetNode->isHTMLElement() && targetNode->hasTagName(inputTag) > && static_cast<HTMLInputElement*>(targetNode)->shouldSubmitImplicitly(event.get())) > event->StopPropagation(); Hm, ok; that looks funny to me, but if you tell me that's the WebKit way I'm happy to do it. 355620 7 darin 2011-02-22 14:38:22 -0800 (In reply to comment #3) > > + if (targetNode && targetNode->isHTMLElement() && targetNode->hasTagName(inputTag)) { > > I'm worried that this will leave WML broken but then I'm not even sure if we fire inputText event in WML documents. hasTagName(inputTag) is all that's needed. If true it guarantees the node is an HTMLInputElement. So no separate check for isHTMLElement is needed. 356655 8 83600 aboxhall 2011-02-23 20:51:22 -0800 Created attachment 83600 with layout test 356658 9 83600 rniwa 2011-02-23 21:01:20 -0800 Comment on attachment 83600 with layout test View in context: https://bugs.webkit.org/attachment.cgi?id=83600&action=review The code change looks good but you need to explain what you're doing. Also, the layout test can be simplified further. > LayoutTests/ChangeLog:7 > + You should explain what kind of a test you're adding. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:1 > +<html> Missing <!DOCTYPE html> > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:6 > + <script> > + function log(msg) { > + document.getElementById('console').appendChild(document.createTextNode(msg + '\n')); > + } We don't normally indent tag like this. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:19 > + } catch (e) {} // Ignore ReferenceError if eventSender is undefined You should exit early when eventSender is not defined. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:27 > + var resultDiv = document.getElementById('result'); > + resultDiv.firstChild.innerHTML = 'FAIL'; You should call log instead. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:33 > + if (lastKeyPressed == 13) What does 13 mean? > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:34 > + document.getElementById('result').style.setProperty('display', 'block'); I don't think it's great that you hide/show SUCCESS like this. You should call log on console instead. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:50 > + function loaded() { > + var el = document.getElementById('el'); > + el.addEventListener('keypress', setLastKeyPressed); > + el.addEventListener('keypress', showResults); > + el.addEventListener('input', fail); > + el.addEventListener('textInput', fail); > + > + runTest(); > + } I don't think it's necessary to wait until page loads. You should just place this entire script element below pre and just run the test there while parsing is done. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:57 > +<br><br> Do we need these BRs? > Source/WebCore/ChangeLog:7 > + You should explain what caused the bug and how you fixed it. 356672 10 83600 ojan 2011-02-23 22:05:49 -0800 Comment on attachment 83600 with layout test View in context: https://bugs.webkit.org/attachment.cgi?id=83600&action=review >> LayoutTests/ChangeLog:7 >> + > > You should explain what kind of a test you're adding. Really? What needs explanation here? >> LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:6 >> + } > > We don't normally indent tag like this. I think you meant something like: We don't normally indent the contents of the head and body tags in tests. > Source/WebCore/ChangeLog:14 > + * html/HTMLInputElement.cpp: > + * html/HTMLInputElement.h: > + (WebCore::HTMLInputElement::shouldSubmitImplicitly): > + * page/EventHandler.cpp: > + (WebCore::EventHandler::handleTextInputEvent): Ideally you'd give a .5-1 sentence explanation of the changes to each file. Also, this file list no longer matches the list of files change. It's annoying but you need to: 1. Delete the changelog entry. 2. prepare-ChangeLog 3. Add your comments back in. :( 356677 11 83600 rniwa 2011-02-23 22:17:07 -0800 Comment on attachment 83600 with layout test View in context: https://bugs.webkit.org/attachment.cgi?id=83600&action=review > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:25 > + log((unexpected ? 'Unexpected ' : '') + event.type + ' fired.'); > + if (unexpected) { You can rewrite this as: if (lastKeyPressed = '\r'.charCodeAt(0)) { log(event.type + ' fired'); return; } log('Unexpected ' + event.type + ' fired'); ... 356682 12 83607 aboxhall 2011-02-23 22:38:31 -0800 Created attachment 83607 work in progress; updated layout test 356684 13 83607 rniwa 2011-02-23 22:47:08 -0800 Comment on attachment 83607 work in progress; updated layout test View in context: https://bugs.webkit.org/attachment.cgi?id=83607&action=review > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:4 > +<head> > +</head> Nit: unnecessary. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:9 > +<br><br> Again, I don't think we need these BRs here. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:10 > +<div id="result"><span style='padding: 5px'></span></div> Do we really need a span inside? > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:17 > +var enterChar = '\r'.charCodeAt(0); Ah, this is great! > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:27 > + resultDiv.firstChild.style.setProperty('background-color', 'red'); I'd write it as resultDiv.firstChild.style.backgroundColor = 'red' or better yet: resultDiv.innerHTML = '<font color="red">FAIL</font>'; > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:32 > + if (resultDiv.firstChild.innerHTML != 'FAIL') { If you had made the change above, you'll do resultDiv.innerText.indexOf('FAIL') < 0). > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:34 > + resultDiv.firstChild.innerHTML = 'SUCCESS'; > + resultDiv.firstChild.style.setProperty('background-color', 'green'); Ditto. I'd write it as resultDiv.innerHTML = '<font color="red">SUCCESS</font>'. In that case you don't even need curly brackets around the line. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:44 > +function setLastKeyPressed(event) { > + lastKeyPressed = event.keyCode; > +} > + > +var el = document.getElementById('el'); > +el.addEventListener('keypress', setLastKeyPressed); I'd use anonymous function as in: el.addEventListener('keypress', function(event) { lastKeyPressed = event.keyCode; }) > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:54 > + var el = document.getElementById('el'); ?? > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:56 > + succeedIfEventNotSent(); I don't think succeedIfEventNotSent needs to be a separate function. You can just put its definition here. 356740 14 zimmermann 2011-02-24 00:55:54 -0800 (In reply to comment #4) > Nikolas, > > Do we fire textInput event in WML? If so, how are we submitting the form on \r? As far as I read the code in WMLInputElement::defaultEventHandler, I can't reason how it's simulating mouse click when clickDefaultFormButton is true. Hm not sure at all, long ago since I last looked at the WML code. All I can say, WML doesn't support JS Scripting at all, so we don't need any events for WML in that regard. WMLInputElement, IIRC, is just a copy&paste of existing HTMLInputElement, and stripped down for WML. If it diverges, feel free to align them -- if WML is still used, (Samsung?) they'd notice if anything goes wrong. And I think you shouldn't have to care for WML (except that it still builds), as it's off-by-default. 357555 15 aboxhall 2011-02-24 16:36:44 -0800 (In reply to comment #13) > (From update of attachment 83607 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=83607&action=review > > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:4 > > +<head> > > +</head> > > Nit: unnecessary. Done. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:9 > > +<br><br> > > Again, I don't think we need these BRs here. They aren't necessary, but space things out a bit better when running the test manually. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:10 > > +<div id="result"><span style='padding: 5px'></span></div> > > Do we really need a span inside? Not really, but it makes it look a little better when running manually. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:17 > > +var enterChar = '\r'.charCodeAt(0); > > Ah, this is great! :-) > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:27 > > + resultDiv.firstChild.style.setProperty('background-color', 'red'); > > I'd write it as resultDiv.firstChild.style.backgroundColor = 'red' or better yet: resultDiv.innerHTML = '<font color="red">FAIL</font>'; I changed my mind again on how to do this. Now adding the span in here and checking for child nodes in the succeedIfEventNotFired block. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:32 > > + if (resultDiv.firstChild.innerHTML != 'FAIL') { > > If you had made the change above, you'll do resultDiv.innerText.indexOf('FAIL') < 0). See above. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:34 > > + resultDiv.firstChild.innerHTML = 'SUCCESS'; > > + resultDiv.firstChild.style.setProperty('background-color', 'green'); > > Ditto. I'd write it as resultDiv.innerHTML = '<font color="red">SUCCESS</font>'. In that case you don't even need curly brackets around the line. Did something similar. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:44 > > +function setLastKeyPressed(event) { > > + lastKeyPressed = event.keyCode; > > +} > > + > > +var el = document.getElementById('el'); > > +el.addEventListener('keypress', setLastKeyPressed); > > I'd use anonymous function as in: > el.addEventListener('keypress', function(event) { lastKeyPressed = event.keyCode; }) Done. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:54 > > + var el = document.getElementById('el'); > > ?? Removed. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:56 > > + succeedIfEventNotSent(); > > I don't think succeedIfEventNotSent needs to be a separate function. You can just put its definition here. I did that, and then slightly reworked the way the test worked because it was annoying me that it didn't have an obvious 'success' condition when running manually. Now I listen for a submit event and show the success message on that, or in this location if submit doesn't fire (which is also a bug, but tested in other cases). (In reply to comment #10) > (From update of attachment 83600 [details]) > > Source/WebCore/ChangeLog:14 > > + * html/HTMLInputElement.cpp: > > + * html/HTMLInputElement.h: > > + (WebCore::HTMLInputElement::shouldSubmitImplicitly): > > + * page/EventHandler.cpp: > > + (WebCore::EventHandler::handleTextInputEvent): > > Ideally you'd give a .5-1 sentence explanation of the changes to each file. Also, this file list no longer matches the list of files change. It's annoying but you need to: > 1. Delete the changelog entry. > 2. prepare-ChangeLog > 3. Add your comments back in. > > :( Hehe, done. The most painful part was working out how to convince prepare-ChangeLog to find my changes. (In reply to comment #7) > (In reply to comment #3) > > > + if (targetNode && targetNode->isHTMLElement() && targetNode->hasTagName(inputTag)) { > > > > I'm worried that this will leave WML broken but then I'm not even sure if we fire inputText event in WML documents. > > hasTagName(inputTag) is all that's needed. If true it guarantees the node is an HTMLInputElement. So no separate check for isHTMLElement is needed. Done. (In reply to comment #9) > > Source/WebCore/ChangeLog:7 > > + > > You should explain what caused the bug and how you fixed it. I've added some comments, do they cover it? 357556 16 83746 aboxhall 2011-02-24 16:37:40 -0800 Created attachment 83746 Patch 357588 17 83746 darin 2011-02-24 17:07:57 -0800 Comment on attachment 83746 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=83746&action=review > Source/WebCore/html/HTMLInputElement.h:186 > + bool shouldSubmitImplicitly(Event* evt) const { return m_inputType->shouldSubmitImplicitly(evt); } This function definition shouldn’t be inline in the header. We don’t want to expose the InputType.h header to everyone who includes the file. We can just declare this here in the header and put the implementation into HTMLInputElement.cpp. Also, please name this event, not evt. > Source/WebCore/html/InputType.cpp:341 > +bool InputType::shouldSubmitImplicitly(Event* event) const There’s really no point in having “const” functions in the input type class. Please leave these functions as normal member functions rather than const member functions. > Source/WebCore/page/EventHandler.cpp:2728 > + Node* targetNode = target->toNode(); > + if (targetNode && targetNode->hasTagName(inputTag) > + && static_cast<HTMLInputElement*>(targetNode)->shouldSubmitImplicitly(event.get())) > + event->stopPropagation(); It doesn’t make a lot of sense to actively call dispatchEvent after calling stopPropagation. And having input-element-specific code here in the event handler class is not good, even though we’ve done that before. I think the cleanest way to do this is to put the code into HTMLInputElement’s preDispatchEventHandler function. if (m_inputType->shouldSubmitImplicitly(event.get())) { event->stopPropagation(); return 0; } You won’t have to touch anything else. Only that one source file, HTMLInputElement.cpp, and only that one function. 357600 18 83746 rniwa 2011-02-24 17:49:13 -0800 Comment on attachment 83746 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=83746&action=review >> Source/WebCore/page/EventHandler.cpp:2728 >> + event->stopPropagation(); > > It doesn’t make a lot of sense to actively call dispatchEvent after calling stopPropagation. And having input-element-specific code here in the event handler class is not good, even though we’ve done that before. > > I think the cleanest way to do this is to put the code into HTMLInputElement’s preDispatchEventHandler function. > > if (m_inputType->shouldSubmitImplicitly(event.get())) { > event->stopPropagation(); > return 0; > } > > You won’t have to touch anything else. Only that one source file, HTMLInputElement.cpp, and only that one function. Ah! this is a much better solution. 357639 19 83746 rniwa 2011-02-24 18:40:40 -0800 Comment on attachment 83746 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=83746&action=review > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:32 > + if (!unexpectedEvents && !result.hasChildNodes()) > + result.innerHTML = '<span style="padding: 5px; background-color: green">SUCCESS</span>'; If you make the change below, then you can move all of this into the anonymous function. > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:55 > + // Just in case something goes wrong with the submit event, there are other tests for that > + succeedIfNoUnexpectedEvent(); I don't think we should be doing this. We should just fail if something goes wrong. 357662 20 83764 aboxhall 2011-02-24 20:06:50 -0800 Created attachment 83764 Patch 357663 21 aboxhall 2011-02-24 20:10:34 -0800 (In reply to comment #17) > (From update of attachment 83746 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=83746&action=review Reverted all other code and implemented your suggestion below. > > Source/WebCore/page/EventHandler.cpp:2728 > > + Node* targetNode = target->toNode(); > > + if (targetNode && targetNode->hasTagName(inputTag) > > + && static_cast<HTMLInputElement*>(targetNode)->shouldSubmitImplicitly(event.get())) > > + event->stopPropagation(); > > It doesn’t make a lot of sense to actively call dispatchEvent after calling stopPropagation. And having input-element-specific code here in the event handler class is not good, even though we’ve done that before. > > I think the cleanest way to do this is to put the code into HTMLInputElement’s preDispatchEventHandler function. > > if (m_inputType->shouldSubmitImplicitly(event.get())) { > event->stopPropagation(); > return 0; > } > > You won’t have to touch anything else. Only that one source file, HTMLInputElement.cpp, and only that one function. Done. (In reply to comment #19) > (From update of attachment 83746 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=83746&action=review > > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:32 > > + if (!unexpectedEvents && !result.hasChildNodes()) > > + result.innerHTML = '<span style="padding: 5px; background-color: green">SUCCESS</span>'; > > If you make the change below, then you can move all of this into the anonymous function. Done. > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:55 > > + // Just in case something goes wrong with the submit event, there are other tests for that > > + succeedIfNoUnexpectedEvent(); > > I don't think we should be doing this. We should just fail if something goes wrong. Done. 357671 22 83767 aboxhall 2011-02-24 21:08:43 -0800 Created attachment 83767 Patch 357673 23 aboxhall 2011-02-24 21:10:58 -0800 Sorry for the noise; latest patch simply adds a log statement in the LayoutTest in the case that window.eventSender is not found. 357675 24 83767 ojan 2011-02-24 21:15:03 -0800 Comment on attachment 83767 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=83767&action=review > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:58 > +} else { > + log('This test requires eventSender to run in LayoutTests.'); > +} Given that you have instructions to run it manually, I don't see that this log comment adds anything. Any test runner that is running WebKit's layout tests will have eventSender. The only reason we check for eventSender is for running the test manually. If you really want to keep this in though, WebKit style for one-line else statements is to leave off the brackets. 357678 25 aboxhall 2011-02-24 21:31:08 -0800 (In reply to comment #24) > (From update of attachment 83767 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=83767&action=review > > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:58 > > +} else { > > + log('This test requires eventSender to run in LayoutTests.'); > > +} > > Given that you have instructions to run it manually, I don't see that this log comment adds anything. Any test runner that is running WebKit's layout tests will have eventSender. The only reason we check for eventSender is for running the test manually. rniwa informed me that some platforms actually don't have eventSender, which made this change advisable. > > If you really want to keep this in though, WebKit style for one-line else statements is to leave off the brackets. Ok. I'm sure I'll get used to that soon. 357679 26 ojan 2011-02-24 21:36:10 -0800 (In reply to comment #25) > rniwa informed me that some platforms actually don't have eventSender, which made this change advisable. Ryosuke, which platforms don't have eventSender? 357680 27 rniwa 2011-02-24 21:39:10 -0800 (In reply to comment #26) > (In reply to comment #25) > > rniwa informed me that some platforms actually don't have eventSender, which made this change advisable. > > Ryosuke, which platforms don't have eventSender? WebKit2 and others. (In reply to comment #24) > (From update of attachment 83767 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=83767&action=review > > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:58 > > +} else { > > + log('This test requires eventSender to run in LayoutTests.'); > > +} > > Given that you have instructions to run it manually, I don't see that this log comment adds anything. Any test runner that is running WebKit's layout tests will have eventSender. The only reason we check for eventSender is for running the test manually. Should do: else if (window.layoutTestController) log('This test requires eventSender to run in LayoutTests.'); 357684 28 83770 aboxhall 2011-02-24 21:52:08 -0800 Created attachment 83770 Patch 357685 29 aboxhall 2011-02-24 21:53:47 -0800 > (In reply to comment #24) > > (From update of attachment 83767 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=83767&action=review > > > > > LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html:58 > > > +} else { > > > + log('This test requires eventSender to run in LayoutTests.'); > > > +} > > > > Given that you have instructions to run it manually, I don't see that this log comment adds anything. Any test runner that is running WebKit's layout tests will have eventSender. The only reason we check for eventSender is for running the test manually. > > Should do: > else if (window.layoutTestController) > log('This test requires eventSender to run in LayoutTests.'); Done. (Also, I noticed while doing this that my last patch actually reverted to my previous code change. This one is better!) 358455 30 83770 commit-queue 2011-02-26 04:12:34 -0800 Comment on attachment 83770 Patch Clearing flags on attachment: 83770 Committed r79777: <http://trac.webkit.org/changeset/79777> 358456 31 commit-queue 2011-02-26 04:12:41 -0800 All reviewed patches have been landed. Closing bug. 2016247 32 mike 2024-02-22 17:09:45 -0800 For the record here, the “typing enter in the input element should not fire textInput” requirement is now also specified in the UI Events Algorithms spec at https://w3c.github.io/uievents/event-algo.html#fire%20key%20input%20events, and https://github.com/web-platform-tests/wpt/pull/44472/files#diff-c6d874752d696fc97ee934bbd2e13f6887425b5d67b6566906597e8f1e23aaa4 has a test. (I’m mentioning it for any future readers here who may be doing troubleshooting and testing for regressions of this bug — because in working on a patch for bug #268988, I noticed this bug while trying to figure out myself how to update my patch after regressing the existing WebKit test at https://github.com/WebKit/WebKit/blob/main/LayoutTests/fast/forms/textinput-not-fired-on-enter-in-input.html and looking at its revision history.) 81891 2011-02-09 16:21:28 -0800 2011-02-09 16:21:28 -0800 test case repro.html text/html 255 ojan VHlwZSBlbnRlciBpbiB0aGUgaW5wdXQgZWxlbWVudC4gV2Ugc2hvdWxkIG5vdCBmaXJlIGlucHV0 IG9yIHRleHRJbnB1dC48YnI+CjxpbnB1dCBpZD1mb28+CjxzY3JpcHQ+CmZvby5hZGRFdmVudExp c3RlbmVyKCdpbnB1dCcsIGZ1bmN0aW9uKCkgeyBhbGVydCgnaW5wdXQgZmlyZWQnKTsgfSk7CmZv by5hZGRFdmVudExpc3RlbmVyKCd0ZXh0SW5wdXQnLCBmdW5jdGlvbigpIHsgYWxlcnQoJ3RleHRJ bnB1dCBmaXJlZCcpOyB9KTsKPC9zY3JpcHQ+ 83266 2011-02-21 21:32:55 -0800 2011-02-22 14:34:18 -0800 work in progress bug-54152-20110222163252.patch text/plain 2957 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogNzg5NTQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBiNDViZjQ1Yzc1MjIyMTU5 YWIyODY1ZTk3N2E3MzA0ZDU0Zjk1OTQyLi41ZWIzZTUwNGJkYzdiMmJlZWQ5MGIwM2NjYzlkMmZm YmU5OGRlZmJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDItMjEgIEFsaWNl IEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdHlwaW5nIGVudGVyIGluIHRoZSBpbnB1dCBlbGVt ZW50IHNob3VsZCBub3QgZmlyZSB0ZXh0SW5wdXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTU0MTUyCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09Q UyEpCisKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAqIGh0 bWwvSFRNTElucHV0RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVu dDo6c2hvdWxkU3VibWl0SW1wbGljaXRseSk6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVu dCk6CisKIDIwMTEtMDItMTggIEplciBOb2JsZSAgPGplci5ub2JsZUBhcHBsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuY3BwCmluZGV4IDZjNWZjMDVlN2U4YmRhNTlmZjc4Mjk4OWMwMDc0ZTZiMmJlMzlk MzEuLmZjM2JhOTc2ZTFlOGI4ZjAyOTUxNGIwNDRhMGEwZDBmYTU2NTM4YzYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtNDEsNyArNDEsNiBAQAogI2luY2x1 ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkhUTUxPcHRpb25FbGVtZW50LmgiCiAjaW5jbHVk ZSAiSFRNTFBhcnNlcklkaW9tcy5oIgotI2luY2x1ZGUgIklucHV0VHlwZS5oIgogI2luY2x1ZGUg IktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJMb2NhbGl6ZWRTdHJpbmdzLmgiCiAjaW5jbHVk ZSAiTW91c2VFdmVudC5oIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5w dXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAppbmRl eCA3NTc5OTJhZGE2NzU0MjYwZjYwMTQzMzEwNzMxYmRkOGZjMDhjMGE1Li5iZDUzMzgwMWEyNjUx ZWM4OWJkYzY1MmUwNjE5ZjRiNWU4YWRjMTI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuaApAQCAtMjYsNiArMjYsNyBAQAogCiAjaW5jbHVkZSAiSFRNTEZvcm1Db250cm9s RWxlbWVudC5oIgogI2luY2x1ZGUgIklucHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIklucHV0VHlw ZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTE4Miw2ICsxODMsOCBAQCBwdWJsaWM6 CiAgICAgdm9pZCBhZGRTZWFyY2hSZXN1bHQoKTsKICAgICB2b2lkIG9uU2VhcmNoKCk7CiAKKyAg ICBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqIGV2dCkgeyByZXR1cm4gbV9pbnB1 dFR5cGUtPnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoZXZ0KTsgfQorCiAjaWYgRU5BQkxFKERBVEFM SVNUKQogICAgIEhUTUxFbGVtZW50KiBsaXN0KCkgY29uc3Q7CiAgICAgSFRNTE9wdGlvbkVsZW1l bnQqIHNlbGVjdGVkT3B0aW9uKCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w YWdlL0V2ZW50SGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5j cHAKaW5kZXggMWE5MzBlMGNiMWExOTNlOWNhMGMzMzE3NWM1MWQ4OWQxN2IxMzdkNS4uZGM2NDI5 MTQ1OGI0N2U3MjA3MTUwNjkxMmU5M2U3OTAxNzkyZWFiYiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZl bnRIYW5kbGVyLmNwcApAQCAtMjcyMiw2ICsyNzIyLDEzIEBAIGJvb2wgRXZlbnRIYW5kbGVyOjpo YW5kbGVUZXh0SW5wdXRFdmVudChjb25zdCBTdHJpbmcmIHRleHQsIEV2ZW50KiB1bmRlcmx5aW5n RXZlCiAgICAgUmVmUHRyPFRleHRFdmVudD4gZXZlbnQgPSBUZXh0RXZlbnQ6OmNyZWF0ZShtX2Zy YW1lLT5kb21XaW5kb3coKSwgdGV4dCwgaW5wdXRUeXBlKTsKICAgICBldmVudC0+c2V0VW5kZXJs eWluZ0V2ZW50KHVuZGVybHlpbmdFdmVudCk7CiAKKyAgICBOb2RlKiB0YXJnZXROb2RlID0gdGFy Z2V0LT50b05vZGUoKTsKKyAgICBpZiAodGFyZ2V0Tm9kZSAmJiB0YXJnZXROb2RlLT5pc0hUTUxF bGVtZW50KCkgJiYgdGFyZ2V0Tm9kZS0+aGFzVGFnTmFtZShpbnB1dFRhZykpIHsKKyAgICAgICAg SFRNTElucHV0RWxlbWVudCogdGFyZ2V0RWxlbWVudCA9IChIVE1MSW5wdXRFbGVtZW50KikgdGFy Z2V0Tm9kZTsKKyAgICAgICAgaWYgKHRhcmdldEVsZW1lbnQtPnNob3VsZFN1Ym1pdEltcGxpY2l0 bHkoZXZlbnQuZ2V0KCkpKQorICAgICAgICAgICAgZXZlbnQtPnN0b3BQcm9wYWdhdGlvbigpOwor ICAgIH0KKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgdGFyZ2V0LT5kaXNwYXRjaEV2ZW50 KGV2ZW50LCBlYyk7CiAgICAgcmV0dXJuIGV2ZW50LT5kZWZhdWx0SGFuZGxlZCgpOwo= 83392 2011-02-22 14:34:25 -0800 2011-02-23 20:51:15 -0800 work in progress bug-54152-20110223093422.patch text/plain 4319 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogNzg5NTQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCBiNDViZjQ1Yzc1MjIyMTU5 YWIyODY1ZTk3N2E3MzA0ZDU0Zjk1OTQyLi41ZWIzZTUwNGJkYzdiMmJlZWQ5MGIwM2NjYzlkMmZm YmU5OGRlZmJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDItMjEgIEFsaWNl IEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdHlwaW5nIGVudGVyIGluIHRoZSBpbnB1dCBlbGVt ZW50IHNob3VsZCBub3QgZmlyZSB0ZXh0SW5wdXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTU0MTUyCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09Q UyEpCisKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAqIGh0 bWwvSFRNTElucHV0RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVu dDo6c2hvdWxkU3VibWl0SW1wbGljaXRseSk6CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZlbnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVu dCk6CisKIDIwMTEtMDItMTggIEplciBOb2JsZSAgPGplci5ub2JsZUBhcHBsZS5jb20+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuY3BwCmluZGV4IDZjNWZjMDVlN2U4YmRhNTlmZjc4Mjk4OWMwMDc0ZTZiMmJlMzlk MzEuLmZjM2JhOTc2ZTFlOGI4ZjAyOTUxNGIwNDRhMGEwZDBmYTU2NTM4YzYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtNDEsNyArNDEsNiBAQAogI2luY2x1 ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkhUTUxPcHRpb25FbGVtZW50LmgiCiAjaW5jbHVk ZSAiSFRNTFBhcnNlcklkaW9tcy5oIgotI2luY2x1ZGUgIklucHV0VHlwZS5oIgogI2luY2x1ZGUg IktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJMb2NhbGl6ZWRTdHJpbmdzLmgiCiAjaW5jbHVk ZSAiTW91c2VFdmVudC5oIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5w dXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAppbmRl eCA3NTc5OTJhZGE2NzU0MjYwZjYwMTQzMzEwNzMxYmRkOGZjMDhjMGE1Li42MTE4ZTBjMzFjMzEx NDRjOWQyMGFmNWNmNjE5NzI1MDUzNmNkZjdmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9o dG1sL0hUTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuaApAQCAtMjYsNiArMjYsNyBAQAogCiAjaW5jbHVkZSAiSFRNTEZvcm1Db250cm9s RWxlbWVudC5oIgogI2luY2x1ZGUgIklucHV0RWxlbWVudC5oIgorI2luY2x1ZGUgIklucHV0VHlw ZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTE4Miw2ICsxODMsOCBAQCBwdWJsaWM6 CiAgICAgdm9pZCBhZGRTZWFyY2hSZXN1bHQoKTsKICAgICB2b2lkIG9uU2VhcmNoKCk7CiAKKyAg ICBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqIGV2dCkgY29uc3QgeyByZXR1cm4g bV9pbnB1dFR5cGUtPnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoZXZ0KTsgfQorCiAjaWYgRU5BQkxF KERBVEFMSVNUKQogICAgIEhUTUxFbGVtZW50KiBsaXN0KCkgY29uc3Q7CiAgICAgSFRNTE9wdGlv bkVsZW1lbnQqIHNlbGVjdGVkT3B0aW9uKCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9odG1sL0lucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5j cHAKaW5kZXggYjJjYzdkZTgxZDA2YTdhOWVhYjY5NDE5ODVlMzUxY2Q3N2I0NGFlMC4uOWQ1ODdl MGI3NzVlYThlMGVmZDg5YzI4MmI5OWU4NDEwY2QwY2QxNSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRU eXBlLmNwcApAQCAtMzM4LDcgKzMzOCw3IEBAIHZvaWQgSW5wdXRUeXBlOjpmb3J3YXJkRXZlbnQo RXZlbnQqKQogewogfQogCi1ib29sIElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGljaXRseShF dmVudCogZXZlbnQpCitib29sIElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGljaXRseShFdmVu dCogZXZlbnQpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGV2ZW50LT5pc0tleWJvYXJkRXZlbnQoKSAm JiBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5rZXlwcmVzc0V2ZW50ICYmIHN0YXRpY19j YXN0PEtleWJvYXJkRXZlbnQqPihldmVudCktPmNoYXJDb2RlKCkgPT0gJ1xyJzsKIH0KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0lucHV0VHlwZS5oCmluZGV4IGVlNTM0ZTA1MmRhZTc0OWIzNTRmYTU4NmVlMGI0MGU1NmUy YzFlYjcuLmY1YmQ1OWQ5YjdmYjY5NTkzMjg2OTNiMWQxNTFkNDFiMjhiNmQ4NzcgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9JbnB1dFR5cGUuaApAQCAtMTY3LDcgKzE2Nyw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgaGFuZGxlV2hlZWxFdmVudChXaGVlbEV2ZW50Kik7CiAgICAgdmlydHVhbCB2b2lkIGZv cndhcmRFdmVudChFdmVudCopOwogICAgIC8vIEhlbHBlcnMgZm9yIGV2ZW50IGhhbmRsZXJzLgot ICAgIHZpcnR1YWwgYm9vbCBzaG91bGRTdWJtaXRJbXBsaWNpdGx5KEV2ZW50Kik7CisgICAgdmly dHVhbCBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqKSBjb25zdDsKICAgICB2aXJ0 dWFsIFBhc3NSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBmb3JtRm9yU3VibWlzc2lvbigpIGNvbnN0 OwogICAgIHZpcnR1YWwgYm9vbCBpc0tleWJvYXJkRm9jdXNhYmxlKCkgY29uc3Q7CiAgICAgdmly dHVhbCBib29sIHNob3VsZFVzZUlucHV0TWV0aG9kKCkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2 ZW50SGFuZGxlci5jcHAKaW5kZXggMWE5MzBlMGNiMWExOTNlOWNhMGMzMzE3NWM1MWQ4OWQxN2Ix MzdkNS4uOGRkYzEyZTkyMjZmMzM2NjUyZDhlMzdlNjY2YzRhYjQxY2VkYWU5NCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtMjcyMiwxMSArMjcyMiwxNiBAQCBib29sIEV2 ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0RXZlbnQoY29uc3QgU3RyaW5nJiB0ZXh0LCBFdmVu dCogdW5kZXJseWluZ0V2ZQogICAgIFJlZlB0cjxUZXh0RXZlbnQ+IGV2ZW50ID0gVGV4dEV2ZW50 OjpjcmVhdGUobV9mcmFtZS0+ZG9tV2luZG93KCksIHRleHQsIGlucHV0VHlwZSk7CiAgICAgZXZl bnQtPnNldFVuZGVybHlpbmdFdmVudCh1bmRlcmx5aW5nRXZlbnQpOwogCisgICAgTm9kZSogdGFy Z2V0Tm9kZSA9IHRhcmdldC0+dG9Ob2RlKCk7CisgICAgaWYgKHRhcmdldE5vZGUgJiYgdGFyZ2V0 Tm9kZS0+aXNIVE1MRWxlbWVudCgpICYmIHRhcmdldE5vZGUtPmhhc1RhZ05hbWUoaW5wdXRUYWcp CisgICAgICAgICYmIHN0YXRpY19jYXN0PEhUTUxJbnB1dEVsZW1lbnQqPih0YXJnZXROb2RlKS0+ c2hvdWxkU3VibWl0SW1wbGljaXRseShldmVudC5nZXQoKSkpCisgICAgICAgIGV2ZW50LT5zdG9w UHJvcGFnYXRpb24oKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAgICAgdGFyZ2V0LT5kaXNw YXRjaEV2ZW50KGV2ZW50LCBlYyk7CiAgICAgcmV0dXJuIGV2ZW50LT5kZWZhdWx0SGFuZGxlZCgp OwogfQotICAgIAorCiAjaWYgIVBMQVRGT1JNKE1BQykgJiYgIVBMQVRGT1JNKFFUKSAmJiAhUExB VEZPUk0oSEFJS1UpICYmICFQTEFURk9STShFRkwpCiBib29sIEV2ZW50SGFuZGxlcjo6aW52ZXJ0 U2Vuc2VPZlRhYnNUb0xpbmtzKEtleWJvYXJkRXZlbnQqKSBjb25zdAogewo= 83600 2011-02-23 20:51:22 -0800 2011-02-23 22:38:24 -0800 with layout test bug-54152-20110224155119.patch text/plain 9477 aboxhall ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA1NjM2ZGM1NzUyNzA3ZWJhZWM2Mjc5ZjYxY2U0YWExN2VlM2JlOGViLi4wMWUxZmE4 NWRhYzlkN2I3NWQ2ZDg2MjQzMzAyNTk0MTU5NjBhNjEzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMTEtMDItMjMgIEFsaWNlIEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdHlwaW5nIGVudGVy IGluIHRoZSBpbnB1dCBlbGVtZW50IHNob3VsZCBub3QgZmlyZSB0ZXh0SW5wdXQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU0MTUyCisKKyAgICAgICAg KiBmYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQt b24tZW50ZXItaW4taW5wdXQuaHRtbDogQWRkZWQuCisKIDIwMTEtMDItMjMgIEFuZHJldyBXaWxz b24gIDxhdHdpbHNvbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTW9yZSB1bnJldmlld2VkIGV4 cGVjdGF0aW9ucyBjbGVhbnVwIGZvciBjaHJvbWl1bS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50 ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU1N2U4MGFhNDhhYjdkODU2ZTQ3 OWU2ZDE4NDQzNmRmZGI3NDY3YzQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0IGNoZWNrcyB0aGF0IHR5cGluZyBFbnRlciBpbnRv IGFuIGlucHV0IGVsZW1lbnQgZG9lcyBub3QgZmlyZSBpbnB1dCBvciB0ZXh0SW5wdXQuCitUbyBy dW4gbWFudWFsbHksIHR5cGUgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgYmVsb3cuCisKKyAK KworU1VDQ0VTUworCitTZW5kaW5nIEVudGVyIHRvIGlucHV0IGVsZW1lbnQKKwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWlu LWlucHV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQt b24tZW50ZXItaW4taW5wdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yODZhYWJhMDhhZTYzNGIyMGY3MWU0 YmRjM2FiODZhN2YyZTQ0ZmQ4Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9m b3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0bWwKQEAgLTAsMCAr MSw2MSBAQAorPGh0bWw+Cis8aGVhZD4KKyAgICA8c2NyaXB0PgorICAgIGZ1bmN0aW9uIGxvZyht c2cpIHsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRD aGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtc2cgKyAnXG4nKSk7CisgICAgfQorCisgICAg ZnVuY3Rpb24gcnVuVGVzdCgpIHsKKyAgICAgICAgaWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJv bGxlcikKKyAgICAgICAgICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKwor ICAgICAgICB0cnkgeworICAgICAgICAgICAgaWYgKGV2ZW50U2VuZGVyKSB7CisgICAgICAgICAg ICAgICAgbG9nKCdcblNlbmRpbmcgRW50ZXIgdG8gaW5wdXQgZWxlbWVudCcpOworICAgICAgICAg ICAgICAgIHZhciBlbCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdlbCcpOworICAgICAgICAg ICAgICAgIGVsLmZvY3VzKCk7CisgICAgICAgICAgICAgICAgZXZlbnRTZW5kZXIua2V5RG93bign XHInLCBbXSk7CisgICAgICAgICAgICB9CisgICAgICAgIH0gY2F0Y2ggKGUpIHt9ICAvLyBJZ25v cmUgUmVmZXJlbmNlRXJyb3IgaWYgZXZlbnRTZW5kZXIgaXMgdW5kZWZpbmVkCisgICAgfQorCisg ICAgZnVuY3Rpb24gZmFpbChldmVudCkgeworICAgICAgICB2YXIgdW5leHBlY3RlZCA9IChsYXN0 S2V5UHJlc3NlZCA9PSAxMyk7CisgICAgICAgIGxvZygodW5leHBlY3RlZCA/ICdVbmV4cGVjdGVk ICcgOiAnJykgKyBldmVudC50eXBlICsgJyBmaXJlZC4nKTsKKyAgICAgICAgaWYgKHVuZXhwZWN0 ZWQpIHsKKyAgICAgICAgICAgIHZhciByZXN1bHREaXYgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJ ZCgncmVzdWx0Jyk7CisgICAgICAgICAgICByZXN1bHREaXYuZmlyc3RDaGlsZC5pbm5lckhUTUwg PSAnRkFJTCc7CisgICAgICAgICAgICByZXN1bHREaXYuZmlyc3RDaGlsZC5zdHlsZS5zZXRQcm9w ZXJ0eSgnYmFja2dyb3VuZC1jb2xvcicsICdyZWQnKTsKKyAgICAgICAgfQorICAgIH0KKworICAg IGZ1bmN0aW9uIHNob3dSZXN1bHRzKGV2ZW50KSB7CisgICAgICAgIGlmIChsYXN0S2V5UHJlc3Nl ZCA9PSAxMykKKyAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXN1bHQnKS5z dHlsZS5zZXRQcm9wZXJ0eSgnZGlzcGxheScsICdibG9jaycpOworICAgIH0KKworICAgIHZhciBs YXN0S2V5UHJlc3NlZCA9IDA7CisgICAgZnVuY3Rpb24gc2V0TGFzdEtleVByZXNzZWQoZXZlbnQp IHsKKyAgICAgICAgbGFzdEtleVByZXNzZWQgPSBldmVudC5rZXlDb2RlOworICAgIH0KKworICAg IGZ1bmN0aW9uIGxvYWRlZCgpIHsKKyAgICAgICAgdmFyIGVsID0gZG9jdW1lbnQuZ2V0RWxlbWVu dEJ5SWQoJ2VsJyk7CisgICAgICAgIGVsLmFkZEV2ZW50TGlzdGVuZXIoJ2tleXByZXNzJywgc2V0 TGFzdEtleVByZXNzZWQpOworICAgICAgICBlbC5hZGRFdmVudExpc3RlbmVyKCdrZXlwcmVzcycs IHNob3dSZXN1bHRzKTsKKyAgICAgICAgZWwuYWRkRXZlbnRMaXN0ZW5lcignaW5wdXQnLCBmYWls KTsKKyAgICAgICAgZWwuYWRkRXZlbnRMaXN0ZW5lcigndGV4dElucHV0JywgZmFpbCk7CisKKyAg ICAgICAgcnVuVGVzdCgpOworICAgIH0KKyAgICA8L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5IG9u bG9hZD0ibG9hZGVkKCk7Ij4KKzxwPlRoaXMgdGVzdCBjaGVja3MgdGhhdCB0eXBpbmcgRW50ZXIg aW50byBhbiBpbnB1dCBlbGVtZW50IGRvZXMgbm90IGZpcmUgaW5wdXQgb3IgdGV4dElucHV0Ljxi cj4KK1RvIHJ1biBtYW51YWxseSwgdHlwZSBlbnRlciBpbiB0aGUgaW5wdXQgZWxlbWVudCBiZWxv dy48L3A+Cis8aW5wdXQgaWQ9ImVsIj4KKzxicj48YnI+Cis8ZGl2IGlkPSJyZXN1bHQiIHN0eWxl PSJkaXNwbGF5Om5vbmUiPjxzcGFuIHN0eWxlPSJiYWNrZ3JvdW5kLWNvbG9yOiBncmVlbjsgcGFk ZGluZzogNXB4Ij5TVUNDRVNTPC9zcGFuPjwvZGl2PgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+ Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2M4NWU4NzhkMzM0ZDQyZDUxYTg4MGRm YjNkZmUzMDg1MWI3YzVhYy4uMGI2OTI4MjE4YzAzODJiODAyOGM0MGUwNTNkMmY5MDdjNjZlNmJh MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJD b3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDExLTAyLTIzICBBbGljZSBCb3hoYWxs ICA8YWJveGhhbGxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIHR5cGluZyBlbnRlciBpbiB0aGUgaW5wdXQgZWxlbWVudCBzaG91 bGQgbm90IGZpcmUgdGV4dElucHV0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD01NDE1MgorCisgICAgICAgIFRlc3Q6IGZhc3QvZm9ybXMvdGV4dGlucHV0 LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC5odG1sCisKKyAgICAgICAgKiBodG1sL0hUTUxJ bnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5oOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6c2hvdWxkU3VibWl0SW1wbGljaXRseSk6 CisgICAgICAgICogcGFnZS9FdmVudEhhbmRsZXIuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXZl bnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudCk6CisKIDIwMTEtMDItMjMgIERhdmlkIEh5 YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IFNhbSBXZWluaWcu CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAppbmRleCA2YzVmYzA1ZTdl OGJkYTU5ZmY3ODI5ODljMDA3NGU2YjJiZTM5ZDMxLi5mYzNiYTk3NmUxZThiOGYwMjk1MTRiMDQ0 YTBhMGQwZmE1NjUzOGM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5j cHAKQEAgLTQxLDcgKzQxLDYgQEAKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKICNpbmNsdWRlICJI VE1MT3B0aW9uRWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxQYXJzZXJJZGlvbXMuaCIKLSNpbmNs dWRlICJJbnB1dFR5cGUuaCIKICNpbmNsdWRlICJLZXlib2FyZEV2ZW50LmgiCiAjaW5jbHVkZSAi TG9jYWxpemVkU3RyaW5ncy5oIgogI2luY2x1ZGUgIk1vdXNlRXZlbnQuaCIKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKaW5kZXggNzU3OTkyYWRhNjc1NDI2MGY2MDE0MzMxMDcz MWJkZDhmYzA4YzBhNS4uNjExOGUwYzMxYzMxMTQ0YzlkMjBhZjVjZjYxOTcyNTA1MzZjZGY3ZiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKKysrIGIv U291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKQEAgLTI2LDYgKzI2LDcgQEAK IAogI2luY2x1ZGUgIkhUTUxGb3JtQ29udHJvbEVsZW1lbnQuaCIKICNpbmNsdWRlICJJbnB1dEVs ZW1lbnQuaCIKKyNpbmNsdWRlICJJbnB1dFR5cGUuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewog CkBAIC0xODIsNiArMTgzLDggQEAgcHVibGljOgogICAgIHZvaWQgYWRkU2VhcmNoUmVzdWx0KCk7 CiAgICAgdm9pZCBvblNlYXJjaCgpOwogCisgICAgYm9vbCBzaG91bGRTdWJtaXRJbXBsaWNpdGx5 KEV2ZW50KiBldnQpIGNvbnN0IHsgcmV0dXJuIG1faW5wdXRUeXBlLT5zaG91bGRTdWJtaXRJbXBs aWNpdGx5KGV2dCk7IH0KKwogI2lmIEVOQUJMRShEQVRBTElTVCkKICAgICBIVE1MRWxlbWVudCog bGlzdCgpIGNvbnN0OwogICAgIEhUTUxPcHRpb25FbGVtZW50KiBzZWxlY3RlZE9wdGlvbigpIGNv bnN0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCmluZGV4IGIyY2M3ZGU4MWQwNmE3YTllYWI2 OTQxOTg1ZTM1MWNkNzdiNDRhZTAuLjlkNTg3ZTBiNzc1ZWE4ZTBlZmQ4OWMyODJiOTllODQxMGNk MGNkMTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAKQEAgLTMzOCw3ICszMzgsNyBAQCB2 b2lkIElucHV0VHlwZTo6Zm9yd2FyZEV2ZW50KEV2ZW50KikKIHsKIH0KIAotYm9vbCBJbnB1dFR5 cGU6OnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqIGV2ZW50KQorYm9vbCBJbnB1dFR5cGU6 OnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqIGV2ZW50KSBjb25zdAogewogICAgIHJldHVy biBldmVudC0+aXNLZXlib2FyZEV2ZW50KCkgJiYgZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVz KCkua2V5cHJlc3NFdmVudCAmJiBzdGF0aWNfY2FzdDxLZXlib2FyZEV2ZW50Kj4oZXZlbnQpLT5j aGFyQ29kZSgpID09ICdccic7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lu cHV0VHlwZS5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaAppbmRleCBlZTUzNGUw NTJkYWU3NDliMzU0ZmE1ODZlZTBiNDBlNTZlMmMxZWI3Li5mNWJkNTlkOWI3ZmI2OTU5MzI4Njkz YjFkMTUxZDQxYjI4YjZkODc3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0 VHlwZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKQEAgLTE2Nyw3ICsx NjcsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGhhbmRsZVdoZWVsRXZlbnQoV2hlZWxF dmVudCopOwogICAgIHZpcnR1YWwgdm9pZCBmb3J3YXJkRXZlbnQoRXZlbnQqKTsKICAgICAvLyBI ZWxwZXJzIGZvciBldmVudCBoYW5kbGVycy4KLSAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkU3VibWl0 SW1wbGljaXRseShFdmVudCopOworICAgIHZpcnR1YWwgYm9vbCBzaG91bGRTdWJtaXRJbXBsaWNp dGx5KEV2ZW50KikgY29uc3Q7CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPEhUTUxGb3JtRWxlbWVu dD4gZm9ybUZvclN1Ym1pc3Npb24oKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgaXNLZXlib2Fy ZEZvY3VzYWJsZSgpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBzaG91bGRVc2VJbnB1dE1ldGhv ZCgpIGNvbnN0OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1 dFR5cGUuY3BwIGIvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwCmlu ZGV4IDFkMDZiZTNiMjNhNjc1ZjhhOTM1NzMzYmUwYjlmNjhmZjNmMDNjNjkuLjEwMzI3N2RjMmFj NzVmOTdiZTA4MjU5ZTVjYTgwYmEzN2UzMzk2YzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1Rl eHRGaWVsZElucHV0VHlwZS5jcHAKQEAgLTEwNCw3ICsxMDQsNyBAQCB2b2lkIFRleHRGaWVsZElu cHV0VHlwZTo6Zm9yd2FyZEV2ZW50KEV2ZW50KiBldmVudCkKICAgICAgICAgdG9SZW5kZXJUZXh0 Q29udHJvbFNpbmdsZUxpbmUoZWxlbWVudCgpLT5yZW5kZXJlcigpKS0+Zm9yd2FyZEV2ZW50KGV2 ZW50KTsKIH0KIAotYm9vbCBUZXh0RmllbGRJbnB1dFR5cGU6OnNob3VsZFN1Ym1pdEltcGxpY2l0 bHkoRXZlbnQqIGV2ZW50KQorYm9vbCBUZXh0RmllbGRJbnB1dFR5cGU6OnNob3VsZFN1Ym1pdElt cGxpY2l0bHkoRXZlbnQqIGV2ZW50KSBjb25zdAogewogICAgIHJldHVybiAoZXZlbnQtPnR5cGUo KSA9PSBldmVudE5hbWVzKCkudGV4dElucHV0RXZlbnQgJiYgZXZlbnQtPmlzVGV4dEV2ZW50KCkg JiYgc3RhdGljX2Nhc3Q8VGV4dEV2ZW50Kj4oZXZlbnQpLT5kYXRhKCkgPT0gIlxuIikgfHwgSW5w dXRUeXBlOjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KGV2ZW50KTsKIH0KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL1RleHRGaWVsZElucHV0VHlwZS5oCmluZGV4IDg2YWQwZWYxYWNkNGJhNmIxOWYxMWJhODZj YWE0YTA4NzE4NGUxOGMuLjM5NTI0ZmQ2NGI1YWEyN2MzMzY2NTNlMTZhNDYxZDNiMjllZmMxMjcg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmgKKysr IGIvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaApAQCAtNDksNyArNDks NyBAQCBwcml2YXRlOgogICAgIHZpcnR1YWwgYm9vbCBpc1RleHRGaWVsZCgpIGNvbnN0OwogICAg IHZpcnR1YWwgYm9vbCB2YWx1ZU1pc3NpbmcoY29uc3QgU3RyaW5nJikgY29uc3Q7CiAgICAgdmly dHVhbCB2b2lkIGZvcndhcmRFdmVudChFdmVudCopOwotICAgIHZpcnR1YWwgYm9vbCBzaG91bGRT dWJtaXRJbXBsaWNpdGx5KEV2ZW50Kik7CisgICAgdmlydHVhbCBib29sIHNob3VsZFN1Ym1pdElt cGxpY2l0bHkoRXZlbnQqKSBjb25zdDsKICAgICB2aXJ0dWFsIFJlbmRlck9iamVjdCogY3JlYXRl UmVuZGVyZXIoUmVuZGVyQXJlbmEqLCBSZW5kZXJTdHlsZSopIGNvbnN0OwogICAgIHZpcnR1YWwg Ym9vbCBzaG91bGRVc2VJbnB1dE1ldGhvZCgpIGNvbnN0OwogICAgIHZpcnR1YWwgU3RyaW5nIHNh bml0aXplVmFsdWUoY29uc3QgU3RyaW5nJiBwcm9wb3NlZFZhbHVlKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv RXZlbnRIYW5kbGVyLmNwcAppbmRleCAxYjVkNjVhOTNmZTdiMDk1NzMxOTVjODJkMTk1ODBiYjY2 YTI0ZjYwLi5lZWNjNDUxNjFjYTQ5OWI0ZmQ0MjhkOTExN2FkZDRhY2UxZDI0NTZkIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCkBAIC0yNzIyLDExICsyNzIyLDE2IEBAIGJvb2wg RXZlbnRIYW5kbGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudChjb25zdCBTdHJpbmcmIHRleHQsIEV2 ZW50KiB1bmRlcmx5aW5nRXZlCiAgICAgUmVmUHRyPFRleHRFdmVudD4gZXZlbnQgPSBUZXh0RXZl bnQ6OmNyZWF0ZShtX2ZyYW1lLT5kb21XaW5kb3coKSwgdGV4dCwgaW5wdXRUeXBlKTsKICAgICBl dmVudC0+c2V0VW5kZXJseWluZ0V2ZW50KHVuZGVybHlpbmdFdmVudCk7CiAKKyAgICBOb2RlKiB0 YXJnZXROb2RlID0gdGFyZ2V0LT50b05vZGUoKTsKKyAgICBpZiAodGFyZ2V0Tm9kZSAmJiB0YXJn ZXROb2RlLT5oYXNUYWdOYW1lKGlucHV0VGFnKQorICAgICAgICAmJiBzdGF0aWNfY2FzdDxIVE1M SW5wdXRFbGVtZW50Kj4odGFyZ2V0Tm9kZSktPnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoZXZlbnQu Z2V0KCkpKQorICAgICAgICBldmVudC0+c3RvcFByb3BhZ2F0aW9uKCk7CisKICAgICBFeGNlcHRp b25Db2RlIGVjOwogICAgIHRhcmdldC0+ZGlzcGF0Y2hFdmVudChldmVudCwgZWMpOwogICAgIHJl dHVybiBldmVudC0+ZGVmYXVsdEhhbmRsZWQoKTsKIH0KLSAgICAKKwogI2lmICFQTEFURk9STShN QUMpICYmICFQTEFURk9STShRVCkgJiYgIVBMQVRGT1JNKEhBSUtVKSAmJiAhUExBVEZPUk0oRUZM KQogYm9vbCBFdmVudEhhbmRsZXI6OmludmVydFNlbnNlT2ZUYWJzVG9MaW5rcyhLZXlib2FyZEV2 ZW50KikgY29uc3QKIHsK 83607 2011-02-23 22:38:31 -0800 2011-02-24 16:37:33 -0800 work in progress; updated layout test bug-54152-20110224173828.patch text/plain 9188 aboxhall ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA1NjM2ZGM1NzUyNzA3ZWJhZWM2Mjc5ZjYxY2U0YWExN2VlM2JlOGViLi4wMWUxZmE4 NWRhYzlkN2I3NWQ2ZDg2MjQzMzAyNTk0MTU5NjBhNjEzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMTEtMDItMjMgIEFsaWNlIEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAg ICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdHlwaW5nIGVudGVy IGluIHRoZSBpbnB1dCBlbGVtZW50IHNob3VsZCBub3QgZmlyZSB0ZXh0SW5wdXQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU0MTUyCisKKyAgICAgICAg KiBmYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQt b24tZW50ZXItaW4taW5wdXQuaHRtbDogQWRkZWQuCisKIDIwMTEtMDItMjMgIEFuZHJldyBXaWxz b24gIDxhdHdpbHNvbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTW9yZSB1bnJldmlld2VkIGV4 cGVjdGF0aW9ucyBjbGVhbnVwIGZvciBjaHJvbWl1bS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50 ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU1N2U4MGFhNDhhYjdkODU2ZTQ3 OWU2ZDE4NDQzNmRmZGI3NDY3YzQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0 L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0IGNoZWNrcyB0aGF0IHR5cGluZyBFbnRlciBpbnRv IGFuIGlucHV0IGVsZW1lbnQgZG9lcyBub3QgZmlyZSBpbnB1dCBvciB0ZXh0SW5wdXQuCitUbyBy dW4gbWFudWFsbHksIHR5cGUgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgYmVsb3cuCisKKyAK KworU1VDQ0VTUworCitTZW5kaW5nIEVudGVyIHRvIGlucHV0IGVsZW1lbnQKKwpkaWZmIC0tZ2l0 IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWlu LWlucHV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQt b24tZW50ZXItaW4taW5wdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40NzdhZDZlYmM1YmQ0NWQ4ZGJhMzhj NGIzN2QzNzlkYWY0ZjA5MzE3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9m b3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0bWwKQEAgLTAsMCAr MSw2MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFkPgorPC9oZWFkPgorPGJvZHk+ Cis8cD5UaGlzIHRlc3QgY2hlY2tzIHRoYXQgdHlwaW5nIEVudGVyIGludG8gYW4gaW5wdXQgZWxl bWVudCBkb2VzIG5vdCBmaXJlIGlucHV0IG9yIHRleHRJbnB1dC48YnI+CitUbyBydW4gbWFudWFs bHksIHR5cGUgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgYmVsb3cuPC9wPgorPGlucHV0IGlk PSJlbCI+Cis8YnI+PGJyPgorPGRpdiBpZD0icmVzdWx0Ij48c3BhbiBzdHlsZT0ncGFkZGluZzog NXB4Jz48L3NwYW4+PC9kaXY+Cis8cHJlIGlkPSJjb25zb2xlIj48L3ByZT4KKzxzY3JpcHQ+Citm dW5jdGlvbiBsb2cobXNnKSB7CisgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2NvbnNvbGUn KS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZShtc2cgKyAnXG4nKSk7Cit9CisK K3ZhciBlbnRlckNoYXIgPSAnXHInLmNoYXJDb2RlQXQoMCk7CitmdW5jdGlvbiBmYWlsKGV2ZW50 KSB7CisgICAgaWYgKGxhc3RLZXlQcmVzc2VkICE9IGVudGVyQ2hhcikgeworICAgICAgICBsb2co ZXZlbnQudHlwZSArICcgZmlyZWQuJyk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgCisg ICAgbG9nKCdVbmV4cGVjdGVkICcgKyBldmVudC50eXBlICsgJyBmaXJlZC4nKTsKKyAgICB2YXIg cmVzdWx0RGl2ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Jlc3VsdCcpOworICAgIHJlc3Vs dERpdi5maXJzdENoaWxkLmlubmVySFRNTCA9ICdGQUlMJzsKKyAgICByZXN1bHREaXYuZmlyc3RD aGlsZC5zdHlsZS5zZXRQcm9wZXJ0eSgnYmFja2dyb3VuZC1jb2xvcicsICdyZWQnKTsKK30KKwor ZnVuY3Rpb24gc3VjY2VlZElmRXZlbnROb3RTZW50KCkgeworICAgIHZhciByZXN1bHREaXYgPSBk b2N1bWVudC5nZXRFbGVtZW50QnlJZCgncmVzdWx0Jyk7CisgICAgaWYgKHJlc3VsdERpdi5maXJz dENoaWxkLmlubmVySFRNTCAhPSAnRkFJTCcpIHsKKyAgICAgICAgcmVzdWx0RGl2LmZpcnN0Q2hp bGQuaW5uZXJIVE1MID0gJ1NVQ0NFU1MnOworICAgICAgICByZXN1bHREaXYuZmlyc3RDaGlsZC5z dHlsZS5zZXRQcm9wZXJ0eSgnYmFja2dyb3VuZC1jb2xvcicsICdncmVlbicpOworICAgIH0KK30K KwordmFyIGxhc3RLZXlQcmVzc2VkID0gMDsKK2Z1bmN0aW9uIHNldExhc3RLZXlQcmVzc2VkKGV2 ZW50KSB7CisgICAgbGFzdEtleVByZXNzZWQgPSBldmVudC5rZXlDb2RlOworfQorCit2YXIgZWwg PSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZWwnKTsKK2VsLmFkZEV2ZW50TGlzdGVuZXIoJ2tl eXByZXNzJywgc2V0TGFzdEtleVByZXNzZWQpOworZWwuYWRkRXZlbnRMaXN0ZW5lcignaW5wdXQn LCBmYWlsKTsKK2VsLmFkZEV2ZW50TGlzdGVuZXIoJ3RleHRJbnB1dCcsIGZhaWwpOworCitpZiAo d2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1 bXBBc1RleHQoKTsKKworZWwuZm9jdXMoKTsKK2lmICh3aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAg ICBsb2coJ1xuU2VuZGluZyBFbnRlciB0byBpbnB1dCBlbGVtZW50Jyk7CisgICAgdmFyIGVsID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2VsJyk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bign XHInLCBbXSk7CisgICAgc3VjY2VlZElmRXZlbnROb3RTZW50KCk7Cit9Cis8L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA3Yzg1ZTg3OGQzMzRkNDJkNTFhODgwZGZiM2Rm ZTMwODUxYjdjNWFjLi4wYjY5MjgyMThjMDM4MmI4MDI4YzQwZTA1M2QyZjkwN2M2NmU2YmEyIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTggQEAKKzIwMTEtMDItMjMgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgdHlwaW5nIGVudGVyIGluIHRoZSBpbnB1dCBlbGVtZW50IHNob3VsZCBu b3QgZmlyZSB0ZXh0SW5wdXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTU0MTUyCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90 LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTElucHV0 RWxlbWVudC5jcHA6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAg IChXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KToKKyAg ICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFdmVudEhh bmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KToKKwogMjAxMS0wMi0yMyAgRGF2aWQgSHlhdHQg IDxoeWF0dEBhcHBsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgU2FtIFdlaW5pZy4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCmluZGV4IDZjNWZjMDVlN2U4YmRh NTlmZjc4Mjk4OWMwMDc0ZTZiMmJlMzlkMzEuLmZjM2JhOTc2ZTFlOGI4ZjAyOTUxNGIwNDRhMGEw ZDBmYTU2NTM4YzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxl bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApA QCAtNDEsNyArNDEsNiBAQAogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkhUTUxP cHRpb25FbGVtZW50LmgiCiAjaW5jbHVkZSAiSFRNTFBhcnNlcklkaW9tcy5oIgotI2luY2x1ZGUg IklucHV0VHlwZS5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJMb2Nh bGl6ZWRTdHJpbmdzLmgiCiAjaW5jbHVkZSAiTW91c2VFdmVudC5oIgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1s L0hUTUxJbnB1dEVsZW1lbnQuaAppbmRleCA3NTc5OTJhZGE2NzU0MjYwZjYwMTQzMzEwNzMxYmRk OGZjMDhjMGE1Li42MTE4ZTBjMzFjMzExNDRjOWQyMGFmNWNmNjE5NzI1MDUzNmNkZjdmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaApAQCAtMjYsNiArMjYsNyBAQAogCiAj aW5jbHVkZSAiSFRNTEZvcm1Db250cm9sRWxlbWVudC5oIgogI2luY2x1ZGUgIklucHV0RWxlbWVu dC5oIgorI2luY2x1ZGUgIklucHV0VHlwZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAg LTE4Miw2ICsxODMsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBhZGRTZWFyY2hSZXN1bHQoKTsKICAg ICB2b2lkIG9uU2VhcmNoKCk7CiAKKyAgICBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZl bnQqIGV2dCkgY29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUtPnNob3VsZFN1Ym1pdEltcGxpY2l0 bHkoZXZ0KTsgfQorCiAjaWYgRU5BQkxFKERBVEFMSVNUKQogICAgIEhUTUxFbGVtZW50KiBsaXN0 KCkgY29uc3Q7CiAgICAgSFRNTE9wdGlvbkVsZW1lbnQqIHNlbGVjdGVkT3B0aW9uKCkgY29uc3Q7 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAKaW5kZXggYjJjYzdkZTgxZDA2YTdhOWVhYjY5NDE5 ODVlMzUxY2Q3N2I0NGFlMC4uOWQ1ODdlMGI3NzVlYThlMGVmZDg5YzI4MmI5OWU4NDEwY2QwY2Qx NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcApAQCAtMzM4LDcgKzMzOCw3IEBAIHZvaWQg SW5wdXRUeXBlOjpmb3J3YXJkRXZlbnQoRXZlbnQqKQogewogfQogCi1ib29sIElucHV0VHlwZTo6 c2hvdWxkU3VibWl0SW1wbGljaXRseShFdmVudCogZXZlbnQpCitib29sIElucHV0VHlwZTo6c2hv dWxkU3VibWl0SW1wbGljaXRseShFdmVudCogZXZlbnQpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGV2 ZW50LT5pc0tleWJvYXJkRXZlbnQoKSAmJiBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5r ZXlwcmVzc0V2ZW50ICYmIHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldmVudCktPmNoYXJD b2RlKCkgPT0gJ1xyJzsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRU eXBlLmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5oCmluZGV4IGVlNTM0ZTA1MmRh ZTc0OWIzNTRmYTU4NmVlMGI0MGU1NmUyYzFlYjcuLmY1YmQ1OWQ5YjdmYjY5NTkzMjg2OTNiMWQx NTFkNDFiMjhiNmQ4NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBl LmgKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaApAQCAtMTY3LDcgKzE2Nyw3 IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlV2hlZWxFdmVudChXaGVlbEV2ZW50 Kik7CiAgICAgdmlydHVhbCB2b2lkIGZvcndhcmRFdmVudChFdmVudCopOwogICAgIC8vIEhlbHBl cnMgZm9yIGV2ZW50IGhhbmRsZXJzLgotICAgIHZpcnR1YWwgYm9vbCBzaG91bGRTdWJtaXRJbXBs aWNpdGx5KEV2ZW50Kik7CisgICAgdmlydHVhbCBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHko RXZlbnQqKSBjb25zdDsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBm b3JtRm9yU3VibWlzc2lvbigpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBpc0tleWJvYXJkRm9j dXNhYmxlKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHNob3VsZFVzZUlucHV0TWV0aG9kKCkg Y29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlw ZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKaW5kZXgg MWQwNmJlM2IyM2E2NzVmOGE5MzU3MzNiZTBiOWY2OGZmM2YwM2M2OS4uMTAzMjc3ZGMyYWM3NWY5 N2JlMDgyNTllNWNhODBiYTM3ZTMzOTZjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRt bC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZp ZWxkSW5wdXRUeXBlLmNwcApAQCAtMTA0LDcgKzEwNCw3IEBAIHZvaWQgVGV4dEZpZWxkSW5wdXRU eXBlOjpmb3J3YXJkRXZlbnQoRXZlbnQqIGV2ZW50KQogICAgICAgICB0b1JlbmRlclRleHRDb250 cm9sU2luZ2xlTGluZShlbGVtZW50KCktPnJlbmRlcmVyKCkpLT5mb3J3YXJkRXZlbnQoZXZlbnQp OwogfQogCi1ib29sIFRleHRGaWVsZElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGljaXRseShF dmVudCogZXZlbnQpCitib29sIFRleHRGaWVsZElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGlj aXRseShFdmVudCogZXZlbnQpIGNvbnN0CiB7CiAgICAgcmV0dXJuIChldmVudC0+dHlwZSgpID09 IGV2ZW50TmFtZXMoKS50ZXh0SW5wdXRFdmVudCAmJiBldmVudC0+aXNUZXh0RXZlbnQoKSAmJiBz dGF0aWNfY2FzdDxUZXh0RXZlbnQqPihldmVudCktPmRhdGEoKSA9PSAiXG4iKSB8fCBJbnB1dFR5 cGU6OnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoZXZlbnQpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwv VGV4dEZpZWxkSW5wdXRUeXBlLmgKaW5kZXggODZhZDBlZjFhY2Q0YmE2YjE5ZjExYmE4NmNhYTRh MDg3MTg0ZTE4Yy4uMzk1MjRmZDY0YjVhYTI3YzMzNjY1M2UxNmE0NjFkM2IyOWVmYzEyNyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5oCkBAIC00OSw3ICs0OSw3IEBA IHByaXZhdGU6CiAgICAgdmlydHVhbCBib29sIGlzVGV4dEZpZWxkKCkgY29uc3Q7CiAgICAgdmly dHVhbCBib29sIHZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmKSBjb25zdDsKICAgICB2aXJ0dWFs IHZvaWQgZm9yd2FyZEV2ZW50KEV2ZW50Kik7Ci0gICAgdmlydHVhbCBib29sIHNob3VsZFN1Ym1p dEltcGxpY2l0bHkoRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkU3VibWl0SW1wbGlj aXRseShFdmVudCopIGNvbnN0OwogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5k ZXJlcihSZW5kZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29uc3Q7CiAgICAgdmlydHVhbCBib29s IHNob3VsZFVzZUlucHV0TWV0aG9kKCkgY29uc3Q7CiAgICAgdmlydHVhbCBTdHJpbmcgc2FuaXRp emVWYWx1ZShjb25zdCBTdHJpbmcmIHByb3Bvc2VkVmFsdWUpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVu dEhhbmRsZXIuY3BwCmluZGV4IDFiNWQ2NWE5M2ZlN2IwOTU3MzE5NWM4MmQxOTU4MGJiNjZhMjRm NjAuLmVlY2M0NTE2MWNhNDk5YjRmZDQyOGQ5MTE3YWRkNGFjZTFkMjQ1NmQgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKQEAgLTI3MjIsMTEgKzI3MjIsMTYgQEAgYm9vbCBFdmVu dEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQq IHVuZGVybHlpbmdFdmUKICAgICBSZWZQdHI8VGV4dEV2ZW50PiBldmVudCA9IFRleHRFdmVudDo6 Y3JlYXRlKG1fZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0LCBpbnB1dFR5cGUpOwogICAgIGV2ZW50 LT5zZXRVbmRlcmx5aW5nRXZlbnQodW5kZXJseWluZ0V2ZW50KTsKIAorICAgIE5vZGUqIHRhcmdl dE5vZGUgPSB0YXJnZXQtPnRvTm9kZSgpOworICAgIGlmICh0YXJnZXROb2RlICYmIHRhcmdldE5v ZGUtPmhhc1RhZ05hbWUoaW5wdXRUYWcpCisgICAgICAgICYmIHN0YXRpY19jYXN0PEhUTUxJbnB1 dEVsZW1lbnQqPih0YXJnZXROb2RlKS0+c2hvdWxkU3VibWl0SW1wbGljaXRseShldmVudC5nZXQo KSkpCisgICAgICAgIGV2ZW50LT5zdG9wUHJvcGFnYXRpb24oKTsKKwogICAgIEV4Y2VwdGlvbkNv ZGUgZWM7CiAgICAgdGFyZ2V0LT5kaXNwYXRjaEV2ZW50KGV2ZW50LCBlYyk7CiAgICAgcmV0dXJu IGV2ZW50LT5kZWZhdWx0SGFuZGxlZCgpOwogfQotICAgIAorCiAjaWYgIVBMQVRGT1JNKE1BQykg JiYgIVBMQVRGT1JNKFFUKSAmJiAhUExBVEZPUk0oSEFJS1UpICYmICFQTEFURk9STShFRkwpCiBi b29sIEV2ZW50SGFuZGxlcjo6aW52ZXJ0U2Vuc2VPZlRhYnNUb0xpbmtzKEtleWJvYXJkRXZlbnQq KSBjb25zdAogewo= 83746 2011-02-24 16:37:40 -0800 2011-02-24 20:06:43 -0800 Patch bug-54152-20110225113737.patch text/plain 9920 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogNzk2MzkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjN2U5MzI1NDYwNjVkYzAwZDQ1ZTFm OTMyYWQ5MTRkYTZjOTM4YWE3Li5kMTlhZWI0Y2VjZjdjZGI1YWEzZjE4YWNmNWQwODY5NTk1MjNi MTAzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTEtMDItMjQgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGVzdHMgdGhhdCB0eXBpbmcgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1l bnQgZG9lcyBub3QgZmlyZSB0ZXh0SW5wdXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01NDE1MgorCisgICAgICAgICogZmFzdC9mb3Jtcy90ZXh0aW5w dXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0 bWw6IEFkZGVkLgorCiAyMDExLTAyLTI0ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgQWRkIGNocm9taXVtIGJhc2VsaW5lcyBmb3IgbmV3IGZhc3QvYmxv Y2svcG9zaXRpb24vdmVydGljYWwtIHRlc3RzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0LWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1p bi1pbnB1dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDIzZDNkYjkwZGFhM2YyNDQ1N2UyY2Yw Mjk5NmM4NDEyZGRiMGJkYQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9y bXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw5IEBACitUaGlzIHRlc3QgY2hlY2tzIHRoYXQgdHlwaW5nIEVudGVyIGludG8gYW4g aW5wdXQgZWxlbWVudCBkb2VzIG5vdCBmaXJlIGlucHV0IG9yIHRleHRJbnB1dC4KK1RvIHJ1biBt YW51YWxseSwgdHlwZSBlbnRlciBpbiB0aGUgaW5wdXQgZWxlbWVudCBiZWxvdy4KKworCisKK1NV Q0NFU1MKKworU2VuZGluZyBFbnRlciB0byBpbnB1dCBlbGVtZW50CisKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1 dC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVu dGVyLWluLWlucHV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWQ3MWRmOTJiZGYwY2U5NjVmODkzOGEwNjJj NjMzMDQ0M2NjNjQxOAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMv dGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC5odG1sCkBAIC0wLDAgKzEsNTkg QEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxwPlRoaXMgdGVzdCBjaGVja3Mg dGhhdCB0eXBpbmcgRW50ZXIgaW50byBhbiBpbnB1dCBlbGVtZW50IGRvZXMgbm90IGZpcmUgaW5w dXQgb3IgdGV4dElucHV0Ljxicj4KK1RvIHJ1biBtYW51YWxseSwgdHlwZSBlbnRlciBpbiB0aGUg aW5wdXQgZWxlbWVudCBiZWxvdy48L3A+Cis8Zm9ybSBpZD0iZm9ybSI+Cis8aW5wdXQgaWQ9ImVs Ij4KKzwvZm9ybT4KKzxicj4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8cHJlIGlkPSJjb25z b2xlIj48L3ByZT4KKzxzY3JpcHQ+CitmdW5jdGlvbiBsb2cobXNnKSB7CisgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0 Tm9kZShtc2cgKyAnXG4nKSk7Cit9CisKK3ZhciB1bmV4cGVjdGVkRXZlbnRzID0gMDsKK3ZhciBl bnRlckNoYXIgPSAnXHInLmNoYXJDb2RlQXQoMCk7CitmdW5jdGlvbiBmYWlsKGV2ZW50KSB7Cisg ICAgaWYgKGxhc3RLZXlQcmVzc2VkICE9IGVudGVyQ2hhcikgeworICAgICAgICBsb2coZXZlbnQu dHlwZSArICcgZmlyZWQuJyk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICB1bmV4cGVj dGVkRXZlbnRzKys7CisgICAgbG9nKCdVbmV4cGVjdGVkICcgKyBldmVudC50eXBlICsgJyBmaXJl ZC4nKTsKKyAgICByZXN1bHQuaW5uZXJIVE1MID0gJzxzcGFuIHN0eWxlPSJwYWRkaW5nOiA1cHg7 IGJhY2tncm91bmQtY29sb3I6IHJlZCI+RkFJTDwvc3Bhbj4nOworfQorCitmdW5jdGlvbiBzdWNj ZWVkSWZOb1VuZXhwZWN0ZWRFdmVudCgpIHsKKyAgICBpZiAoIXVuZXhwZWN0ZWRFdmVudHMgJiYg IXJlc3VsdC5oYXNDaGlsZE5vZGVzKCkpCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNw YW4gc3R5bGU9InBhZGRpbmc6IDVweDsgYmFja2dyb3VuZC1jb2xvcjogZ3JlZW4iPlNVQ0NFU1M8 L3NwYW4+JzsKK30KKwordmFyIGxhc3RLZXlQcmVzc2VkID0gMDsKK2VsLmFkZEV2ZW50TGlzdGVu ZXIoJ2tleXByZXNzJywgZnVuY3Rpb24oZXZlbnQpIHsgbGFzdEtleVByZXNzZWQgPSBldmVudC5r ZXlDb2RlOyB9KTsKK2VsLmFkZEV2ZW50TGlzdGVuZXIoJ2lucHV0JywgZmFpbCk7CitlbC5hZGRF dmVudExpc3RlbmVyKCd0ZXh0SW5wdXQnLCBmYWlsKTsKKworLy8gSWYgdGhlIGZvcm0gaXMgc3Vi bWl0dGVkIG9uIGVudGVyIGFuZCBubyB1bmV4cGVjdGVkIGV2ZW50IGhhcyBiZWVuIGZpcmVkLCBz dWNjZXNzIQorZm9ybS5hZGRFdmVudExpc3RlbmVyKCdzdWJtaXQnLCBmdW5jdGlvbihldmVudCkg eworICAgIHN1Y2NlZWRJZk5vVW5leHBlY3RlZEV2ZW50KCk7CisgICAgZXZlbnQucHJldmVudERl ZmF1bHQoKTsKK30pOworCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxh eW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworZWwuZm9jdXMoKTsKK2lmICh3aW5k b3cuZXZlbnRTZW5kZXIpIHsKKyAgICBsb2coJ1xuU2VuZGluZyBFbnRlciB0byBpbnB1dCBlbGVt ZW50Jyk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bignXHInLCBbXSk7CisKKyAgICAvLyBKdXN0 IGluIGNhc2Ugc29tZXRoaW5nIGdvZXMgd3Jvbmcgd2l0aCB0aGUgc3VibWl0IGV2ZW50LCB0aGVy ZSBhcmUgb3RoZXIgdGVzdHMgZm9yIHRoYXQKKyAgICBzdWNjZWVkSWZOb1VuZXhwZWN0ZWRFdmVu dCgpOworfQorPC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDk3YzFk MjMwYjk0Y2UyZDI1ZGZkYmYxM2Q2MGY5MjgxMjA2YjAyOC4uNmY3Zjg4ZGE0NTE3N2U5ZTIxY2E0 ZTgxZjZjODAxNDAzOGFlZWMwMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9n CisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDExLTAy LTI0ICBBbGljZSBCb3hoYWxsICA8YWJveGhhbGxAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIHR5cGluZyBlbnRlciBpbiB0aGUg aW5wdXQgZWxlbWVudCBzaG91bGQgbm90IGZpcmUgdGV4dElucHV0CisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD01NDE1MgorCisgICAgICAgIFN0b3AgdGV4 dElucHV0IGV2ZW50IHByb3BhZ2F0aW9uIGluIEV2ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0 RXZlbnQgaWYgdGhlIGV2ZW50IHRhcmdldCBzaG91bGQgc3VibWl0IGltcGxpY2l0bHkuCisgICAg ICAgIEFkZGl0aW9uYWxseSwgbWFrZXMgdGhlIGV4aXN0aW5nIElucHV0VHlwZTo6c2hvdWxkU3Vi bWl0SW1wbGljaXRseSgpIG1ldGhvZCBvZmZpY2lhbGx5IGNvbnN0LgorCisgICAgICAgIFRlc3Q6 IGZhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC5odG1sCisK KyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAqIGh0bWwvSFRN TElucHV0RWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6c2hv dWxkU3VibWl0SW1wbGljaXRseSk6IEFkZCBpbmxpbmUgbWV0aG9kIGRlbGVnYXRpbmcgdG8gbV9p bnB1dFR5cGUuCisgICAgICAgICogaHRtbC9JbnB1dFR5cGUuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6SW5wdXRUeXBlOjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KTogTWFrZSBjb25zdC4KKyAgICAg ICAgKiBodG1sL0lucHV0VHlwZS5oOgorICAgICAgICAqIGh0bWwvVGV4dEZpZWxkSW5wdXRUeXBl LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRleHRGaWVsZElucHV0VHlwZTo6c2hvdWxkU3VibWl0 SW1wbGljaXRseSk6IE1ha2UgY29uc3QuCisgICAgICAgICogaHRtbC9UZXh0RmllbGRJbnB1dFR5 cGUuaDoKKyAgICAgICAgKiBwYWdlL0V2ZW50SGFuZGxlci5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpFdmVudEhhbmRsZXI6OmhhbmRsZVRleHRJbnB1dEV2ZW50KTogQ2hlY2sgc2hvdWxkU3VibWl0 SW1wbGljaXRseSgpIG9uIHRoZSBldmVudCB0YXJnZXQgYW5kIHN0b3AgZXZlbnQgcHJvcGFnYXRp b24gaWYgdHJ1ZS4KKwogMjAxMS0wMi0yNCAgSmFtZXMgUm9iaW5zb24gIDxqYW1lc3JAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEZpc2hlci4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCmluZGV4IDZjNWZjMDVlN2U4YmRhNTlmZjc4Mjk4 OWMwMDc0ZTZiMmJlMzlkMzEuLmZjM2JhOTc2ZTFlOGI4ZjAyOTUxNGIwNDRhMGEwZDBmYTU2NTM4 YzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcApAQCAtNDEsNyAr NDEsNiBAQAogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIkhUTUxPcHRpb25FbGVt ZW50LmgiCiAjaW5jbHVkZSAiSFRNTFBhcnNlcklkaW9tcy5oIgotI2luY2x1ZGUgIklucHV0VHlw ZS5oIgogI2luY2x1ZGUgIktleWJvYXJkRXZlbnQuaCIKICNpbmNsdWRlICJMb2NhbGl6ZWRTdHJp bmdzLmgiCiAjaW5jbHVkZSAiTW91c2VFdmVudC5oIgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1 dEVsZW1lbnQuaAppbmRleCA3NTc5OTJhZGE2NzU0MjYwZjYwMTQzMzEwNzMxYmRkOGZjMDhjMGE1 Li42MTE4ZTBjMzFjMzExNDRjOWQyMGFmNWNmNjE5NzI1MDUzNmNkZjdmIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaApAQCAtMjYsNiArMjYsNyBAQAogCiAjaW5jbHVkZSAi SFRNTEZvcm1Db250cm9sRWxlbWVudC5oIgogI2luY2x1ZGUgIklucHV0RWxlbWVudC5oIgorI2lu Y2x1ZGUgIklucHV0VHlwZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTE4Miw2ICsx ODMsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBhZGRTZWFyY2hSZXN1bHQoKTsKICAgICB2b2lkIG9u U2VhcmNoKCk7CiAKKyAgICBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqIGV2dCkg Y29uc3QgeyByZXR1cm4gbV9pbnB1dFR5cGUtPnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoZXZ0KTsg fQorCiAjaWYgRU5BQkxFKERBVEFMSVNUKQogICAgIEhUTUxFbGVtZW50KiBsaXN0KCkgY29uc3Q7 CiAgICAgSFRNTE9wdGlvbkVsZW1lbnQqIHNlbGVjdGVkT3B0aW9uKCkgY29uc3Q7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9o dG1sL0lucHV0VHlwZS5jcHAKaW5kZXggYjJjYzdkZTgxZDA2YTdhOWVhYjY5NDE5ODVlMzUxY2Q3 N2I0NGFlMC4uOWQ1ODdlMGI3NzVlYThlMGVmZDg5YzI4MmI5OWU4NDEwY2QwY2QxNSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL2h0bWwvSW5wdXRUeXBlLmNwcApAQCAtMzM4LDcgKzMzOCw3IEBAIHZvaWQgSW5wdXRUeXBl Ojpmb3J3YXJkRXZlbnQoRXZlbnQqKQogewogfQogCi1ib29sIElucHV0VHlwZTo6c2hvdWxkU3Vi bWl0SW1wbGljaXRseShFdmVudCogZXZlbnQpCitib29sIElucHV0VHlwZTo6c2hvdWxkU3VibWl0 SW1wbGljaXRseShFdmVudCogZXZlbnQpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGV2ZW50LT5pc0tl eWJvYXJkRXZlbnQoKSAmJiBldmVudC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS5rZXlwcmVzc0V2 ZW50ICYmIHN0YXRpY19jYXN0PEtleWJvYXJkRXZlbnQqPihldmVudCktPmNoYXJDb2RlKCkgPT0g J1xyJzsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmggYi9T b3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5oCmluZGV4IGVlNTM0ZTA1MmRhZTc0OWIzNTRm YTU4NmVlMGI0MGU1NmUyYzFlYjcuLmY1YmQ1OWQ5YjdmYjY5NTkzMjg2OTNiMWQxNTFkNDFiMjhi NmQ4NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKKysrIGIv U291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuaApAQCAtMTY3LDcgKzE2Nyw3IEBAIHB1Ymxp YzoKICAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlV2hlZWxFdmVudChXaGVlbEV2ZW50Kik7CiAgICAg dmlydHVhbCB2b2lkIGZvcndhcmRFdmVudChFdmVudCopOwogICAgIC8vIEhlbHBlcnMgZm9yIGV2 ZW50IGhhbmRsZXJzLgotICAgIHZpcnR1YWwgYm9vbCBzaG91bGRTdWJtaXRJbXBsaWNpdGx5KEV2 ZW50Kik7CisgICAgdmlydHVhbCBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqKSBj b25zdDsKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8SFRNTEZvcm1FbGVtZW50PiBmb3JtRm9yU3Vi bWlzc2lvbigpIGNvbnN0OwogICAgIHZpcnR1YWwgYm9vbCBpc0tleWJvYXJkRm9jdXNhYmxlKCkg Y29uc3Q7CiAgICAgdmlydHVhbCBib29sIHNob3VsZFVzZUlucHV0TWV0aG9kKCkgY29uc3Q7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKaW5kZXggMWQwNmJlM2Iy M2E2NzVmOGE5MzU3MzNiZTBiOWY2OGZmM2YwM2M2OS4uMTAzMjc3ZGMyYWM3NWY5N2JlMDgyNTll NWNhODBiYTM3ZTMzOTZjNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9UZXh0Rmll bGRJbnB1dFR5cGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRU eXBlLmNwcApAQCAtMTA0LDcgKzEwNCw3IEBAIHZvaWQgVGV4dEZpZWxkSW5wdXRUeXBlOjpmb3J3 YXJkRXZlbnQoRXZlbnQqIGV2ZW50KQogICAgICAgICB0b1JlbmRlclRleHRDb250cm9sU2luZ2xl TGluZShlbGVtZW50KCktPnJlbmRlcmVyKCkpLT5mb3J3YXJkRXZlbnQoZXZlbnQpOwogfQogCi1i b29sIFRleHRGaWVsZElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGljaXRseShFdmVudCogZXZl bnQpCitib29sIFRleHRGaWVsZElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGljaXRseShFdmVu dCogZXZlbnQpIGNvbnN0CiB7CiAgICAgcmV0dXJuIChldmVudC0+dHlwZSgpID09IGV2ZW50TmFt ZXMoKS50ZXh0SW5wdXRFdmVudCAmJiBldmVudC0+aXNUZXh0RXZlbnQoKSAmJiBzdGF0aWNfY2Fz dDxUZXh0RXZlbnQqPihldmVudCktPmRhdGEoKSA9PSAiXG4iKSB8fCBJbnB1dFR5cGU6OnNob3Vs ZFN1Ym1pdEltcGxpY2l0bHkoZXZlbnQpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxk SW5wdXRUeXBlLmgKaW5kZXggODZhZDBlZjFhY2Q0YmE2YjE5ZjExYmE4NmNhYTRhMDg3MTg0ZTE4 Yy4uMzk1MjRmZDY0YjVhYTI3YzMzNjY1M2UxNmE0NjFkM2IyOWVmYzEyNyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5oCkBAIC00OSw3ICs0OSw3IEBAIHByaXZhdGU6 CiAgICAgdmlydHVhbCBib29sIGlzVGV4dEZpZWxkKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29s IHZhbHVlTWlzc2luZyhjb25zdCBTdHJpbmcmKSBjb25zdDsKICAgICB2aXJ0dWFsIHZvaWQgZm9y d2FyZEV2ZW50KEV2ZW50Kik7Ci0gICAgdmlydHVhbCBib29sIHNob3VsZFN1Ym1pdEltcGxpY2l0 bHkoRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkU3VibWl0SW1wbGljaXRseShFdmVu dCopIGNvbnN0OwogICAgIHZpcnR1YWwgUmVuZGVyT2JqZWN0KiBjcmVhdGVSZW5kZXJlcihSZW5k ZXJBcmVuYSosIFJlbmRlclN0eWxlKikgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHNob3VsZFVz ZUlucHV0TWV0aG9kKCkgY29uc3Q7CiAgICAgdmlydHVhbCBTdHJpbmcgc2FuaXRpemVWYWx1ZShj b25zdCBTdHJpbmcmIHByb3Bvc2VkVmFsdWUpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGFnZS9FdmVudEhhbmRsZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIu Y3BwCmluZGV4IGFmNmMzZjI3MTBkNGY1ZWRlOGUyYjc3ZDg1MTVjMjljYjA4ZmUyYzMuLjhhZWQ2 ZjhhMTk5NTc2M2Y4NzUwNmNjNjBjMDcwYmYyODQ5MDZkYWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2 ZW50SGFuZGxlci5jcHAKQEAgLTI3MjIsMTEgKzI3MjIsMTYgQEAgYm9vbCBFdmVudEhhbmRsZXI6 OmhhbmRsZVRleHRJbnB1dEV2ZW50KGNvbnN0IFN0cmluZyYgdGV4dCwgRXZlbnQqIHVuZGVybHlp bmdFdmUKICAgICBSZWZQdHI8VGV4dEV2ZW50PiBldmVudCA9IFRleHRFdmVudDo6Y3JlYXRlKG1f ZnJhbWUtPmRvbVdpbmRvdygpLCB0ZXh0LCBpbnB1dFR5cGUpOwogICAgIGV2ZW50LT5zZXRVbmRl cmx5aW5nRXZlbnQodW5kZXJseWluZ0V2ZW50KTsKIAorICAgIE5vZGUqIHRhcmdldE5vZGUgPSB0 YXJnZXQtPnRvTm9kZSgpOworICAgIGlmICh0YXJnZXROb2RlICYmIHRhcmdldE5vZGUtPmhhc1Rh Z05hbWUoaW5wdXRUYWcpCisgICAgICAgICYmIHN0YXRpY19jYXN0PEhUTUxJbnB1dEVsZW1lbnQq Pih0YXJnZXROb2RlKS0+c2hvdWxkU3VibWl0SW1wbGljaXRseShldmVudC5nZXQoKSkpCisgICAg ICAgIGV2ZW50LT5zdG9wUHJvcGFnYXRpb24oKTsKKwogICAgIEV4Y2VwdGlvbkNvZGUgZWM7CiAg ICAgdGFyZ2V0LT5kaXNwYXRjaEV2ZW50KGV2ZW50LCBlYyk7CiAgICAgcmV0dXJuIGV2ZW50LT5k ZWZhdWx0SGFuZGxlZCgpOwogfQotICAgIAorCiAjaWYgIVBMQVRGT1JNKE1BQykgJiYgIVBMQVRG T1JNKFFUKSAmJiAhUExBVEZPUk0oSEFJS1UpICYmICFQTEFURk9STShFRkwpCiBib29sIEV2ZW50 SGFuZGxlcjo6aW52ZXJ0U2Vuc2VPZlRhYnNUb0xpbmtzKEtleWJvYXJkRXZlbnQqKSBjb25zdAog ewo= 83764 2011-02-24 20:06:50 -0800 2011-02-24 21:08:36 -0800 Patch bug-54152-20110225150647.patch text/plain 4937 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogNzk2NTYKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBmZjA2NTJmNmFlYjNlMjUxOTdiZThj YzY5M2RiNTk5NTQ0ZTVkMzc2Li5iYmUyMWE4YTE5OWRhZWE0NDdkOWFiMTczZDVhMjRhYzdjNmY0 MGRmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTEtMDItMjQgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGVzdHMgdGhhdCB0eXBpbmcgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1l bnQgZG9lcyBub3QgZmlyZSB0ZXh0SW5wdXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01NDE1MgorCisgICAgICAgICogZmFzdC9mb3Jtcy90ZXh0aW5w dXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0 bWw6IEFkZGVkLgorCiAyMDExLTAyLTI0ICBNaWhhaSBQYXJwYXJpdGEgIDxtaWhhaXBAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgQ2hyb21pdW0gZXhwZWN0YXRpb25zIHVwZGF0 ZS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJl ZC1vbi1lbnRlci1pbi1pbnB1dC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1z L3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjQyM2QzZGI5MGRhYTNmMjQ0NTdlMmNmMDI5OTZjODQxMmRkYjBiZGEKLS0tIC9kZXYv bnVsbAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24t ZW50ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0IGNo ZWNrcyB0aGF0IHR5cGluZyBFbnRlciBpbnRvIGFuIGlucHV0IGVsZW1lbnQgZG9lcyBub3QgZmly ZSBpbnB1dCBvciB0ZXh0SW5wdXQuCitUbyBydW4gbWFudWFsbHksIHR5cGUgZW50ZXIgaW4gdGhl IGlucHV0IGVsZW1lbnQgYmVsb3cuCisKKworCitTVUNDRVNTCisKK1NlbmRpbmcgRW50ZXIgdG8g aW5wdXQgZWxlbWVudAorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRp bnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3Qv Zm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjUwMWIyZTFhMjVkZWExMTUyMmJmYzNmMGYyNmYzYTAyODEzMjg5N2UKLS0tIC9kZXYvbnVs bAorKysgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50 ZXItaW4taW5wdXQuaHRtbApAQCAtMCwwICsxLDUzIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1s PgorPGJvZHk+Cis8cD5UaGlzIHRlc3QgY2hlY2tzIHRoYXQgdHlwaW5nIEVudGVyIGludG8gYW4g aW5wdXQgZWxlbWVudCBkb2VzIG5vdCBmaXJlIGlucHV0IG9yIHRleHRJbnB1dC48YnI+CitUbyBy dW4gbWFudWFsbHksIHR5cGUgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgYmVsb3cuPC9wPgor PGZvcm0gaWQ9ImZvcm0iPgorPGlucHV0IGlkPSJlbCI+Cis8L2Zvcm0+Cis8YnI+Cis8ZGl2IGlk PSJyZXN1bHQiPjwvZGl2PgorPHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0PgorZnVu Y3Rpb24gbG9nKG1zZykgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJyku YXBwZW5kQ2hpbGQoZG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQorCit2 YXIgdW5leHBlY3RlZEV2ZW50cyA9IDA7Cit2YXIgZW50ZXJDaGFyID0gJ1xyJy5jaGFyQ29kZUF0 KDApOworZnVuY3Rpb24gZmFpbChldmVudCkgeworICAgIGlmIChsYXN0S2V5UHJlc3NlZCAhPSBl bnRlckNoYXIpIHsKKyAgICAgICAgbG9nKGV2ZW50LnR5cGUgKyAnIGZpcmVkLicpOworICAgICAg ICByZXR1cm47CisgICAgfQorCisgICAgdW5leHBlY3RlZEV2ZW50cysrOworICAgIGxvZygnVW5l eHBlY3RlZCAnICsgZXZlbnQudHlwZSArICcgZmlyZWQuJyk7CisgICAgcmVzdWx0LmlubmVySFRN TCA9ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiByZWQiPkZB SUw8L3NwYW4+JzsKK30KKwordmFyIGxhc3RLZXlQcmVzc2VkID0gMDsKK2VsLmFkZEV2ZW50TGlz dGVuZXIoJ2tleXByZXNzJywgZnVuY3Rpb24oZXZlbnQpIHsgbGFzdEtleVByZXNzZWQgPSBldmVu dC5rZXlDb2RlOyB9KTsKK2VsLmFkZEV2ZW50TGlzdGVuZXIoJ2lucHV0JywgZmFpbCk7CitlbC5h ZGRFdmVudExpc3RlbmVyKCd0ZXh0SW5wdXQnLCBmYWlsKTsKKworLy8gSWYgdGhlIGZvcm0gaXMg c3VibWl0dGVkIG9uIGVudGVyIGFuZCBubyB1bmV4cGVjdGVkIGV2ZW50IGhhcyBiZWVuIGZpcmVk LCBzdWNjZXNzIQorZm9ybS5hZGRFdmVudExpc3RlbmVyKCdzdWJtaXQnLCBmdW5jdGlvbihldmVu dCkgeworICAgIGlmICghdW5leHBlY3RlZEV2ZW50cyAmJiAhcmVzdWx0Lmhhc0NoaWxkTm9kZXMo KSkKKyAgICAgICAgcmVzdWx0LmlubmVySFRNTCA9ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4 OyBiYWNrZ3JvdW5kLWNvbG9yOiBncmVlbiI+U1VDQ0VTUzwvc3Bhbj4nOworCisgICAgZXZlbnQu cHJldmVudERlZmF1bHQoKTsKK30pOworCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVy KQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworZWwuZm9jdXMoKTsK K2lmICh3aW5kb3cuZXZlbnRTZW5kZXIpIHsKKyAgICBsb2coJ1xuU2VuZGluZyBFbnRlciB0byBp bnB1dCBlbGVtZW50Jyk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bignXHInLCBbXSk7Cit9Cis8 L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA2ZjQ5NjYzZTZiZjczMDlk NTgzYzQxYmVlZGRmMzcyNDJlNGZjM2YxLi44ZDk0MTUxNjQyMGE1OWJjMzk3ZmMxN2ExYTA2ZjQ1 NzU5MmRkMjRhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTEtMDItMjQgIEFsaWNl IEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgdHlwaW5nIGVudGVyIGluIHRoZSBpbnB1dCBlbGVt ZW50IHNob3VsZCBub3QgZmlyZSB0ZXh0SW5wdXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTU0MTUyCisKKyAgICAgICAgU3RvcCB0ZXh0SW5wdXQgZXZl bnQgcHJvcGFnYXRpb24gaW4gSFRNTElucHV0RWxlbWVudDo6cHJlRGlzcGF0Y2hFdmVudEhhbmRs ZXIgaWYgdGhlIGV2ZW50IHRhcmdldCBzaG91bGQgc3VibWl0IGltcGxpY2l0bHkuCisKKyAgICAg ICAgVGVzdDogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0 Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChX ZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50OjpwcmVEaXNwYXRjaEV2ZW50SGFuZGxlcik6IENoZWNr IG1faW5wdXRUeXBlLT5zaG91bGRTdWJtaXRJbXBsaWNpdGx5IGZvciB0ZXh0SW5wdXRFdmVudHMg YW5kIHN0b3AgcHJvcGFnYXRpb24gaWYgdHJ1ZS4KIDIwMTEtMDItMjQgIERhbiBCZXJuc3RlaW4g IDxtaXR6QGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBTaW1vbiBGcmFzZXIuCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAppbmRleCA2YzVmYzA1ZTdlOGJk YTU5ZmY3ODI5ODljMDA3NGU2YjJiZTM5ZDMxLi5hMjIxZDNlNWE5ZmYyMTYyMzQwNTk1YWZmZDEz NDZiMjA5ZjZiZTJmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVs ZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAK QEAgLTk2MSw2ICs5NjEsMTAgQEAgdm9pZCBIVE1MSW5wdXRFbGVtZW50OjpzZXRGaWxlTGlzdEZy b21SZW5kZXJlcihjb25zdCBWZWN0b3I8U3RyaW5nPiYgcGF0aHMpCiAKIHZvaWQqIEhUTUxJbnB1 dEVsZW1lbnQ6OnByZURpc3BhdGNoRXZlbnRIYW5kbGVyKEV2ZW50KiBldmVudCkKIHsKKyAgICBp ZiAoZXZlbnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCkudGV4dElucHV0RXZlbnQgJiYgbV9pbnB1 dFR5cGUtPnNob3VsZFN1Ym1pdEltcGxpY2l0bHkoZXZlbnQpKSB7CisgICAgICAgIGV2ZW50LT5z dG9wUHJvcGFnYXRpb24oKTsKKyAgICAgICAgcmV0dXJuIDA7CisgICAgfQogICAgIGlmIChldmVu dC0+dHlwZSgpICE9IGV2ZW50TmFtZXMoKS5jbGlja0V2ZW50KQogICAgICAgICByZXR1cm4gMDsK ICAgICBpZiAoIWV2ZW50LT5pc01vdXNlRXZlbnQoKSB8fCBzdGF0aWNfY2FzdDxNb3VzZUV2ZW50 Kj4oZXZlbnQpLT5idXR0b24oKSAhPSBMZWZ0QnV0dG9uKQo= 83767 2011-02-24 21:08:43 -0800 2011-02-24 21:52:01 -0800 Patch bug-54152-20110225160840.patch text/plain 9997 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogNzk2MzkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBjN2U5MzI1NDYwNjVkYzAwZDQ1ZTFm OTMyYWQ5MTRkYTZjOTM4YWE3Li5kMTlhZWI0Y2VjZjdjZGI1YWEzZjE4YWNmNWQwODY5NTk1MjNi MTAzIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTEtMDItMjQgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGVzdHMgdGhhdCB0eXBpbmcgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1l bnQgZG9lcyBub3QgZmlyZSB0ZXh0SW5wdXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01NDE1MgorCisgICAgICAgICogZmFzdC9mb3Jtcy90ZXh0aW5w dXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0 bWw6IEFkZGVkLgorCiAyMDExLTAyLTI0ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1 bS5vcmc+CiAKICAgICAgICAgQWRkIGNocm9taXVtIGJhc2VsaW5lcyBmb3IgbmV3IGZhc3QvYmxv Y2svcG9zaXRpb24vdmVydGljYWwtIHRlc3RzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0LWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1p bi1pbnB1dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNDIzZDNkYjkwZGFhM2YyNDQ1N2UyY2Yw Mjk5NmM4NDEyZGRiMGJkYQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9y bXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSw5IEBACitUaGlzIHRlc3QgY2hlY2tzIHRoYXQgdHlwaW5nIEVudGVyIGludG8gYW4g aW5wdXQgZWxlbWVudCBkb2VzIG5vdCBmaXJlIGlucHV0IG9yIHRleHRJbnB1dC4KK1RvIHJ1biBt YW51YWxseSwgdHlwZSBlbnRlciBpbiB0aGUgaW5wdXQgZWxlbWVudCBiZWxvdy4KKworCisKK1NV Q0NFU1MKKworU2VuZGluZyBFbnRlciB0byBpbnB1dCBlbGVtZW50CisKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1 dC5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVu dGVyLWluLWlucHV0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYWVkNDIyNTQyYmFlZGRkOGE0ZjE5Mjk5Mzcx YzZjOWZiYjQ2OTc2NAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMv dGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC5odG1sCkBAIC0wLDAgKzEsNjEg QEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxwPlRoaXMgdGVzdCBjaGVja3Mg dGhhdCB0eXBpbmcgRW50ZXIgaW50byBhbiBpbnB1dCBlbGVtZW50IGRvZXMgbm90IGZpcmUgaW5w dXQgb3IgdGV4dElucHV0Ljxicj4KK1RvIHJ1biBtYW51YWxseSwgdHlwZSBlbnRlciBpbiB0aGUg aW5wdXQgZWxlbWVudCBiZWxvdy48L3A+Cis8Zm9ybSBpZD0iZm9ybSI+Cis8aW5wdXQgaWQ9ImVs Ij4KKzwvZm9ybT4KKzxicj4KKzxkaXYgaWQ9InJlc3VsdCI+PC9kaXY+Cis8cHJlIGlkPSJjb25z b2xlIj48L3ByZT4KKzxzY3JpcHQ+CitmdW5jdGlvbiBsb2cobXNnKSB7CisgICAgZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2NvbnNvbGUnKS5hcHBlbmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0 Tm9kZShtc2cgKyAnXG4nKSk7Cit9CisKK3ZhciB1bmV4cGVjdGVkRXZlbnRzID0gMDsKK3ZhciBl bnRlckNoYXIgPSAnXHInLmNoYXJDb2RlQXQoMCk7CitmdW5jdGlvbiBmYWlsKGV2ZW50KSB7Cisg ICAgaWYgKGxhc3RLZXlQcmVzc2VkICE9IGVudGVyQ2hhcikgeworICAgICAgICBsb2coZXZlbnQu dHlwZSArICcgZmlyZWQuJyk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICB1bmV4cGVj dGVkRXZlbnRzKys7CisgICAgbG9nKCdVbmV4cGVjdGVkICcgKyBldmVudC50eXBlICsgJyBmaXJl ZC4nKTsKKyAgICByZXN1bHQuaW5uZXJIVE1MID0gJzxzcGFuIHN0eWxlPSJwYWRkaW5nOiA1cHg7 IGJhY2tncm91bmQtY29sb3I6IHJlZCI+RkFJTDwvc3Bhbj4nOworfQorCitmdW5jdGlvbiBzdWNj ZWVkSWZOb1VuZXhwZWN0ZWRFdmVudCgpIHsKKyAgICBpZiAoIXVuZXhwZWN0ZWRFdmVudHMgJiYg IXJlc3VsdC5oYXNDaGlsZE5vZGVzKCkpCisgICAgICAgIHJlc3VsdC5pbm5lckhUTUwgPSAnPHNw YW4gc3R5bGU9InBhZGRpbmc6IDVweDsgYmFja2dyb3VuZC1jb2xvcjogZ3JlZW4iPlNVQ0NFU1M8 L3NwYW4+JzsKK30KKwordmFyIGxhc3RLZXlQcmVzc2VkID0gMDsKK2VsLmFkZEV2ZW50TGlzdGVu ZXIoJ2tleXByZXNzJywgZnVuY3Rpb24oZXZlbnQpIHsgbGFzdEtleVByZXNzZWQgPSBldmVudC5r ZXlDb2RlOyB9KTsKK2VsLmFkZEV2ZW50TGlzdGVuZXIoJ2lucHV0JywgZmFpbCk7CitlbC5hZGRF dmVudExpc3RlbmVyKCd0ZXh0SW5wdXQnLCBmYWlsKTsKKworLy8gSWYgdGhlIGZvcm0gaXMgc3Vi bWl0dGVkIG9uIGVudGVyIGFuZCBubyB1bmV4cGVjdGVkIGV2ZW50IGhhcyBiZWVuIGZpcmVkLCBz dWNjZXNzIQorZm9ybS5hZGRFdmVudExpc3RlbmVyKCdzdWJtaXQnLCBmdW5jdGlvbihldmVudCkg eworICAgIHN1Y2NlZWRJZk5vVW5leHBlY3RlZEV2ZW50KCk7CisgICAgZXZlbnQucHJldmVudERl ZmF1bHQoKTsKK30pOworCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxh eW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworZWwuZm9jdXMoKTsKK2lmICh3aW5k b3cuZXZlbnRTZW5kZXIpIHsKKyAgICBsb2coJ1xuU2VuZGluZyBFbnRlciB0byBpbnB1dCBlbGVt ZW50Jyk7CisgICAgZXZlbnRTZW5kZXIua2V5RG93bignXHInLCBbXSk7CisKKyAgICAvLyBKdXN0 IGluIGNhc2Ugc29tZXRoaW5nIGdvZXMgd3Jvbmcgd2l0aCB0aGUgc3VibWl0IGV2ZW50LCB0aGVy ZSBhcmUgb3RoZXIgdGVzdHMgZm9yIHRoYXQKKyAgICBzdWNjZWVkSWZOb1VuZXhwZWN0ZWRFdmVu dCgpOworfSBlbHNlIHsKKyAgICBsb2coJ1RoaXMgdGVzdCByZXF1aXJlcyBldmVudFNlbmRlciB0 byBydW4gaW4gTGF5b3V0VGVzdHMuJyk7Cit9Cis8L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA0OTdjMWQyMzBiOTRjZTJkMjVkZmRiZjEzZDYwZjkyODEyMDZiMDI4Li42 ZjdmODhkYTQ1MTc3ZTllMjFjYTRlODFmNmM4MDE0MDM4YWVlYzAwIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMjcgQEAKKzIwMTEtMDItMjQgIEFsaWNlIEJveGhhbGwgIDxhYm94aGFsbEBjaHJvbWl1 bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAg dHlwaW5nIGVudGVyIGluIHRoZSBpbnB1dCBlbGVtZW50IHNob3VsZCBub3QgZmlyZSB0ZXh0SW5w dXQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTU0MTUy CisKKyAgICAgICAgU3RvcCB0ZXh0SW5wdXQgZXZlbnQgcHJvcGFnYXRpb24gaW4gRXZlbnRIYW5k bGVyOjpoYW5kbGVUZXh0SW5wdXRFdmVudCBpZiB0aGUgZXZlbnQgdGFyZ2V0IHNob3VsZCBzdWJt aXQgaW1wbGljaXRseS4KKyAgICAgICAgQWRkaXRpb25hbGx5LCBtYWtlcyB0aGUgZXhpc3Rpbmcg SW5wdXRUeXBlOjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KCkgbWV0aG9kIG9mZmljaWFsbHkgY29u c3QuCisKKyAgICAgICAgVGVzdDogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVu dGVyLWluLWlucHV0Lmh0bWwKKworICAgICAgICAqIGh0bWwvSFRNTElucHV0RWxlbWVudC5jcHA6 CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpI VE1MSW5wdXRFbGVtZW50OjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KTogQWRkIGlubGluZSBtZXRo b2QgZGVsZWdhdGluZyB0byBtX2lucHV0VHlwZS4KKyAgICAgICAgKiBodG1sL0lucHV0VHlwZS5j cHA6CisgICAgICAgIChXZWJDb3JlOjpJbnB1dFR5cGU6OnNob3VsZFN1Ym1pdEltcGxpY2l0bHkp OiBNYWtlIGNvbnN0LgorICAgICAgICAqIGh0bWwvSW5wdXRUeXBlLmg6CisgICAgICAgICogaHRt bC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEZpZWxkSW5w dXRUeXBlOjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KTogTWFrZSBjb25zdC4KKyAgICAgICAgKiBo dG1sL1RleHRGaWVsZElucHV0VHlwZS5oOgorICAgICAgICAqIHBhZ2UvRXZlbnRIYW5kbGVyLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OkV2ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0RXZlbnQp OiBDaGVjayBzaG91bGRTdWJtaXRJbXBsaWNpdGx5KCkgb24gdGhlIGV2ZW50IHRhcmdldCBhbmQg c3RvcCBldmVudCBwcm9wYWdhdGlvbiBpZiB0cnVlLgorCiAyMDExLTAyLTI0ICBKYW1lcyBSb2Jp bnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4g RmlzaGVyLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50 LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKaW5kZXggNmM1 ZmMwNWU3ZThiZGE1OWZmNzgyOTg5YzAwNzRlNmIyYmUzOWQzMS4uZmMzYmE5NzZlMWU4YjhmMDI5 NTE0YjA0NGEwYTBkMGZhNTY1MzhjNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVs ZW1lbnQuY3BwCkBAIC00MSw3ICs0MSw2IEBACiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCiAjaW5j bHVkZSAiSFRNTE9wdGlvbkVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MUGFyc2VySWRpb21zLmgi Ci0jaW5jbHVkZSAiSW5wdXRUeXBlLmgiCiAjaW5jbHVkZSAiS2V5Ym9hcmRFdmVudC5oIgogI2lu Y2x1ZGUgIkxvY2FsaXplZFN0cmluZ3MuaCIKICNpbmNsdWRlICJNb3VzZUV2ZW50LmgiCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaCBiL1NvdXJjZS9X ZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCmluZGV4IDc1Nzk5MmFkYTY3NTQyNjBmNjAx NDMzMTA3MzFiZGQ4ZmMwOGMwYTUuLjYxMThlMGMzMWMzMTE0NGM5ZDIwYWY1Y2Y2MTk3MjUwNTM2 Y2RmN2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCkBAIC0yNiw2ICsy Niw3IEBACiAKICNpbmNsdWRlICJIVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgiCiAjaW5jbHVkZSAi SW5wdXRFbGVtZW50LmgiCisjaW5jbHVkZSAiSW5wdXRUeXBlLmgiCiAKIG5hbWVzcGFjZSBXZWJD b3JlIHsKIApAQCAtMTgyLDYgKzE4Myw4IEBAIHB1YmxpYzoKICAgICB2b2lkIGFkZFNlYXJjaFJl c3VsdCgpOwogICAgIHZvaWQgb25TZWFyY2goKTsKIAorICAgIGJvb2wgc2hvdWxkU3VibWl0SW1w bGljaXRseShFdmVudCogZXZ0KSBjb25zdCB7IHJldHVybiBtX2lucHV0VHlwZS0+c2hvdWxkU3Vi bWl0SW1wbGljaXRseShldnQpOyB9CisKICNpZiBFTkFCTEUoREFUQUxJU1QpCiAgICAgSFRNTEVs ZW1lbnQqIGxpc3QoKSBjb25zdDsKICAgICBIVE1MT3B0aW9uRWxlbWVudCogc2VsZWN0ZWRPcHRp b24oKSBjb25zdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNw cCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmNwcAppbmRleCBiMmNjN2RlODFkMDZh N2E5ZWFiNjk0MTk4NWUzNTFjZDc3YjQ0YWUwLi45ZDU4N2UwYjc3NWVhOGUwZWZkODljMjgyYjk5 ZTg0MTBjZDBjZDE1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9JbnB1dFR5cGUuY3BwCkBAIC0zMzgsNyArMzM4 LDcgQEAgdm9pZCBJbnB1dFR5cGU6OmZvcndhcmRFdmVudChFdmVudCopCiB7CiB9CiAKLWJvb2wg SW5wdXRUeXBlOjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KEV2ZW50KiBldmVudCkKK2Jvb2wgSW5w dXRUeXBlOjpzaG91bGRTdWJtaXRJbXBsaWNpdGx5KEV2ZW50KiBldmVudCkgY29uc3QKIHsKICAg ICByZXR1cm4gZXZlbnQtPmlzS2V5Ym9hcmRFdmVudCgpICYmIGV2ZW50LT50eXBlKCkgPT0gZXZl bnROYW1lcygpLmtleXByZXNzRXZlbnQgJiYgc3RhdGljX2Nhc3Q8S2V5Ym9hcmRFdmVudCo+KGV2 ZW50KS0+Y2hhckNvZGUoKSA9PSAnXHInOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv aHRtbC9JbnB1dFR5cGUuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvSW5wdXRUeXBlLmgKaW5kZXgg ZWU1MzRlMDUyZGFlNzQ5YjM1NGZhNTg2ZWUwYjQwZTU2ZTJjMWViNy4uZjViZDU5ZDliN2ZiNjk1 OTMyODY5M2IxZDE1MWQ0MWIyOGI2ZDg3NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRt bC9JbnB1dFR5cGUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL0lucHV0VHlwZS5oCkBAIC0x NjcsNyArMTY3LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBoYW5kbGVXaGVlbEV2ZW50 KFdoZWVsRXZlbnQqKTsKICAgICB2aXJ0dWFsIHZvaWQgZm9yd2FyZEV2ZW50KEV2ZW50Kik7CiAg ICAgLy8gSGVscGVycyBmb3IgZXZlbnQgaGFuZGxlcnMuCi0gICAgdmlydHVhbCBib29sIHNob3Vs ZFN1Ym1pdEltcGxpY2l0bHkoRXZlbnQqKTsKKyAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkU3VibWl0 SW1wbGljaXRseShFdmVudCopIGNvbnN0OwogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxIVE1MRm9y bUVsZW1lbnQ+IGZvcm1Gb3JTdWJtaXNzaW9uKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIGlz S2V5Ym9hcmRGb2N1c2FibGUoKSBjb25zdDsKICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkVXNlSW5w dXRNZXRob2QoKSBjb25zdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZp ZWxkSW5wdXRUeXBlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBl LmNwcAppbmRleCAxZDA2YmUzYjIzYTY3NWY4YTkzNTczM2JlMGI5ZjY4ZmYzZjAzYzY5Li4xMDMy NzdkYzJhYzc1Zjk3YmUwODI1OWU1Y2E4MGJhMzdlMzM5NmM3IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv aHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuY3BwCkBAIC0xMDQsNyArMTA0LDcgQEAgdm9pZCBUZXh0 RmllbGRJbnB1dFR5cGU6OmZvcndhcmRFdmVudChFdmVudCogZXZlbnQpCiAgICAgICAgIHRvUmVu ZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5lKGVsZW1lbnQoKS0+cmVuZGVyZXIoKSktPmZvcndhcmRF dmVudChldmVudCk7CiB9CiAKLWJvb2wgVGV4dEZpZWxkSW5wdXRUeXBlOjpzaG91bGRTdWJtaXRJ bXBsaWNpdGx5KEV2ZW50KiBldmVudCkKK2Jvb2wgVGV4dEZpZWxkSW5wdXRUeXBlOjpzaG91bGRT dWJtaXRJbXBsaWNpdGx5KEV2ZW50KiBldmVudCkgY29uc3QKIHsKICAgICByZXR1cm4gKGV2ZW50 LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLnRleHRJbnB1dEV2ZW50ICYmIGV2ZW50LT5pc1RleHRF dmVudCgpICYmIHN0YXRpY19jYXN0PFRleHRFdmVudCo+KGV2ZW50KS0+ZGF0YSgpID09ICJcbiIp IHx8IElucHV0VHlwZTo6c2hvdWxkU3VibWl0SW1wbGljaXRseShldmVudCk7CiB9CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlwZS5oIGIvU291cmNlL1dl YkNvcmUvaHRtbC9UZXh0RmllbGRJbnB1dFR5cGUuaAppbmRleCA4NmFkMGVmMWFjZDRiYTZiMTlm MTFiYTg2Y2FhNGEwODcxODRlMThjLi4zOTUyNGZkNjRiNWFhMjdjMzM2NjUzZTE2YTQ2MWQzYjI5 ZWZjMTI3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL1RleHRGaWVsZElucHV0VHlw ZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvVGV4dEZpZWxkSW5wdXRUeXBlLmgKQEAgLTQ5 LDcgKzQ5LDcgQEAgcHJpdmF0ZToKICAgICB2aXJ0dWFsIGJvb2wgaXNUZXh0RmllbGQoKSBjb25z dDsKICAgICB2aXJ0dWFsIGJvb2wgdmFsdWVNaXNzaW5nKGNvbnN0IFN0cmluZyYpIGNvbnN0Owog ICAgIHZpcnR1YWwgdm9pZCBmb3J3YXJkRXZlbnQoRXZlbnQqKTsKLSAgICB2aXJ0dWFsIGJvb2wg c2hvdWxkU3VibWl0SW1wbGljaXRseShFdmVudCopOworICAgIHZpcnR1YWwgYm9vbCBzaG91bGRT dWJtaXRJbXBsaWNpdGx5KEV2ZW50KikgY29uc3Q7CiAgICAgdmlydHVhbCBSZW5kZXJPYmplY3Qq IGNyZWF0ZVJlbmRlcmVyKFJlbmRlckFyZW5hKiwgUmVuZGVyU3R5bGUqKSBjb25zdDsKICAgICB2 aXJ0dWFsIGJvb2wgc2hvdWxkVXNlSW5wdXRNZXRob2QoKSBjb25zdDsKICAgICB2aXJ0dWFsIFN0 cmluZyBzYW5pdGl6ZVZhbHVlKGNvbnN0IFN0cmluZyYgcHJvcG9zZWRWYWx1ZSk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wYWdlL0V2ZW50SGFuZGxlci5jcHAKaW5kZXggYWY2YzNmMjcxMGQ0ZjVlZGU4ZTJiNzdkODUx NWMyOWNiMDhmZTJjMy4uOGFlZDZmOGExOTk1NzYzZjg3NTA2Y2M2MGMwNzBiZjI4NDkwNmRhYyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9FdmVudEhhbmRsZXIuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvRXZlbnRIYW5kbGVyLmNwcApAQCAtMjcyMiwxMSArMjcyMiwxNiBA QCBib29sIEV2ZW50SGFuZGxlcjo6aGFuZGxlVGV4dElucHV0RXZlbnQoY29uc3QgU3RyaW5nJiB0 ZXh0LCBFdmVudCogdW5kZXJseWluZ0V2ZQogICAgIFJlZlB0cjxUZXh0RXZlbnQ+IGV2ZW50ID0g VGV4dEV2ZW50OjpjcmVhdGUobV9mcmFtZS0+ZG9tV2luZG93KCksIHRleHQsIGlucHV0VHlwZSk7 CiAgICAgZXZlbnQtPnNldFVuZGVybHlpbmdFdmVudCh1bmRlcmx5aW5nRXZlbnQpOwogCisgICAg Tm9kZSogdGFyZ2V0Tm9kZSA9IHRhcmdldC0+dG9Ob2RlKCk7CisgICAgaWYgKHRhcmdldE5vZGUg JiYgdGFyZ2V0Tm9kZS0+aGFzVGFnTmFtZShpbnB1dFRhZykKKyAgICAgICAgJiYgc3RhdGljX2Nh c3Q8SFRNTElucHV0RWxlbWVudCo+KHRhcmdldE5vZGUpLT5zaG91bGRTdWJtaXRJbXBsaWNpdGx5 KGV2ZW50LmdldCgpKSkKKyAgICAgICAgZXZlbnQtPnN0b3BQcm9wYWdhdGlvbigpOworCiAgICAg RXhjZXB0aW9uQ29kZSBlYzsKICAgICB0YXJnZXQtPmRpc3BhdGNoRXZlbnQoZXZlbnQsIGVjKTsK ICAgICByZXR1cm4gZXZlbnQtPmRlZmF1bHRIYW5kbGVkKCk7CiB9Ci0gICAgCisKICNpZiAhUExB VEZPUk0oTUFDKSAmJiAhUExBVEZPUk0oUVQpICYmICFQTEFURk9STShIQUlLVSkgJiYgIVBMQVRG T1JNKEVGTCkKIGJvb2wgRXZlbnRIYW5kbGVyOjppbnZlcnRTZW5zZU9mVGFic1RvTGlua3MoS2V5 Ym9hcmRFdmVudCopIGNvbnN0CiB7Cg== 83770 2011-02-24 21:52:08 -0800 2011-02-26 04:12:34 -0800 Patch bug-54152-20110225165205.patch text/plain 5037 aboxhall U3VidmVyc2lvbiBSZXZpc2lvbjogNzk2NTkKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBiNzkyZWRhYTY3ZWU0MWM1N2RmMzY3 OWRiZDQ2ZmVmZDg2YmFhN2IxLi5iNDA3ODJlOTY1MmQyMjBiMTM2NGYxNWMxZmNiNjNlZjkyOTU5 MDFiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTEtMDItMjQgIEFsaWNlIEJveGhhbGwgIDxh Ym94aGFsbEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BT ISkuCisKKyAgICAgICAgVGVzdHMgdGhhdCB0eXBpbmcgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1l bnQgZG9lcyBub3QgZmlyZSB0ZXh0SW5wdXQuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD01NDE1MgorCisgICAgICAgICogZmFzdC9mb3Jtcy90ZXh0aW5w dXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZmFzdC9mb3Jtcy90ZXh0aW5wdXQtbm90LWZpcmVkLW9uLWVudGVyLWluLWlucHV0Lmh0 bWw6IEFkZGVkLgorCiAyMDExLTAyLTI0ICBEYW4gQmVybnN0ZWluICA8bWl0ekBhcHBsZS5jb20+ CiAKICAgICAgICAgVXBkYXRlZCByZXN1bHRzIGFmdGVyIHI3OTYyOS4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5vdC1maXJlZC1vbi1lbnRlci1pbi1pbnB1 dC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmly ZWQtb24tZW50ZXItaW4taW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQyM2QzZGI5MGRh YTNmMjQ0NTdlMmNmMDI5OTZjODQxMmRkYjBiZGEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQtZXhw ZWN0ZWQudHh0CkBAIC0wLDAgKzEsOSBAQAorVGhpcyB0ZXN0IGNoZWNrcyB0aGF0IHR5cGluZyBF bnRlciBpbnRvIGFuIGlucHV0IGVsZW1lbnQgZG9lcyBub3QgZmlyZSBpbnB1dCBvciB0ZXh0SW5w dXQuCitUbyBydW4gbWFudWFsbHksIHR5cGUgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgYmVs b3cuCisKKworCitTVUNDRVNTCisKK1NlbmRpbmcgRW50ZXIgdG8gaW5wdXQgZWxlbWVudAorCmRp ZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24t ZW50ZXItaW4taW5wdXQuaHRtbCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvdGV4dGlucHV0LW5v dC1maXJlZC1vbi1lbnRlci1pbi1pbnB1dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE2MmI2MDc1ZTE1NmRi Njc5MTAwZGI4M2Q2MDdjYjA5MWNjOGYxNDUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2Zvcm1zL3RleHRpbnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQuaHRtbApA QCAtMCwwICsxLDU1IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJvZHk+Cis8cD5UaGlz IHRlc3QgY2hlY2tzIHRoYXQgdHlwaW5nIEVudGVyIGludG8gYW4gaW5wdXQgZWxlbWVudCBkb2Vz IG5vdCBmaXJlIGlucHV0IG9yIHRleHRJbnB1dC48YnI+CitUbyBydW4gbWFudWFsbHksIHR5cGUg ZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgYmVsb3cuPC9wPgorPGZvcm0gaWQ9ImZvcm0iPgor PGlucHV0IGlkPSJlbCI+Cis8L2Zvcm0+Cis8YnI+Cis8ZGl2IGlkPSJyZXN1bHQiPjwvZGl2Pgor PHByZSBpZD0iY29uc29sZSI+PC9wcmU+Cis8c2NyaXB0PgorZnVuY3Rpb24gbG9nKG1zZykgewor ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdjb25zb2xlJykuYXBwZW5kQ2hpbGQoZG9jdW1l bnQuY3JlYXRlVGV4dE5vZGUobXNnICsgJ1xuJykpOworfQorCit2YXIgdW5leHBlY3RlZEV2ZW50 cyA9IDA7Cit2YXIgZW50ZXJDaGFyID0gJ1xyJy5jaGFyQ29kZUF0KDApOworZnVuY3Rpb24gZmFp bChldmVudCkgeworICAgIGlmIChsYXN0S2V5UHJlc3NlZCAhPSBlbnRlckNoYXIpIHsKKyAgICAg ICAgbG9nKGV2ZW50LnR5cGUgKyAnIGZpcmVkLicpOworICAgICAgICByZXR1cm47CisgICAgfQor CisgICAgdW5leHBlY3RlZEV2ZW50cysrOworICAgIGxvZygnVW5leHBlY3RlZCAnICsgZXZlbnQu dHlwZSArICcgZmlyZWQuJyk7CisgICAgcmVzdWx0LmlubmVySFRNTCA9ICc8c3BhbiBzdHlsZT0i cGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9yOiByZWQiPkZBSUw8L3NwYW4+JzsKK30KKwor dmFyIGxhc3RLZXlQcmVzc2VkID0gMDsKK2VsLmFkZEV2ZW50TGlzdGVuZXIoJ2tleXByZXNzJywg ZnVuY3Rpb24oZXZlbnQpIHsgbGFzdEtleVByZXNzZWQgPSBldmVudC5rZXlDb2RlOyB9KTsKK2Vs LmFkZEV2ZW50TGlzdGVuZXIoJ2lucHV0JywgZmFpbCk7CitlbC5hZGRFdmVudExpc3RlbmVyKCd0 ZXh0SW5wdXQnLCBmYWlsKTsKKworLy8gSWYgdGhlIGZvcm0gaXMgc3VibWl0dGVkIG9uIGVudGVy IGFuZCBubyB1bmV4cGVjdGVkIGV2ZW50IGhhcyBiZWVuIGZpcmVkLCBzdWNjZXNzIQorZm9ybS5h ZGRFdmVudExpc3RlbmVyKCdzdWJtaXQnLCBmdW5jdGlvbihldmVudCkgeworICAgIGlmICghdW5l eHBlY3RlZEV2ZW50cyAmJiAhcmVzdWx0Lmhhc0NoaWxkTm9kZXMoKSkKKyAgICAgICAgcmVzdWx0 LmlubmVySFRNTCA9ICc8c3BhbiBzdHlsZT0icGFkZGluZzogNXB4OyBiYWNrZ3JvdW5kLWNvbG9y OiBncmVlbiI+U1VDQ0VTUzwvc3Bhbj4nOworCisgICAgZXZlbnQucHJldmVudERlZmF1bHQoKTsK K30pOworCitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgIGxheW91dFRlc3RD b250cm9sbGVyLmR1bXBBc1RleHQoKTsKKworZWwuZm9jdXMoKTsKK2lmICh3aW5kb3cuZXZlbnRT ZW5kZXIpIHsKKyAgICBsb2coJ1xuU2VuZGluZyBFbnRlciB0byBpbnB1dCBlbGVtZW50Jyk7Cisg ICAgZXZlbnRTZW5kZXIua2V5RG93bignXHInLCBbXSk7Cit9IGVsc2UgaWYgKHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlcikKKyAgICBsb2coJ1RoaXMgdGVzdCByZXF1aXJlcyBldmVudFNlbmRl ciB0byBydW4gaW4gTGF5b3V0VGVzdHMuJyk7CisKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1s PgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dlYkNvcmUv Q2hhbmdlTG9nCmluZGV4IDFmYWE5ZDRjMmE4Nzg1NGFiN2NhZjA0OWYxOGFlODQyYmFlZjdhNDku LmEyZjU1ZGZmMTM0ZTc2MDAwMzdiZmY3MzY4MjA0YTA2ZTEyZjk0NDcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKQEAg LTEsMyArMSwxNyBAQAorMjAxMS0wMi0yNCAgQWxpY2UgQm94aGFsbCAgPGFib3hoYWxsQGNocm9t aXVtLm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICB0eXBpbmcgZW50ZXIgaW4gdGhlIGlucHV0IGVsZW1lbnQgc2hvdWxkIG5vdCBmaXJlIHRleHRJ bnB1dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NTQx NTIKKworICAgICAgICBTdG9wIHRleHRJbnB1dCBldmVudCBwcm9wYWdhdGlvbiBpbiBIVE1MSW5w dXRFbGVtZW50OjpwcmVEaXNwYXRjaEV2ZW50SGFuZGxlciBpZiB0aGUgZXZlbnQgdGFyZ2V0IHNo b3VsZCBzdWJtaXQgaW1wbGljaXRseS4KKworICAgICAgICBUZXN0OiBmYXN0L2Zvcm1zL3RleHRp bnB1dC1ub3QtZmlyZWQtb24tZW50ZXItaW4taW5wdXQuaHRtbAorCisgICAgICAgICogaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6 OnByZURpc3BhdGNoRXZlbnRIYW5kbGVyKTogQ2hlY2sgbV9pbnB1dFR5cGUtPnNob3VsZFN1Ym1p dEltcGxpY2l0bHkgZm9yIHRleHRJbnB1dEV2ZW50cyBhbmQgc3RvcCBwcm9wYWdhdGlvbiBpZiB0 cnVlLgorCiAyMDExLTAyLTI0ICBKYW1lcyBSb2JpbnNvbiAgPGphbWVzckBjaHJvbWl1bS5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgS2VubmV0aCBSdXNzZWxsLgpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0 bWwvSFRNTElucHV0RWxlbWVudC5jcHAKaW5kZXggNmM1ZmMwNWU3ZThiZGE1OWZmNzgyOTg5YzAw NzRlNmIyYmUzOWQzMS4uYTIyMWQzZTVhOWZmMjE2MjM0MDU5NWFmZmQxMzQ2YjIwOWY2YmUyZiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCkBAIC05NjEsNiArOTYx LDEwIEBAIHZvaWQgSFRNTElucHV0RWxlbWVudDo6c2V0RmlsZUxpc3RGcm9tUmVuZGVyZXIoY29u c3QgVmVjdG9yPFN0cmluZz4mIHBhdGhzKQogCiB2b2lkKiBIVE1MSW5wdXRFbGVtZW50OjpwcmVE aXNwYXRjaEV2ZW50SGFuZGxlcihFdmVudCogZXZlbnQpCiB7CisgICAgaWYgKGV2ZW50LT50eXBl KCkgPT0gZXZlbnROYW1lcygpLnRleHRJbnB1dEV2ZW50ICYmIG1faW5wdXRUeXBlLT5zaG91bGRT dWJtaXRJbXBsaWNpdGx5KGV2ZW50KSkgeworICAgICAgICBldmVudC0+c3RvcFByb3BhZ2F0aW9u KCk7CisgICAgICAgIHJldHVybiAwOworICAgIH0KICAgICBpZiAoZXZlbnQtPnR5cGUoKSAhPSBl dmVudE5hbWVzKCkuY2xpY2tFdmVudCkKICAgICAgICAgcmV0dXJuIDA7CiAgICAgaWYgKCFldmVu dC0+aXNNb3VzZUV2ZW50KCkgfHwgc3RhdGljX2Nhc3Q8TW91c2VFdmVudCo+KGV2ZW50KS0+YnV0 dG9uKCkgIT0gTGVmdEJ1dHRvbikK