82461 2012-03-28 06:33:41 -0700 [Chromium] Implement a Layout Test for editing/SurroundingText 2012-07-02 17:53:52 -0700 1 1 1 Unclassified WebKit WebKit Misc. 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 82460 66687 1 leandrogracia leandrogracia abarth dglazkov fishd jamesr rniwa steveblock tkent tkent+wkapi tonyg webkit.review.bot oldest_to_newest 589912 0 leandrogracia 2012-03-28 06:33:41 -0700 Once the WebKit embedder is available, update DumpRenderTree in order to provide a new Layout Test for the SurroundingText feature in WebCore. 638512 1 145109 leandrogracia 2012-05-31 09:53:39 -0700 Created attachment 145109 Patch 638884 2 145109 tkent 2012-05-31 18:35:44 -0700 Comment on attachment 145109 Patch Please consider using window.internals instead of layoutTestController. 652190 3 145109 rniwa 2012-06-19 01:12:17 -0700 Comment on attachment 145109 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=145109&action=review > Tools/DumpRenderTree/chromium/WebViewHost.cpp:884 > +WebKit::WebString WebViewHost::textSurroundingElement(const WebKit::WebString& elementId, unsigned offset, unsigned maxLength) > +{ > + // To make testing easier, access an element by its id first. > + WebDocument document = webView()->mainFrame()->document(); > + WebElement element = document.getElementById(elementId); > + if (element.isNull()) > + return WebString(); > + > + // Then try to get its first child if present. Otherwise use is next sibling. > + // In any case it should be the text node we're referring to for content search. > + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); > + if (node.isNull() || !node.isTextNode() || offset >= node.nodeValue().length()) > + return WebString(); > + > + WebSurroundingText surroundingText; > + surroundingText.initialize(node, offset, maxLength); > + return surroundingText.textContent(); > +} r- because we shouldn't be adding this much code just for testing purpose. > LayoutTests/platform/chromium/fast/text/surrounding-text-expected.txt:15 > +.12345 > +6789 12345 > + > +6789. > +57th Street and Lake Shore Drive > +Chicago IL 60637 . > +12345abc > +6789 > +12345 > + > +67890123. > +This is a test example . > +012345678901234567890123456789 > +. 12345test 12345test > +Test the extraction of the text surrounding an element. Please hide this. > LayoutTests/platform/chromium/fast/text/surrounding-text-expected.txt:31 > +PASS surroundingText("test1", 0, 100) is "12345 6789 12345 6789" > +PASS surroundingText("test1", 5, 6) is "89 123" > +PASS surroundingText("test1", 5, 0) is "" > +PASS surroundingText("test1", 5, 1) is "1" > +PASS surroundingText("test1", 6, 2) is "12" > +PASS surroundingText("test2", 0, 100) is "57th Street and Lake Shore Drive Chicago IL 60637" > +PASS surroundingText("test3", 0, 100) is "6789 12345 6789" > +PASS surroundingText("test4", 0, 100) is "This is a test example" > +PASS surroundingText("test5", 15, 12) is "901234567890" > +PASS surroundingText("test6", 0, 100) is "" > +PASS surroundingText("test7", 0, 100) is "" > +PASS successfullyParsed is true This output isn't helpful because it doesn't tell us what they're testing. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:8 > +<!-- Test exploration (limited by form control elements) --!> All these comments are pure noise to me. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:49 > + shouldBeEqualToString('surroundingText("test1", 0, 100)', '12345 6789 12345 6789'); > + shouldBeEqualToString('surroundingText("test1", 5, 6)', '89 123'); > + shouldBeEqualToString('surroundingText("test1", 5, 0)', ''); > + shouldBeEqualToString('surroundingText("test1", 5, 1)', '1'); > + shouldBeEqualToString('surroundingText("test1", 6, 2)', '12'); > + shouldBeEqualToString('surroundingText("test2", 0, 100)', '57th Street and Lake Shore Drive Chicago IL 60637'); > + shouldBeEqualToString('surroundingText("test3", 0, 100)', '6789 12345 6789'); > + shouldBeEqualToString('surroundingText("test4", 0, 100)', 'This is a test example'); > + shouldBeEqualToString('surroundingText("test5", 15, 12)', '901234567890'); > + shouldBeEqualToString('surroundingText("test6", 0, 100)', ''); > + shouldBeEqualToString('surroundingText("test7", 0, 100)', ''); For these test cases and expectations to make sense, we need to also dump the markup or the test markup needs to be dynamically created within shouldBeEqualToString as in: shouldBeEqualToString('surroundingText("<button>.</button>12345<p id="test1">6789 12345</p>6789<button>.</button>")', '12345 6789 12345 6789'); 652191 4 rniwa 2012-06-19 01:12:33 -0700 Please use internals as tkent suggested. 652345 5 145109 leandrogracia 2012-06-19 05:44:14 -0700 Comment on attachment 145109 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=145109&action=review Taking a look to all other comments. Thanks for reviewing. >> Tools/DumpRenderTree/chromium/WebViewHost.cpp:884 >> +} > > r- because we shouldn't be adding this much code just for testing purpose. Any suggestions about how to test the feature without adding this code? We need to provide a valid text node + offset in order to retrieve the contents. 652568 6 rniwa 2012-06-19 10:27:56 -0700 (In reply to comment #5) > (From update of attachment 145109 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=145109&action=review > > Taking a look to all other comments. Thanks for reviewing. > > >> Tools/DumpRenderTree/chromium/WebViewHost.cpp:884 > >> +} > > > > r- because we shouldn't be adding this much code just for testing purpose. > > Any suggestions about how to test the feature without adding this code? We need to provide a valid text node + offset in order to retrieve the contents. Then the function should take a text node, offset, and maximum length. 652576 7 leandrogracia 2012-06-19 10:37:43 -0700 (In reply to comment #6) > (In reply to comment #5) > > (From update of attachment 145109 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=145109&action=review > > > > Taking a look to all other comments. Thanks for reviewing. > > > > >> Tools/DumpRenderTree/chromium/WebViewHost.cpp:884 > > >> +} > > > > > > r- because we shouldn't be adding this much code just for testing purpose. > > > > Any suggestions about how to test the feature without adding this code? We need to provide a valid text node + offset in order to retrieve the contents. > > Then the function should take a text node, offset, and maximum length. Are you ok if what this code does (getting the text node from an adjacent node by its id) is moved to js? Otherwise pointing what to test can become quite obscure. 652580 8 rniwa 2012-06-19 10:41:27 -0700 (In reply to comment #7) > Are you ok if what this code does (getting the text node from an adjacent node by its id) is moved to js? Otherwise pointing what to test can become quite obscure. That's fine. 652593 9 leandrogracia 2012-06-19 10:48:16 -0700 (In reply to comment #8) > (In reply to comment #7) > > Are you ok if what this code does (getting the text node from an adjacent node by its id) is moved to js? Otherwise pointing what to test can become quite obscure. > > That's fine. I'll try that. Thanks. 656783 10 149339 leandrogracia 2012-06-25 12:29:12 -0700 Created attachment 149339 Patch 656784 11 145109 leandrogracia 2012-06-25 12:29:44 -0700 Comment on attachment 145109 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=145109&action=review >> LayoutTests/platform/chromium/fast/text/surrounding-text-expected.txt:15 >> +Test the extraction of the text surrounding an element. > > Please hide this. Done. >> LayoutTests/platform/chromium/fast/text/surrounding-text-expected.txt:31 >> +PASS successfullyParsed is true > > This output isn't helpful because it doesn't tell us what they're testing. Fixed. >> LayoutTests/platform/chromium/fast/text/surrounding-text.html:8 >> +<!-- Test exploration (limited by form control elements) --!> > > All these comments are pure noise to me. Removed. >> LayoutTests/platform/chromium/fast/text/surrounding-text.html:49 >> + shouldBeEqualToString('surroundingText("test7", 0, 100)', ''); > > For these test cases and expectations to make sense, we need to also dump the markup or the test markup needs to be dynamically created within shouldBeEqualToString as in: > shouldBeEqualToString('surroundingText("<button>.</button>12345<p id="test1">6789 12345</p>6789<button>.</button>")', '12345 6789 12345 6789'); Done. 656785 12 149339 leandrogracia 2012-06-25 12:31:51 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review > Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 > + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. 656817 13 149339 rniwa 2012-06-25 13:31:55 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review > Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2331 > + WebString elementId = WebString::fromUTF8(arguments[0].toString()); > + WebElement element = webFrame->document().getElementById(elementId); > + if (element.isNull()) { > + result->setNull(); > + return; > + } What!? I thought I made clear that this function should take a Text node as an argument. r- because of this. >> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); > > Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. What why do we need to fallback to nextSibling when element doesn't have any children? We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. 656856 14 149339 leandrogracia 2012-06-25 14:23:56 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review >> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2331 >> + } > > What!? I thought I made clear that this function should take a Text node as an argument. r- because of this. WebViewHost::textSurroundingElement is the one taking a text node now. I'd gladly do the same here and move these operations to javascript, but I cannot convert an argument to a node. That forces me to use strings with the id as the rest of the code in this file does. I'm open to alternatives. >>> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >>> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); >> >> Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. > > What why do we need to fallback to nextSibling when element doesn't have any children? > We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. Because since we cannot pass a node we need to pass its id. Therefore, we cannot directly pass text nodes but nodes that are by them or containing them. If you have any suggestions to easily point specific text nodes from the test I'll be happy to follow it. 656892 15 149339 rniwa 2012-06-25 14:50:18 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review >>>> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >>>> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); >>> >>> Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. >> >> What why do we need to fallback to nextSibling when element doesn't have any children? >> We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. > > Because since we cannot pass a node we need to pass its id. Therefore, we cannot directly pass text nodes but nodes that are by them or containing them. If you have any suggestions to easily point specific text nodes from the test I'll be happy to follow it. Why you can't pass a node? 656893 16 149339 rniwa 2012-06-25 14:50:22 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review >>>> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >>>> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); >>> >>> Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. >> >> What why do we need to fallback to nextSibling when element doesn't have any children? >> We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. > > Because since we cannot pass a node we need to pass its id. Therefore, we cannot directly pass text nodes but nodes that are by them or containing them. If you have any suggestions to easily point specific text nodes from the test I'll be happy to follow it. Why you can't pass a node? 656988 17 149339 leandrogracia 2012-06-25 16:25:54 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review >>>>>> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >>>>>> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); >>>>> >>>>> Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. >>>> >>>> What why do we need to fallback to nextSibling when element doesn't have any children? >>>> We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. >>> >>> Because since we cannot pass a node we need to pass its id. Therefore, we cannot directly pass text nodes but nodes that are by them or containing them. If you have any suggestions to easily point specific text nodes from the test I'll be happy to follow it. >> >> Why you can't pass a node? > > Why you can't pass a node? CppVariant (CppArgumentList is a vector of CppVariants) doesn't implement toObject or any other method that would allow me to retrieve the node from the argument. Please correct me if I'm wrong. 656995 18 149339 rniwa 2012-06-25 16:33:35 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review >>>>>>> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >>>>>>> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); >>>>>> >>>>>> Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. >>>>> >>>>> What why do we need to fallback to nextSibling when element doesn't have any children? >>>>> We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. >>>> >>>> Because since we cannot pass a node we need to pass its id. Therefore, we cannot directly pass text nodes but nodes that are by them or containing them. If you have any suggestions to easily point specific text nodes from the test I'll be happy to follow it. >>> >>> Why you can't pass a node? >> >> Why you can't pass a node? > > CppVariant (CppArgumentList is a vector of CppVariants) doesn't implement toObject or any other method that would allow me to retrieve the node from the argument. Please correct me if I'm wrong. There is WebBinding::GetElement. You should be able to create a similar function here. Take a look at getElementImpl. 657839 19 149339 leandrogracia 2012-06-26 12:20:03 -0700 Comment on attachment 149339 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149339&action=review >>>>>>>> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:2333 >>>>>>>> + WebNode node = element.hasChildNodes() ? element.firstChild() : element.nextSibling(); >>>>>>> >>>>>>> Couldn't move this further into JS since elements cannot be directly retrieved from arguments. Other methods in this file use the id string for this same purpose. >>>>>> >>>>>> What why do we need to fallback to nextSibling when element doesn't have any children? >>>>>> We shouldn't be doing these crazy black magic behind the scene especially for the testing APIs. >>>>> >>>>> Because since we cannot pass a node we need to pass its id. Therefore, we cannot directly pass text nodes but nodes that are by them or containing them. If you have any suggestions to easily point specific text nodes from the test I'll be happy to follow it. >>>> >>>> Why you can't pass a node? >>> >>> Why you can't pass a node? >> >> CppVariant (CppArgumentList is a vector of CppVariants) doesn't implement toObject or any other method that would allow me to retrieve the node from the argument. Please correct me if I'm wrong. > > There is WebBinding::GetElement. You should be able to create a similar function here. Take a look at getElementImpl. Thanks for the suggestion. I'm doing that. 657847 20 149586 leandrogracia 2012-06-26 12:26:33 -0700 Created attachment 149586 Patch 657851 21 webkit.review.bot 2012-06-26 12:29:31 -0700 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 657910 22 149586 rniwa 2012-06-26 13:17:56 -0700 Comment on attachment 149586 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149586&action=review > Source/WebKit/chromium/public/WebBindings.h:158 > + // Return true (success) if the given npobj is a node. > + // If so, return that element as a WebNode object. > + WEBKIT_EXPORT static bool getNode(NPObject* element, WebNode*); > + I don't think you need to add this function. Just put the implementation in LayoutTestController.cpp > LayoutTests/platform/chromium/fast/text/surrounding-text.html:17 > + var test = document.getElementById('test'); > + test.innerHTML = html; It seems like we don't nee this local variable. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:22 > + if (here == null) { > + throw 'Test case needs an element with id "here"'; > + } No curly brackets around single line statements. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:27 > + if (node == null) { > + throw 'No node after "here" element'; > + } Ditto. 657911 23 149586 rniwa 2012-06-26 13:18:04 -0700 Comment on attachment 149586 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149586&action=review > Source/WebKit/chromium/public/WebBindings.h:158 > + // Return true (success) if the given npobj is a node. > + // If so, return that element as a WebNode object. > + WEBKIT_EXPORT static bool getNode(NPObject* element, WebNode*); > + I don't think you need to add this function. Just put the implementation in LayoutTestController.cpp > LayoutTests/platform/chromium/fast/text/surrounding-text.html:17 > + var test = document.getElementById('test'); > + test.innerHTML = html; It seems like we don't nee this local variable. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:22 > + if (here == null) { > + throw 'Test case needs an element with id "here"'; > + } No curly brackets around single line statements. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:27 > + if (node == null) { > + throw 'No node after "here" element'; > + } Ditto. 657918 24 149586 leandrogracia 2012-06-26 13:25:52 -0700 Comment on attachment 149586 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149586&action=review Thanks for the review. I'll apply the changes in your comments tomorrow. >>> Source/WebKit/chromium/public/WebBindings.h:158 >>> + >> >> I don't think you need to add this function. Just put the implementation in LayoutTestController.cpp > > I don't think you need to add this function. Just put the implementation in LayoutTestController.cpp I'll do that. In that case there won't be any change to the WebKit API after the next patch. 658524 25 149724 leandrogracia 2012-06-27 04:25:56 -0700 Created attachment 149724 Patch 658525 26 149586 leandrogracia 2012-06-27 04:27:39 -0700 Comment on attachment 149586 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149586&action=review >>>> Source/WebKit/chromium/public/WebBindings.h:158 >>>> + >>> >>> I don't think you need to add this function. Just put the implementation in LayoutTestController.cpp >> >> I don't think you need to add this function. Just put the implementation in LayoutTestController.cpp > > I'll do that. In that case there won't be any change to the WebKit API after the next patch. It seems this was not a good idea after all. Moving this functionality to LayoutTestController introduces a layering violation as it will depend on NPV8Objects, V8Nodes and other classes that are defined in WebCore. In fact trying to include them doesn't work. I think adding this function to WebBindings is the best and cleanest way to solve the issue. >>> LayoutTests/platform/chromium/fast/text/surrounding-text.html:17 >>> + test.innerHTML = html; >> >> It seems like we don't nee this local variable. > > It seems like we don't nee this local variable. Fixed. >>> LayoutTests/platform/chromium/fast/text/surrounding-text.html:22 >>> + } >> >> No curly brackets around single line statements. > > No curly brackets around single line statements. Fixed. >>> LayoutTests/platform/chromium/fast/text/surrounding-text.html:27 >>> + } >> >> Ditto. > > Ditto. Fixed. 661575 27 149724 abarth 2012-07-02 10:01:33 -0700 Comment on attachment 149724 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=149724&action=review Thanks for addressing rniwa's comments. > Source/WebKit/chromium/public/WebBindings.h:157 > + // Return true (success) if the given npobj is a node. > + // If so, return that element as a WebNode object. > + WEBKIT_EXPORT static bool getNode(NPObject* element, WebNode*); This is a sensible function to expose here. It's analogous to getElement below. > LayoutTests/platform/chromium/fast/text/surrounding-text.html:15 > +function surroundingText(html, offset, maxLength) { You're mixing your indent level a bit here. We generally prefer four-space indent. 661584 28 150441 abarth 2012-07-02 10:15:34 -0700 Created attachment 150441 Patch for landing 661587 29 150441 leandrogracia 2012-07-02 10:21:03 -0700 Comment on attachment 150441 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=150441&action=review > Source/WebKit/chromium/public/WebBindings.h:156 > + // If so, return that element as a WebNode object. There's a minor nit here I was going to fix. It should say "return that element" when it should be "return that node". 661591 30 150444 leandrogracia 2012-07-02 10:22:07 -0700 Created attachment 150444 Patch 661592 31 150441 leandrogracia 2012-07-02 10:22:42 -0700 Comment on attachment 150441 Patch for landing View in context: https://bugs.webkit.org/attachment.cgi?id=150441&action=review >> Source/WebKit/chromium/public/WebBindings.h:156 >> + // If so, return that element as a WebNode object. > > There's a minor nit here I was going to fix. It should say "return that element" when it should be "return that node". Fixed. 661595 32 150444 rniwa 2012-07-02 10:26:20 -0700 Comment on attachment 150444 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=150444&action=review > Source/WebKit/chromium/ChangeLog:8 > + Reviewed by NOBODY (OOPS!). This line should appear before the description. > Tools/ChangeLog:9 > + Reviewed by NOBODY (OOPS!). Ditto. > Tools/DumpRenderTree/chromium/WebViewHost.h:132 > + WebKit::WebString textSurroundingElement(const WebKit::WebNode&, unsigned offset, unsigned maxLength); > + Why are we adding this to WebView? > LayoutTests/ChangeLog:11 > + * platform/chromium/fast/text/surrounding-text-expected.txt: Added. > + * platform/chromium/fast/text/surrounding-text.html: Added. This test doesn't belong in fast/text. It should be in editing. 661596 33 abarth 2012-07-02 10:30:10 -0700 (In reply to comment #32) > (From update of attachment 150444 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=150444&action=review > > > Source/WebKit/chromium/ChangeLog:8 > > + Reviewed by NOBODY (OOPS!). > > This line should appear before the description. You keep complaining about this issue, but I'm not sure it matters. > > Tools/DumpRenderTree/chromium/WebViewHost.h:132 > > + WebKit::WebString textSurroundingElement(const WebKit::WebNode&, unsigned offset, unsigned maxLength); > > + > > Why are we adding this to WebView? Do you mean WebViewHost? It looks like the code could go into LayoutTestController.cpp, but I'm not sure it matters much one way or another. 661617 34 rniwa 2012-07-02 11:13:11 -0700 (In reply to comment #33) > > > Tools/DumpRenderTree/chromium/WebViewHost.h:132 > > > + WebKit::WebString textSurroundingElement(const WebKit::WebNode&, unsigned offset, unsigned maxLength); > > > + > > > > Why are we adding this to WebView? > > Do you mean WebViewHost? It looks like the code could go into LayoutTestController.cpp, but I'm not sure it matters much one way or another. I don't think we should be adding new methods on WebViewHost unless it's necessary. 661618 35 150444 leandrogracia 2012-07-02 11:16:09 -0700 Comment on attachment 150444 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=150444&action=review >>> Source/WebKit/chromium/ChangeLog:8 >>> + Reviewed by NOBODY (OOPS!). >> >> This line should appear before the description. > > You keep complaining about this issue, but I'm not sure it matters. Fixed. >> Tools/ChangeLog:9 >> + Reviewed by NOBODY (OOPS!). > > Ditto. Fixed. >>> Tools/DumpRenderTree/chromium/WebViewHost.h:132 >>> + >> >> Why are we adding this to WebView? > > Do you mean WebViewHost? It looks like the code could go into LayoutTestController.cpp, but I'm not sure it matters much one way or another. Fixed. >> LayoutTests/ChangeLog:11 >> + * platform/chromium/fast/text/surrounding-text.html: Added. > > This test doesn't belong in fast/text. It should be in editing. Fixed. 661619 36 150453 leandrogracia 2012-07-02 11:16:31 -0700 Created attachment 150453 Patch 661621 37 webkit.review.bot 2012-07-02 11:18:39 -0700 Attachment 150453 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/plat..." exit_code: 1 Tools/DumpRenderTree/chromium/LayoutTestController.cpp:64: Alphabetical sorting problem. [build/include_order] [4] Total errors found: 1 in 9 files If any of these errors are false positives, please file a bug against check-webkit-style. 661624 38 leandrogracia 2012-07-02 11:20:23 -0700 (In reply to comment #37) > Attachment 150453 [details] did not pass style-queue: > > Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'LayoutTests/ChangeLog', u'LayoutTests/plat..." exit_code: 1 > Tools/DumpRenderTree/chromium/LayoutTestController.cpp:64: Alphabetical sorting problem. [build/include_order] [4] > Total errors found: 1 in 9 files > > > If any of these errors are false positives, please file a bug against check-webkit-style. Looks indeed as a false positive caused by platform/ includes. Can you confirm? 661654 39 150453 rniwa 2012-07-02 11:57:58 -0700 Comment on attachment 150453 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=150453&action=review >> Tools/DumpRenderTree/chromium/LayoutTestController.cpp:64 >> +#include "WebSurroundingText.h" > > Alphabetical sorting problem. [build/include_order] [4] This isn't a false positive. "platform/WebSerializedScriptValue.h" and "platform/WebSize.h" need to be moved below v8/include/v8.h but above webkit/support/webkit_support.h 661666 40 150453 rniwa 2012-07-02 12:19:25 -0700 Comment on attachment 150453 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=150453&action=review Please fix the header include order before landing it. > LayoutTests/platform/chromium/editing/surrounding-text/surrounding-text.html:6 > +<head> > +<meta charset="utf-8"> > +<script src="../../../../fast/js/resources/js-test-pre.js"></script> > +</head> Since we don't need to specify charset in this test, you can move the script element to body. > LayoutTests/platform/chromium/editing/surrounding-text/surrounding-text.html:12 > +<script type="text/javascript"> Type attribute is unnecessary. 661738 41 150478 abarth 2012-07-02 14:49:20 -0700 Created attachment 150478 Patch for landing 661841 42 150478 webkit.review.bot 2012-07-02 17:53:44 -0700 Comment on attachment 150478 Patch for landing Clearing flags on attachment: 150478 Committed r121713: <http://trac.webkit.org/changeset/121713> 661842 43 webkit.review.bot 2012-07-02 17:53:52 -0700 All reviewed patches have been landed. Closing bug. 145109 2012-05-31 09:53:39 -0700 2012-06-25 12:29:44 -0700 Patch bug-82461-20120531175338.patch text/plain 11287 leandrogracia U3VidmVyc2lvbiBSZXZpc2lvbjogMTE5MDk2CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggMmI3MWI3YzYzNWJkN2E3MzJhNjRiZjVmZThiYWIxZGVk MDA5MWU4OC4uYjllNzM5ZjY2MGQzMjdjM2E5NzdhOTcwYjFmMmE3ZTk5ZmVjMDNkZCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIz IEBACisyMDEyLTA1LTMxICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9t aXVtLm9yZz4KKworICAgICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZv ciBlZGl0aW5nL1N1cnJvdW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9ODI0NjEKKworICAgICAgICBBZGQgYSBuZXcgbWV0aG9kIHRvIHRo ZSBsYXlvdXQgdGVzdCBjb250cm9sbGVyIGluIG9yZGVyIHRvIHJldHJpZXZlIHRoZQorICAgICAg ICB0ZXh0IHN1cnJvdW5kaW5nIGEgcHJvdmlkZWQgZWxlbWVudC4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVt L0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy OjpMYXlvdXRUZXN0Q29udHJvbGxlcik6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 dGV4dFN1cnJvdW5kaW5nRWxlbWVudCk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21p dW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHA6Cisg ICAgICAgIChXZWJWaWV3SG9zdDo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudCk6CisgICAgICAgICog RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaDoKKyAgICAgICAgKFdlYlZpZXdI b3N0KToKKwogMjAxMi0wNS0zMSAgWm9sdGFuIEhvcnZhdGggIDx6b2x0YW5Ad2Via2l0Lm9yZz4K IAogICAgICAgICBbUXRdIERvbid0IGVuZm9yY2UgdGhlIHZlcnNpb24gb2YgbGlicG5nIGZvciB0 aGUgY29uZmlnIHRlc3Qgd2hlbiBwYXNzaW5nIHRoZSBvcHRpb24gdG8gdGhlIGxpbmtlcgpkaWZm IC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwCmluZGV4IGM3MzkxNDNlMDYwNTExZmUxMzdhOGFhOTRmNmNiZTJmM2UzZTdiMjUuLjBl YjUxZWFlODNjNzY5YjQ0ZWQ1NWI5MjZiMjIzYzg4OTMzZDA0ODUgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9U b29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAg LTI2Nyw3ICsyNjcsOCBAQCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xs ZXIoVGVzdFNoZWxsKiBzaGVsbCkKICAgICBiaW5kTWV0aG9kKCJzZXRGaXhlZExheW91dFNpemUi LCAmTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldEZpeGVkTGF5b3V0U2l6ZSk7CiAgICAgYmluZE1l dGhvZCgic2VsZWN0aW9uQXNNYXJrdXAiLCAmTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNlbGVjdGlv bkFzTWFya3VwKTsKICAgICBiaW5kTWV0aG9kKCJzZXRIYXNDdXN0b21GdWxsU2NyZWVuQmVoYXZp b3IiLCAmTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNldEhhc0N1c3RvbUZ1bGxTY3JlZW5CZWhhdmlv cik7Ci0gICAgCisgICAgYmluZE1ldGhvZCgidGV4dFN1cnJvdW5kaW5nRWxlbWVudCIsICZMYXlv dXRUZXN0Q29udHJvbGxlcjo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudCk7CisKICAgICAvLyBUaGUg ZmFsbGJhY2sgbWV0aG9kIGlzIGNhbGxlZCB3aGVuIGFuIHVua25vd24gbWV0aG9kIGlzIGludm9r ZWQuCiAgICAgYmluZEZhbGxiYWNrTWV0aG9kKCZMYXlvdXRUZXN0Q29udHJvbGxlcjo6ZmFsbGJh Y2tNZXRob2QpOwogCkBAIC0yMjYzLDMgKzIyNjQsMTIgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6c2V0UG9pbnRlckxvY2tXaWxsRmFpbFN5bmNocm9ub3VzbHkoY29uc3QgQ3BwQXJndW1l bnQKICAgICByZXN1bHQtPnNldE51bGwoKTsKIH0KICNlbmRpZgorCit2b2lkIExheW91dFRlc3RD b250cm9sbGVyOjp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNvbnN0IENwcEFyZ3VtZW50TGlzdCYg YXJndW1lbnRzLCBDcHBWYXJpYW50KiByZXN1bHQpCit7CisgICAgaWYgKGFyZ3VtZW50cy5zaXpl KCkgPCAzIHx8ICFhcmd1bWVudHNbMF0uaXNTdHJpbmcoKSB8fCAhYXJndW1lbnRzWzFdLmlzTnVt YmVyKCkgfHwgIWFyZ3VtZW50c1syXS5pc051bWJlcigpKQorICAgICAgICByZXR1cm47CisgICAg V2ViU3RyaW5nIGVsZW1lbnRJZCA9IFdlYlN0cmluZzo6ZnJvbVVURjgoYXJndW1lbnRzWzBdLnRv U3RyaW5nKCkpOworICAgIFdlYlN0cmluZyBjb250ZW50ID0gbV9zaGVsbC0+d2ViVmlld0hvc3Qo KS0+dGV4dFN1cnJvdW5kaW5nRWxlbWVudChlbGVtZW50SWQsIGFyZ3VtZW50c1sxXS50b0ludDMy KCksIGFyZ3VtZW50c1syXS50b0ludDMyKCkpOworICAgIHJlc3VsdC0+c2V0KGNvbnRlbnQudXRm OCgpKTsKK30KZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91 dFRlc3RDb250cm9sbGVyLmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oCmluZGV4IDM3OTc4NjU3ZTNiMWZmMzdiOWQ0MzhhNTQ1NjhiNDJjYzg0 NGVkYTIuLjQzZDM5M2E1M2RmODRkZTlkN2Q5MTYwMmU5MjE0NWJmMzg0NjU0Y2UgMTAwNjQ0Ci0t LSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmgK KysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIu aApAQCAtNDQ0LDYgKzQ0NCwxMSBAQCBwdWJsaWM6CiAgICAgLy8gQ2F1c2UgdGhlIHdlYiBpbnRl bnQgdG8gYmUgZGVsaXZlcmVkIHRvIHRoaXMgY29udGV4dC4KICAgICB2b2lkIGRlbGl2ZXJXZWJJ bnRlbnQoY29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopOwogCisgICAgLy8gUmV0 cmlldmVzIHRoZSB0ZXh0IHN1cnJvdW5kaW5nIGEgcG9zaXRpb24gaW4gYSB0ZXh0IG5vZGUuCisg ICAgLy8gVGhlIGZpcnN0IGNoaWxkIG9mIHRoZSBlbGVtZW50IGdpdmVuIHkgaXRzIGlkIHdpbGwg YmUgdXNlZCBhcyByZWZlcmVuY2UsCisgICAgLy8gb3IgaXRzIG5leHQgc2libGluZyBpZiBub3Qg cHJlc2VudC4gSXQgbXVzdCBiZSBhIHRleHQgbm9kZS4KKyAgICB2b2lkIHRleHRTdXJyb3VuZGlu Z0VsZW1lbnQoY29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopOworCiBwdWJsaWM6 CiAgICAgLy8gVGhlIGZvbGxvd2luZyBtZXRob2RzIGFyZSBub3QgZXhwb3NlZCB0byBKYXZhU2Ny aXB0LgogICAgIHZvaWQgc2V0V29ya1F1ZXVlRnJvemVuKGJvb2wgZnJvemVuKSB7IG1fd29ya1F1 ZXVlLnNldEZyb3plbihmcm96ZW4pOyB9CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1 bS9XZWJWaWV3SG9zdC5jcHAKaW5kZXggZmNjOGQyYjdiNWM5MmJiZjFhN2ZlZDVhMTUzMTMwY2Ex MzY0ZDg3OS4uZjQyZTFhZjFhOTk5OTdjMGNlNjQ5YmJjYzM0Y2VkZTc4ZDRlZmRlOSAxMDA2NDQK LS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCisrKyBi L1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcApAQCAtNjMsNiAr NjMsNyBAQAogI2luY2x1ZGUgInBsYXRmb3JtL1dlYlNlcmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgog I2luY2x1ZGUgInBsYXRmb3JtL1dlYlNpemUuaCIKICNpbmNsdWRlICJXZWJTdG9yYWdlTmFtZXNw YWNlLmgiCisjaW5jbHVkZSAiV2ViU3Vycm91bmRpbmdUZXh0LmgiCiAjaW5jbHVkZSAiV2ViVGV4 dENoZWNraW5nQ29tcGxldGlvbi5oIgogI2luY2x1ZGUgIldlYlRleHRDaGVja2luZ1Jlc3VsdC5o IgogI2luY2x1ZGUgIldlYlVzZXJNZWRpYUNsaWVudE1vY2suaCIKQEAgLTg2Myw2ICs4NjQsMjUg QEAgdm9pZCBXZWJWaWV3SG9zdDo6ZGlkTG9zZVBvaW50ZXJMb2NrKCkKIH0KICNlbmRpZgogCitX ZWJLaXQ6OldlYlN0cmluZyBXZWJWaWV3SG9zdDo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudChjb25z dCBXZWJLaXQ6OldlYlN0cmluZyYgZWxlbWVudElkLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVk IG1heExlbmd0aCkKK3sKKyAgICAvLyBUbyBtYWtlIHRlc3RpbmcgZWFzaWVyLCBhY2Nlc3MgYW4g ZWxlbWVudCBieSBpdHMgaWQgZmlyc3QuCisgICAgV2ViRG9jdW1lbnQgZG9jdW1lbnQgPSB3ZWJW aWV3KCktPm1haW5GcmFtZSgpLT5kb2N1bWVudCgpOworICAgIFdlYkVsZW1lbnQgZWxlbWVudCA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGVsZW1lbnRJZCk7CisgICAgaWYgKGVsZW1lbnQuaXNO dWxsKCkpCisgICAgICAgIHJldHVybiBXZWJTdHJpbmcoKTsKKworICAgIC8vIFRoZW4gdHJ5IHRv IGdldCBpdHMgZmlyc3QgY2hpbGQgaWYgcHJlc2VudC4gT3RoZXJ3aXNlIHVzZSBpcyBuZXh0IHNp YmxpbmcuCisgICAgLy8gSW4gYW55IGNhc2UgaXQgc2hvdWxkIGJlIHRoZSB0ZXh0IG5vZGUgd2Un cmUgcmVmZXJyaW5nIHRvIGZvciBjb250ZW50IHNlYXJjaC4KKyAgICBXZWJOb2RlIG5vZGUgPSBl bGVtZW50Lmhhc0NoaWxkTm9kZXMoKSA/IGVsZW1lbnQuZmlyc3RDaGlsZCgpIDogZWxlbWVudC5u ZXh0U2libGluZygpOworICAgIGlmIChub2RlLmlzTnVsbCgpIHx8ICFub2RlLmlzVGV4dE5vZGUo KSB8fCBvZmZzZXQgPj0gbm9kZS5ub2RlVmFsdWUoKS5sZW5ndGgoKSkKKyAgICAgICAgcmV0dXJu IFdlYlN0cmluZygpOworCisgICAgV2ViU3Vycm91bmRpbmdUZXh0IHN1cnJvdW5kaW5nVGV4dDsK KyAgICBzdXJyb3VuZGluZ1RleHQuaW5pdGlhbGl6ZShub2RlLCBvZmZzZXQsIG1heExlbmd0aCk7 CisgICAgcmV0dXJuIHN1cnJvdW5kaW5nVGV4dC50ZXh0Q29udGVudCgpOworfQorCiB2b2lkIFdl YlZpZXdIb3N0OjpzaG93KFdlYk5hdmlnYXRpb25Qb2xpY3kpCiB7CiAgICAgbV9oYXNXaW5kb3cg PSB0cnVlOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmll d0hvc3QuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKaW5k ZXggMjFkYmI0YzhkMmE5YjdkMmIxNjI5NjAzMjJjMTg5YjAzNzgyZjliYS4uNmRmOGM0MDhmYTI5 MTRkODgyYjI2MWI5NTljOTM0OTA4MjQ0MGNiNCAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRl clRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9XZWJWaWV3SG9zdC5oCkBAIC0xMjMsNiArMTIzLDggQEAgY2xhc3MgV2ViVmlld0hv c3QgOiBwdWJsaWMgV2ViS2l0OjpXZWJWaWV3Q2xpZW50LCBwdWJsaWMgV2ViS2l0OjpXZWJGcmFt ZUNsaWVudCwKICAgICB2b2lkIHNldFBvaW50ZXJMb2NrV2lsbEZhaWxTeW5jaHJvbm91c2x5KCkg eyBtX3BvaW50ZXJMb2NrUGxhbm5lZFJlc3VsdCA9IFBvaW50ZXJMb2NrV2lsbEZhaWxTeW5jOyB9 CiAjZW5kaWYKIAorICAgIFdlYktpdDo6V2ViU3RyaW5nIHRleHRTdXJyb3VuZGluZ0VsZW1lbnQo Y29uc3QgV2ViS2l0OjpXZWJTdHJpbmcmIGVsZW1lbnRJZCwgdW5zaWduZWQgb2Zmc2V0LCB1bnNp Z25lZCBtYXhMZW5ndGgpOworCiAgICAgLy8gTmF2aWdhdGlvbkhvc3QKICAgICB2aXJ0dWFsIGJv b2wgbmF2aWdhdGUoY29uc3QgVGVzdE5hdmlnYXRpb25FbnRyeSYsIGJvb2wgcmVsb2FkKTsKIApk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CmluZGV4IGI3YTM5MmFjYTgzZmE1MDUzMjBmZGZlMDc4YjA5ZTkwNjY5MGRhY2QuLmVmNTk2MjAy MzI2ZDE5MGIwMDU2ZjI5ZTA3MDQ3YTM1MWI1YzkxNzYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAor MjAxMi0wNS0zMSAgTGVhbmRybyBHcmFjaWEgR2lsICA8bGVhbmRyb2dyYWNpYUBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJbXBsZW1lbnQgYSBMYXlvdXQgVGVzdCBmb3IgZWRp dGluZy9TdXJyb3VuZGluZ1RleHQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTgyNDYxCisKKyAgICAgICAgQWRkIGEgbmV3IGxheW91dCB0ZXN0IGZvciB0 aGUgc3Vycm91bmRpbmcgdGV4dCBmZWF0dXJlLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJv dW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJv bWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC5odG1sOiBBZGRlZC4KKwogMjAxMi0wNS0z MSAgTWlraGFpbCBQb3pkbnlha292ICA8bWlraGFpbC5wb3pkbnlha292QGludGVsLmNvbT4KIAog ICAgICAgICBbRUZMXSBHYXJkZW5pbmcgYWZ0ZXIgcjExODk4OQpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQtZXhwZWN0 ZWQudHh0IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5k aW5nLXRleHQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmI3NzQ4NzgzM2IwMWI3YjA5OGNlMjdj NGM2MWM0ZWEwMGNmNzk3MGMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwzNCBAQAorLjEyMzQ1Cis2Nzg5IDEyMzQ1CisKKzY3ODkuIAorNTd0aCBTdHJlZXQgYW5k IExha2UgU2hvcmUgRHJpdmUKK0NoaWNhZ28gSUwgNjA2MzcgLgorMTIzNDVhYmMKKzY3ODkKKzEy MzQ1CisKKzY3ODkwMTIzLgorVGhpcyBpcyBhIHRlc3QgZXhhbXBsZSAgLgorMDEyMzQ1Njc4OTAx MjM0NTY3ODkwMTIzNDU2Nzg5CisuIDEyMzQ1dGVzdCAxMjM0NXRlc3QKK1Rlc3QgdGhlIGV4dHJh Y3Rpb24gb2YgdGhlIHRleHQgc3Vycm91bmRpbmcgYW4gZWxlbWVudC4KKworT24gc3VjY2Vzcywg eW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRF U1QgQ09NUExFVEUiLgorCisKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCJ0ZXN0MSIsIDAsIDEwMCkg aXMgIjEyMzQ1IDY3ODkgMTIzNDUgNjc4OSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCJ0ZXN0MSIs IDUsIDYpIGlzICI4OSAxMjMiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgidGVzdDEiLCA1LCAwKSBp cyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoInRlc3QxIiwgNSwgMSkgaXMgIjEiCitQQVNTIHN1 cnJvdW5kaW5nVGV4dCgidGVzdDEiLCA2LCAyKSBpcyAiMTIiCitQQVNTIHN1cnJvdW5kaW5nVGV4 dCgidGVzdDIiLCAwLCAxMDApIGlzICI1N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZSBD aGljYWdvIElMIDYwNjM3IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoInRlc3QzIiwgMCwgMTAwKSBp cyAiNjc4OSAxMjM0NSA2Nzg5IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoInRlc3Q0IiwgMCwgMTAw KSBpcyAiVGhpcyBpcyBhIHRlc3QgZXhhbXBsZSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCJ0ZXN0 NSIsIDE1LCAxMikgaXMgIjkwMTIzNDU2Nzg5MCIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCJ0ZXN0 NiIsIDAsIDEwMCkgaXMgIiIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCJ0ZXN0NyIsIDAsIDEwMCkg aXMgIiIKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQor CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vy cm91bmRpbmctdGV4dC5odG1sIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90 ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lY2ZiZDJlMTIyODNjZjhhZDkz ZmVlNGFhNWE1Zjk0OTBlMGNkMTBiCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbApAQCAtMCwwICsx LDU5IEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPG1ldGEgY2hhcnNldD0idXRmLTgiPgor PGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi8uLi8uLi9mYXN0L2pzL3Jlc291cmNl cy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vLi4vZmFzdC9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8IS0t IFRlc3QgZXhwbG9yYXRpb24gKGxpbWl0ZWQgYnkgZm9ybSBjb250cm9sIGVsZW1lbnRzKSAtLSE+ Cis8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJ0ZXN0MSI+Njc4OSAxMjM0NTwvcD42Nzg5 PGJ1dHRvbj4uPC9idXR0b24+Cis8c2VsZWN0Pi48L3NlbGVjdD48ZGl2PjU3dGggU3RyZWV0IGFu ZCBMYWtlIFNob3JlIERyaXZlPC9kaXY+IDxzcGFuPkNoaWNhZ288L3NwYW4+IDxzcGFuIGlkPSJ0 ZXN0MiI+SUw8L3NwYW4+IDxzcGFuPjYwNjM3PC9zcGFuPjxzZWxlY3Q+Ljwvc2VsZWN0PgorCis8 IS0tIFRlc3Qgc3RvcHBlZCBleHBsb3JhdGlvbiAtLSE+Cis8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+ MTIzNDU8YnV0dG9uPmFiYzwvYnV0dG9uPjxwPjY3ODk8YnIgaWQ9InRlc3QzIi8+MTIzNDU8L3A+ Njc4OTx0ZXh0YXJlYT5hYmM8L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+CisK KzwhLS0gVGVzdCBza2lwcGVkIGJyYW5jaGVzIC0tIT4KKzxvcHRpb24+Ljwvb3B0aW9uPjxkaXYg aWQ9InRlc3Q0Ij5UaGlzIGlzIDwhLS0gY29tbWVudCAtLSE+YSB0ZXN0IDxzY3JpcHQgbGFuZ3Vh Z2U9ImphdmFzY3JpcHQiPi8qIENvbW1lbnQgKi88L3NjcmlwdD4gZXhhbXBsZTxvcHRpb24+Ljwv b3B0aW9uPgorCis8IS0tIFRlc3QgYWxpZ25tZW50IGFyb3VuZCBnaXZlbiBwb3NpdGlvbiAtLSE+ Cis8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJ0ZXN0NSI+MDEyMzQ1Njc4OTAxMjM0NTY3ODkw MTIzNDU2Nzg5PC9kaXY+PGJ1dHRvbj4uPC9idXR0b24+CisKKzwhLS0gVmFsaWQgY29udGFpbmVy IHRlc3QgLS0hPgorPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uIGlkPSJ0ZXN0NiI+dGVz dDwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0aW9uPgorPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0 dG9uPnRlPHNwYW4gaWQ9InRlc3Q3Ij5zdDwvc3Bhbj48L2J1dHRvbj48b3B0aW9uPi48L29wdGlv bj4KKworPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4K KzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2Rlc2NyaXB0aW9uKCdUZXN0IHRoZSBl eHRyYWN0aW9uIG9mIHRoZSB0ZXh0IHN1cnJvdW5kaW5nIGFuIGVsZW1lbnQuJyk7CisKK2Z1bmN0 aW9uIHN1cnJvdW5kaW5nVGV4dChlbGVtZW50LCBvZmZzZXQsIG1heExlbmd0aCkgeworICB2YXIg dGV4dCA9IHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlci50ZXh0U3Vycm91bmRpbmdFbGVtZW50 KGVsZW1lbnQsIG9mZnNldCwgbWF4TGVuZ3RoKTsKKyAgcmV0dXJuIHRleHQucmVwbGFjZSgvXHMr L2csICcgJykucmVwbGFjZSgvXlxzKnxccyokL2csICcnKTsKK30KKworZnVuY3Rpb24gcnVuKCkg eworICAgIGlmICghd2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQorICAgICAgICByZXR1cm47 CisKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dCgidGVzdDEiLCAw LCAxMDApJywgJzEyMzQ1IDY3ODkgMTIzNDUgNjc4OScpOworICAgIHNob3VsZEJlRXF1YWxUb1N0 cmluZygnc3Vycm91bmRpbmdUZXh0KCJ0ZXN0MSIsIDUsIDYpJywgJzg5IDEyMycpOworICAgIHNo b3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KCJ0ZXN0MSIsIDUsIDApJywgJycp OworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KCJ0ZXN0MSIsIDUs IDEpJywgJzEnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dCgi dGVzdDEiLCA2LCAyKScsICcxMicpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91 bmRpbmdUZXh0KCJ0ZXN0MiIsIDAsIDEwMCknLCAnNTd0aCBTdHJlZXQgYW5kIExha2UgU2hvcmUg RHJpdmUgQ2hpY2FnbyBJTCA2MDYzNycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vy cm91bmRpbmdUZXh0KCJ0ZXN0MyIsIDAsIDEwMCknLCAnNjc4OSAxMjM0NSA2Nzg5Jyk7CisgICAg c2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoInRlc3Q0IiwgMCwgMTAwKScs ICdUaGlzIGlzIGEgdGVzdCBleGFtcGxlJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdz dXJyb3VuZGluZ1RleHQoInRlc3Q1IiwgMTUsIDEyKScsICc5MDEyMzQ1Njc4OTAnKTsKKyAgICBz aG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dCgidGVzdDYiLCAwLCAxMDApJywg JycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KCJ0ZXN0NyIs IDAsIDEwMCknLCAnJyk7CisgICAgZmluaXNoSlNUZXN0KCk7Cit9CisKK3dpbmRvdy5vbmxvYWQg PSBydW47Cit3aW5kb3cuanNUZXN0SXNBc3luYyA9IHRydWU7Cit3aW5kb3cuc3VjY2Vzc2Z1bGx5 UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL2Zhc3Qv anMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+ Cg== 149339 2012-06-25 12:29:12 -0700 2012-06-26 12:26:24 -0700 Patch bug-82461-20120625202911.patch text/plain 12292 leandrogracia U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxMTYxCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggYjU2M2Y4ZTkxODgwOWVjNzY3MDY1ZDMyYjY2MDVjYWQ4 MTExZDk3Ny4uMWY5NDg3Mjc0ZTMyNjJhNmFlY2E5MTExYzYzMTI3ODI5ZTA0YTVhYSAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIz IEBACisyMDEyLTA2LTI1ICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9t aXVtLm9yZz4KKworICAgICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZv ciBlZGl0aW5nL1N1cnJvdW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9ODI0NjEKKworICAgICAgICBBZGQgYSBuZXcgbWV0aG9kIHRvIHRo ZSBsYXlvdXQgdGVzdCBjb250cm9sbGVyIGluIG9yZGVyIHRvIHJldHJpZXZlIHRoZQorICAgICAg ICB0ZXh0IHN1cnJvdW5kaW5nIGEgcHJvdmlkZWQgZWxlbWVudC4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVt L0xheW91dFRlc3RDb250cm9sbGVyLmNwcDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy OjpMYXlvdXRUZXN0Q29udHJvbGxlcik6CisgICAgICAgIChMYXlvdXRUZXN0Q29udHJvbGxlcjo6 dGV4dFN1cnJvdW5kaW5nRWxlbWVudCk6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21p dW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuaDoKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVy KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHA6Cisg ICAgICAgIChXZWJWaWV3SG9zdDo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudCk6CisgICAgICAgICog RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaDoKKyAgICAgICAgKFdlYlZpZXdI b3N0KToKKwogMjAxMi0wNi0yNSAgU2ltb24gSGF1c21hbm4gIDxzaW1vbi5oYXVzbWFubkBub2tp YS5jb20+CiAKICAgICAgICAgW1F0XSBGaXggV2luMzIgZGVidWcgYnVpbGQKZGlmZiAtLWdpdCBh L1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNwcCBi L1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNwcApp bmRleCAwNmYxNDZjMWMzZDVmOTU0MzU4NTg2YjI2NzlkN2Q4Y2IxZTljYTVlLi4xN2YwNDNlNDdi YWE3ODAxMGY5MGFmZTQ0ZTdkOTdjOTc5ZmNjNTRjIDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvVG9vbHMvRHVt cFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC0yNzcsNyAr Mjc3LDggQEAgTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKFRlc3RT aGVsbCogc2hlbGwpCiAgICAgYmluZE1ldGhvZCgic2V0Rml4ZWRMYXlvdXRTaXplIiwgJkxheW91 dFRlc3RDb250cm9sbGVyOjpzZXRGaXhlZExheW91dFNpemUpOwogICAgIGJpbmRNZXRob2QoInNl bGVjdGlvbkFzTWFya3VwIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZWxlY3Rpb25Bc01hcmt1 cCk7CiAgICAgYmluZE1ldGhvZCgic2V0SGFzQ3VzdG9tRnVsbFNjcmVlbkJlaGF2aW9yIiwgJkxh eW91dFRlc3RDb250cm9sbGVyOjpzZXRIYXNDdXN0b21GdWxsU2NyZWVuQmVoYXZpb3IpOwotICAg IAorICAgIGJpbmRNZXRob2QoInRleHRTdXJyb3VuZGluZ0VsZW1lbnQiLCAmTGF5b3V0VGVzdENv bnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQpOworCiAgICAgLy8gVGhlIGZhbGxiYWNr IG1ldGhvZCBpcyBjYWxsZWQgd2hlbiBhbiB1bmtub3duIG1ldGhvZCBpcyBpbnZva2VkLgogICAg IGJpbmRGYWxsYmFja01ldGhvZCgmTGF5b3V0VGVzdENvbnRyb2xsZXI6OmZhbGxiYWNrTWV0aG9k KTsKIApAQCAtMjMxMCwzICsyMzExLDMxIEBAIHZvaWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNl dFBvaW50ZXJMb2NrV2lsbEZhaWxTeW5jaHJvbm91c2x5KGNvbnN0IENwcEFyZ3VtZW50CiAgICAg cmVzdWx0LT5zZXROdWxsKCk7CiB9CiAjZW5kaWYKKwordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxl cjo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudChjb25zdCBDcHBBcmd1bWVudExpc3QmIGFyZ3VtZW50 cywgQ3BwVmFyaWFudCogcmVzdWx0KQoreworICAgIGlmIChhcmd1bWVudHMuc2l6ZSgpIDwgMyB8 fCAhYXJndW1lbnRzWzBdLmlzU3RyaW5nKCkgfHwgIWFyZ3VtZW50c1sxXS5pc051bWJlcigpIHx8 ICFhcmd1bWVudHNbMl0uaXNOdW1iZXIoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgV2ViRnJh bWUqIHdlYkZyYW1lID0gbV9zaGVsbC0+d2ViVmlldygpLT5tYWluRnJhbWUoKTsKKyAgICBpZiAo IXdlYkZyYW1lKSB7CisgICAgICAgIHJlc3VsdC0+c2V0TnVsbCgpOworICAgICAgICByZXR1cm47 CisgICAgfQorCisgICAgV2ViU3RyaW5nIGVsZW1lbnRJZCA9IFdlYlN0cmluZzo6ZnJvbVVURjgo YXJndW1lbnRzWzBdLnRvU3RyaW5nKCkpOworICAgIFdlYkVsZW1lbnQgZWxlbWVudCA9IHdlYkZy YW1lLT5kb2N1bWVudCgpLmdldEVsZW1lbnRCeUlkKGVsZW1lbnRJZCk7CisgICAgaWYgKGVsZW1l bnQuaXNOdWxsKCkpIHsKKyAgICAgICAgcmVzdWx0LT5zZXROdWxsKCk7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisKKyAgICBXZWJOb2RlIG5vZGUgPSBlbGVtZW50Lmhhc0NoaWxkTm9kZXMoKSA/ IGVsZW1lbnQuZmlyc3RDaGlsZCgpIDogZWxlbWVudC5uZXh0U2libGluZygpOworICAgIGlmIChu b2RlLmlzTnVsbCgpIHx8ICFub2RlLmlzVGV4dE5vZGUoKSkgeworICAgICAgICByZXN1bHQtPnNl dE51bGwoKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIFdlYlN0cmluZyBjb250ZW50 ID0gbV9zaGVsbC0+d2ViVmlld0hvc3QoKS0+dGV4dFN1cnJvdW5kaW5nRWxlbWVudChub2RlLCBh cmd1bWVudHNbMV0udG9JbnQzMigpLCBhcmd1bWVudHNbMl0udG9JbnQzMigpKTsKKyAgICByZXN1 bHQtPnNldChjb250ZW50LnV0ZjgoKSk7Cit9CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVy VHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5oIGIvVG9vbHMvRHVtcFJlbmRlclRy ZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuaAppbmRleCBhZjM5YjJlZjY4NjBmNjM2 MTY5YWI5NWE0ZTMwMjgyZjc3MDk2Zjg5Li4wZTc0ODQxYjU3NjIzM2ViNGI5OGRlNDZiNjUwZDMz ZTI0Nzc3NzY0IDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlv dXRUZXN0Q29udHJvbGxlci5oCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xh eW91dFRlc3RDb250cm9sbGVyLmgKQEAgLTQ1Myw2ICs0NTMsMTEgQEAgcHVibGljOgogICAgIC8v IHJlc3VsdGluZyBpbiB0aGUgY2hhbmdlZCBzZXR0aW5nIGJlaW5nIGlnbm9yZWQuCiAgICAgdm9p ZCBzZXRUZXh0U3VicGl4ZWxQb3NpdGlvbmluZyhjb25zdCBDcHBBcmd1bWVudExpc3QmLCBDcHBW YXJpYW50Kik7CiAKKyAgICAvLyBSZXRyaWV2ZXMgdGhlIHRleHQgc3Vycm91bmRpbmcgYSBwb3Np dGlvbiBpbiBhIHRleHQgbm9kZS4KKyAgICAvLyBUaGUgZmlyc3QgY2hpbGQgb2YgdGhlIGVsZW1l bnQgZ2l2ZW4geSBpdHMgaWQgd2lsbCBiZSB1c2VkIGFzIHJlZmVyZW5jZSwKKyAgICAvLyBvciBp dHMgbmV4dCBzaWJsaW5nIGlmIG5vdCBwcmVzZW50LiBJdCBtdXN0IGJlIGEgdGV4dCBub2RlLgor ICAgIHZvaWQgdGV4dFN1cnJvdW5kaW5nRWxlbWVudChjb25zdCBDcHBBcmd1bWVudExpc3QmLCBD cHBWYXJpYW50Kik7CisKIHB1YmxpYzoKICAgICAvLyBUaGUgZm9sbG93aW5nIG1ldGhvZHMgYXJl IG5vdCBleHBvc2VkIHRvIEphdmFTY3JpcHQuCiAgICAgdm9pZCBzZXRXb3JrUXVldWVGcm96ZW4o Ym9vbCBmcm96ZW4pIHsgbV93b3JrUXVldWUuc2V0RnJvemVuKGZyb3plbik7IH0KZGlmZiAtLWdp dCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcCBiL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAppbmRleCA4OGUwNzM3OGY0 NTdkOWU1ODIwYTVkNTk2MmJkMGZjM2MxZDhiYzRmLi5mNzBiNGRmYWIyNGY3YzkyNzg5YzJkZjA4 Mzg1NjMxMWVmY2QyNWM1IDEwMDY0NAotLS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1 bS9XZWJWaWV3SG9zdC5jcHAKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2Vi Vmlld0hvc3QuY3BwCkBAIC02NCw2ICs2NCw3IEBACiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViU2Vy aWFsaXplZFNjcmlwdFZhbHVlLmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViU2l6ZS5oIgogI2lu Y2x1ZGUgIldlYlN0b3JhZ2VOYW1lc3BhY2UuaCIKKyNpbmNsdWRlICJXZWJTdXJyb3VuZGluZ1Rl eHQuaCIKICNpbmNsdWRlICJXZWJUZXh0Q2hlY2tpbmdDb21wbGV0aW9uLmgiCiAjaW5jbHVkZSAi V2ViVGV4dENoZWNraW5nUmVzdWx0LmgiCiAjaW5jbHVkZSAiV2ViVXNlck1lZGlhQ2xpZW50TW9j ay5oIgpAQCAtOTAxLDYgKzkwMiwxNiBAQCB2b2lkIFdlYlZpZXdIb3N0OjpkaWRMb3NlUG9pbnRl ckxvY2soKQogfQogI2VuZGlmCiAKK1dlYktpdDo6V2ViU3RyaW5nIFdlYlZpZXdIb3N0Ojp0ZXh0 U3Vycm91bmRpbmdFbGVtZW50KGNvbnN0IFdlYktpdDo6V2ViTm9kZSYgbm9kZSwgdW5zaWduZWQg b2Zmc2V0LCB1bnNpZ25lZCBtYXhMZW5ndGgpCit7CisgICAgaWYgKG5vZGUuaXNOdWxsKCkgfHwg IW5vZGUuaXNUZXh0Tm9kZSgpIHx8IG9mZnNldCA+PSBub2RlLm5vZGVWYWx1ZSgpLmxlbmd0aCgp KQorICAgICAgICByZXR1cm4gV2ViU3RyaW5nKCk7CisKKyAgICBXZWJTdXJyb3VuZGluZ1RleHQg c3Vycm91bmRpbmdUZXh0OworICAgIHN1cnJvdW5kaW5nVGV4dC5pbml0aWFsaXplKG5vZGUsIG9m ZnNldCwgbWF4TGVuZ3RoKTsKKyAgICByZXR1cm4gc3Vycm91bmRpbmdUZXh0LnRleHRDb250ZW50 KCk7Cit9CisKIHZvaWQgV2ViVmlld0hvc3Q6OnNob3coV2ViTmF2aWdhdGlvblBvbGljeSkKIHsK ICAgICBtX2hhc1dpbmRvdyA9IHRydWU7CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJl ZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0v V2ViVmlld0hvc3QuaAppbmRleCBjZTE4OWQ5MTU0Y2I0OTBlYTEzNGIzM2ZkNDljMDYyM2U2Mjk3 ZjliLi40OTQwNDIxMTI5NWNhOWQzNmNhM2RhNmIxMDg0OWJkMjcwZjMwM2YzIDEwMDY0NAotLS0g YS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCisrKyBiL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmgKQEAgLTEyOCw2ICsxMjgsOCBA QCBjbGFzcyBXZWJWaWV3SG9zdCA6IHB1YmxpYyBXZWJLaXQ6OldlYlZpZXdDbGllbnQsIHB1Ymxp YyBXZWJLaXQ6OldlYkZyYW1lQ2xpZW50LAogICAgIHZvaWQgc2V0UG9pbnRlckxvY2tXaWxsRmFp bFN5bmNocm9ub3VzbHkoKSB7IG1fcG9pbnRlckxvY2tQbGFubmVkUmVzdWx0ID0gUG9pbnRlckxv Y2tXaWxsRmFpbFN5bmM7IH0KICNlbmRpZgogCisgICAgV2ViS2l0OjpXZWJTdHJpbmcgdGV4dFN1 cnJvdW5kaW5nRWxlbWVudChjb25zdCBXZWJLaXQ6OldlYk5vZGUmLCB1bnNpZ25lZCBvZmZzZXQs IHVuc2lnbmVkIG1heExlbmd0aCk7CisKICAgICAvLyBOYXZpZ2F0aW9uSG9zdAogICAgIHZpcnR1 YWwgYm9vbCBuYXZpZ2F0ZShjb25zdCBUZXN0TmF2aWdhdGlvbkVudHJ5JiwgYm9vbCByZWxvYWQp OwogCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKaW5kZXggZjExNGRmMjAyNmI0MzgwYzU5YjNiOGRkYmEzY2QwZTdhZWMyOTNmMi4uMWY3 YzViNjAwNTBkMDZiZDQzMTg0YTM5Yzc4YzI2YjU0NDBmMTJkZSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1 IEBACisyMDEyLTA2LTI1ICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9t aXVtLm9yZz4KKworICAgICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZv ciBlZGl0aW5nL1N1cnJvdW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9ODI0NjEKKworICAgICAgICBBZGQgYSBuZXcgbGF5b3V0IHRlc3Qg Zm9yIHRoZSBzdXJyb3VuZGluZyB0ZXh0IGZlYXR1cmUuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQv c3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIHBsYXRmb3Jt L2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0Lmh0bWw6IEFkZGVkLgorCiAyMDEy LTA2LTI1ICBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gIDxhbGxhbi5qZW5zZW5Abm9raWEuY29tPgog CiAgICAgICAgIFtRdF0gVW5za2lwIDNEIHRyYW5zZm9ybSB0ZXN0cy4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4 cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJy b3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45MTJjMWM1MmRiYmMzZDViMDE2 M2JiOTY0ODAyZDk0YjdlNGRiZWRkCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxh dGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0CkBA IC0wLDAgKzEsMjEgQEAKK1Rlc3QgdGhlIGV4dHJhY3Rpb24gb2YgdGhlIHRleHQgc3Vycm91bmRp bmcgYW4gZWxlbWVudC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQ QVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1BBU1Mgc3Vy cm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEy MzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCAwLCAxMDApIGlzICIxMjM0NSA2Nzg5IDEy MzQ1IDY3ODkiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8 cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgNSwgNikg aXMgIjg5IDEyMyIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0 NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA1LCAw KSBpcyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAg aWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDUsIDEpIGlz ICIxIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9 ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDYsIDIpIGlzICIx MiIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJo ZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCAxMDAsIDUpIGlzICIi CitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPHNlbGVjdD4uPC9zZWxlY3Q+PGRpdj41N3RoIFN0cmVl dCBhbmQgTGFrZSBTaG9yZSBEcml2ZTwvZGl2PiA8c3Bhbj5DaGljYWdvPC9zcGFuPiA8c3BhbiBp ZD0iaGVyZSI+SUw8L3NwYW4+IDxzcGFuPjYwNjM3PC9zcGFuPjxzZWxlY3Q+Ljwvc2VsZWN0Pics IDAsIDEwMCkgaXMgIjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3JlIERyaXZlIENoaWNhZ28gSUwg NjA2MzciCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PjEyMzQ1 PGJ1dHRvbj5hYmM8L2J1dHRvbj48cD42Nzg5PGJyIGlkPSJoZXJlIi8+MTIzNDU8L3A+Njc4OTx0 ZXh0YXJlYT5hYmM8L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+JywgMCwgMTAw KSBpcyAiNjc4OSAxMjM0NSA2Nzg5IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+Ljwv YnV0dG9uPjxkaXYgaWQ9ImhlcmUiPlRoaXMgaXMgPCEtLSBjb21tZW50IC0tIT5hIHRlc3QgPCcg KyAnc2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0Ij48JyArICcvc2NyaXB0PmV4YW1wbGU8YnV0 dG9uPi48L2J1dHRvbj4nLCAwLCAxMDApIGlzICJUaGlzIGlzIGEgdGVzdCBleGFtcGxlIgorUEFT UyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPjAxMjM0 NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTwvZGl2PjxidXR0b24+LjwvYnV0dG9uPicsIDE1LCAx MikgaXMgIjkwMTIzNDU2Nzg5MCIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8b3B0aW9uPi48L29w dGlvbj4xMjM0NTxidXR0b24gaWQ9ImhlcmUiPnRlc3Q8L2J1dHRvbj48b3B0aW9uPi48L29wdGlv bj4nLCAwLCAxMDApIGlzICIiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPG9wdGlvbj4uPC9vcHRp b24+MTIzNDU8YnV0dG9uPnRlPHNwYW4gaWQ9ImhlcmUiPnN0PC9zcGFuPjwvYnV0dG9uPjxvcHRp b24+Ljwvb3B0aW9uPicsIDAsIDEwMCkgaXMgIiIKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlz IHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9y bS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC5odG1sIGIvTGF5b3V0VGVzdHMv cGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi5hMTFjM2I0MmVhZTFiMTZlYWVkNTM3ZTdlNTk2NTg3ZmU5ZDMxYTE5Ci0tLSAvZGV2L251 bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5k aW5nLXRleHQuaHRtbApAQCAtMCwwICsxLDUwIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor PGhlYWQ+Cis8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vLi4v ZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJv ZHk+Cis8ZGl2IGlkPSJ0ZXN0Ij4KKzwvZGl2PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8 ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4K K2Rlc2NyaXB0aW9uKCdUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRoZSB0ZXh0IHN1cnJvdW5kaW5n IGFuIGVsZW1lbnQuJyk7CisKK2Z1bmN0aW9uIHN1cnJvdW5kaW5nVGV4dChodG1sLCBvZmZzZXQs IG1heExlbmd0aCkgeworICB2YXIgdGVzdCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0 Jyk7CisgIHRlc3QuaW5uZXJIVE1MID0gaHRtbDsKKworICB2YXIgdGV4dCA9IHdpbmRvdy5sYXlv dXRUZXN0Q29udHJvbGxlci50ZXh0U3Vycm91bmRpbmdFbGVtZW50KCdoZXJlJywgb2Zmc2V0LCBt YXhMZW5ndGgpOworICByZXR1cm4gdGV4dC5yZXBsYWNlKC9ccysvZywgJyAnKS5yZXBsYWNlKC9e XHMqfFxzKiQvZywgJycpOworfQorCitmdW5jdGlvbiBydW4oKSB7CisgICAgaWYgKCF3aW5kb3cu bGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgICAgIHJldHVybjsKKworICAgIHNob3VsZEJlRXF1 YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBp ZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDAsIDEwMCkn LCAnMTIzNDUgNjc4OSAxMjM0NSA2Nzg5Jyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdz dXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5 IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgNSwgNiknLCAnODkgMTIzJyk7Cisg ICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1 dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRv bj5cJywgNSwgMCknLCAnJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGlu Z1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9w PjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgNSwgMSknLCAnMScpOworICAgIHNob3VsZEJlRXF1 YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBp ZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDYsIDIpJywg JzEyJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0 dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9u Pi48L2J1dHRvbj5cJywgMTAwLCA1KScsICcnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmco J3N1cnJvdW5kaW5nVGV4dChcJzxzZWxlY3Q+Ljwvc2VsZWN0PjxkaXY+NTd0aCBTdHJlZXQgYW5k IExha2UgU2hvcmUgRHJpdmU8L2Rpdj4gPHNwYW4+Q2hpY2Fnbzwvc3Bhbj4gPHNwYW4gaWQ9Imhl cmUiPklMPC9zcGFuPiA8c3Bhbj42MDYzNzwvc3Bhbj48c2VsZWN0Pi48L3NlbGVjdD5cJywgMCwg MTAwKScsICc1N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZSBDaGljYWdvIElMIDYwNjM3 Jyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8ZmllbGRz ZXQ+LjwvZmllbGRzZXQ+MTIzNDU8YnV0dG9uPmFiYzwvYnV0dG9uPjxwPjY3ODk8YnIgaWQ9Imhl cmUiLz4xMjM0NTwvcD42Nzg5PHRleHRhcmVhPmFiYzwvdGV4dGFyZWE+MDEyMzxmaWVsZHNldD4u PC9maWVsZHNldD5cJywgMCwgMTAwKScsICc2Nzg5IDEyMzQ1IDY3ODknKTsKKyAgICBzaG91bGRC ZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjxkaXYg aWQ9ImhlcmUiPlRoaXMgaXMgPCEtLSBjb21tZW50IC0tIT5hIHRlc3QgPFwnICsgXCdzY3JpcHQg bGFuZ3VhZ2U9ImphdmFzY3JpcHQiPjxcJyArIFwnL3NjcmlwdD5leGFtcGxlPGJ1dHRvbj4uPC9i dXR0b24+XCcsIDAsIDEwMCknLCAnVGhpcyBpcyBhIHRlc3QgZXhhbXBsZScpOworICAgIHNob3Vs ZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+PGRp diBpZD0iaGVyZSI+MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5PC9kaXY+PGJ1dHRvbj4u PC9idXR0b24+XCcsIDE1LCAxMiknLCAnOTAxMjM0NTY3ODkwJyk7CisgICAgc2hvdWxkQmVFcXVh bFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8b3B0aW9uPi48L29wdGlvbj4xMjM0NTxidXR0 b24gaWQ9ImhlcmUiPnRlc3Q8L2J1dHRvbj48b3B0aW9uPi48L29wdGlvbj5cJywgMCwgMTAwKScs ICcnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxvcHRp b24+Ljwvb3B0aW9uPjEyMzQ1PGJ1dHRvbj50ZTxzcGFuIGlkPSJoZXJlIj5zdDwvc3Bhbj48L2J1 dHRvbj48b3B0aW9uPi48L29wdGlvbj5cJywgMCwgMTAwKScsICcnKTsKKworICAgIGRvY3VtZW50 LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKSk7CisgICAg ZmluaXNoSlNUZXN0KCk7Cit9CisKK3dpbmRvdy5vbmxvYWQgPSBydW47Cit3aW5kb3cuanNUZXN0 SXNBc3luYyA9IHRydWU7Cit3aW5kb3cuc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qt cG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 149586 2012-06-26 12:26:33 -0700 2012-06-27 04:27:38 -0700 Patch bug-82461-20120626202633.patch text/plain 15284 leandrogracia U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxMTYxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDdhOGNlNmYyZTU4MWQ2ODJhZmU4YTJkYmVmYjYxNDVmMTFmNTliZjEuLmYwYjQ1NTlhN2Q0ZGI5 OWMxYWRkYWUyZjhiNGRkN2U0ODAwZjUxMjMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTkgQEAKKzIwMTItMDYtMjYgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9n cmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5 b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAgIEFsbG93IHBhc3Np bmcgbm9kZXMgYXMgYXJndW1lbnRzIGZvciBsYXlvdXQgdGVzdCBtZXRob2RzLgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL1dlYkJpbmRp bmdzLmg6CisgICAgICAgIChXZWJCaW5kaW5ncyk6CisgICAgICAgICogc3JjL1dlYkJpbmRpbmdz LmNwcDoKKyAgICAgICAgKFdlYktpdDo6Z2V0Tm9kZUltcGwpOgorICAgICAgICAoV2ViS2l0KToK KyAgICAgICAgKFdlYktpdDo6V2ViQmluZGluZ3M6OmdldE5vZGUpOgorCiAyMDEyLTA2LTI1ICBL aW51a28gWWFzdWRhICA8a2ludWtvQGNocm9taXVtLm9yZz4KIAogICAgICAgICBIZWFwLXVzZS1h ZnRlci1mcmVlIGluIFdlYktpdDo6TWFpblRocmVhZEZpbGVTeXN0ZW1DYWxsYmFja3MKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkJpbmRpbmdzLmggYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJCaW5kaW5ncy5oCmluZGV4IDM0YTMyMDU1N2Qx M2JlODk2NDUxNDg5NmI4Y2I0OTg0MDdiYzQ4YzQuLmQxYjZiOGUxMGFhMzczMDNmYmVlOTU2OGNk YWRmYzI2NGJjNGM1YTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGlj L1dlYkJpbmRpbmdzLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQmlu ZGluZ3MuaApAQCAtMTUyLDYgKzE1MiwxMCBAQCBwdWJsaWM6CiAgICAgLy8gSWYgc28sIHJldHVy biBpdCBhcyBhIFdlYkFycmF5QnVmZmVyVmlldyBvYmplY3QuCiAgICAgV0VCS0lUX0VYUE9SVCBz dGF0aWMgYm9vbCBnZXRBcnJheUJ1ZmZlclZpZXcoTlBPYmplY3QqIGFycmF5QnVmZmVyVmlldywg V2ViQXJyYXlCdWZmZXJWaWV3Kik7CiAKKyAgICAvLyBSZXR1cm4gdHJ1ZSAoc3VjY2VzcykgaWYg dGhlIGdpdmVuIG5wb2JqIGlzIGEgbm9kZS4KKyAgICAvLyBJZiBzbywgcmV0dXJuIHRoYXQgZWxl bWVudCBhcyBhIFdlYk5vZGUgb2JqZWN0LgorICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wg Z2V0Tm9kZShOUE9iamVjdCogZWxlbWVudCwgV2ViTm9kZSopOworCiAgICAgLy8gUmV0dXJuIHRy dWUgKHN1Y2Nlc3MpIGlmIHRoZSBnaXZlbiBucG9iaiBpcyBhbiBlbGVtZW50LgogICAgIC8vIElm IHNvLCByZXR1cm4gdGhhdCBlbGVtZW50IGFzIGEgV2ViRWxlbWVudCBvYmplY3QuCiAgICAgV0VC S0lUX0VYUE9SVCBzdGF0aWMgYm9vbCBnZXRFbGVtZW50KE5QT2JqZWN0KiBlbGVtZW50LCBXZWJF bGVtZW50Kik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJCaW5k aW5ncy5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJCaW5kaW5ncy5jcHAKaW5k ZXggYzRmNDBkZjNkNDBlNzI1ZTZiOThlMmZmNGU4ZWI1YzE4NDVmMzAwZi4uOTI2ZGIzYjExMWNm ZTU3NWU0YzgzYTZiMDUwZDE4YjgzNWUyNzJiOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViQmluZGluZ3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYkJpbmRpbmdzLmNwcApAQCAtMjIxLDYgKzIyMSwyMSBAQCBzdGF0aWMgYm9vbCBnZXRS YW5nZUltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViUmFuZ2UqIHdlYlJhbmdlKQogICAgIHJldHVy biB0cnVlOwogfQogCitzdGF0aWMgYm9vbCBnZXROb2RlSW1wbChOUE9iamVjdCogb2JqZWN0LCBX ZWJOb2RlKiB3ZWJOb2RlKQoreworICAgIGlmICghb2JqZWN0IHx8IChvYmplY3QtPl9jbGFzcyAh PSBucFNjcmlwdE9iamVjdENsYXNzKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgVjhO UE9iamVjdCogdjhOUE9iamVjdCA9IHJlaW50ZXJwcmV0X2Nhc3Q8VjhOUE9iamVjdCo+KG9iamVj dCk7CisgICAgdjg6OkhhbmRsZTx2ODo6T2JqZWN0PiB2OE9iamVjdCh2OE5QT2JqZWN0LT52OE9i amVjdCk7CisgICAgTm9kZSogbmF0aXZlID0gVjhOb2RlOjpIYXNJbnN0YW5jZSh2OE9iamVjdCkg PyBWOE5vZGU6OnRvTmF0aXZlKHY4T2JqZWN0KSA6IDA7CisgICAgaWYgKCFuYXRpdmUpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgICp3ZWJOb2RlID0gV2ViTm9kZShuYXRpdmUpOworICAg IHJldHVybiB0cnVlOworfQorCiBzdGF0aWMgYm9vbCBnZXRFbGVtZW50SW1wbChOUE9iamVjdCog b2JqZWN0LCBXZWJFbGVtZW50KiB3ZWJFbGVtZW50KQogewogICAgIGlmICghb2JqZWN0IHx8IChv YmplY3QtPl9jbGFzcyAhPSBucFNjcmlwdE9iamVjdENsYXNzKSkKQEAgLTMyMCw2ICszMzUsMTYg QEAgYm9vbCBXZWJCaW5kaW5nczo6Z2V0QXJyYXlCdWZmZXJWaWV3KE5QT2JqZWN0KiBhcnJheUJ1 ZmZlclZpZXcsIFdlYkFycmF5QnVmZmVyVmkKICNlbmRpZgogfQogCitib29sIFdlYkJpbmRpbmdz OjpnZXROb2RlKE5QT2JqZWN0KiBub2RlLCBXZWJOb2RlKiB3ZWJOb2RlKQoreworI2lmIFVTRShW OCkKKyAgICByZXR1cm4gZ2V0Tm9kZUltcGwobm9kZSwgd2ViTm9kZSk7CisjZWxzZQorICAgIC8v IE5vdCBzdXBwb3J0ZWQgb24gb3RoZXIgcG9ydHMgKEpTQywgZXRjLikuCisgICAgcmV0dXJuIGZh bHNlOworI2VuZGlmCit9CisKIGJvb2wgV2ViQmluZGluZ3M6OmdldEVsZW1lbnQoTlBPYmplY3Qq IGVsZW1lbnQsIFdlYkVsZW1lbnQqIHdlYkVsZW1lbnQpCiB7CiAjaWYgVVNFKFY4KQpkaWZmIC0t Z2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IGI1NjNmOGU5MTg4 MDllYzc2NzA2NWQzMmI2NjA1Y2FkODExMWQ5NzcuLmI0ODRjY2QyNmNjOGQ4OTkwNzM0ZTE2NmEy ZjJmNzQ5MGRmZjdkZjkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29scy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwyMyBAQAorMjAxMi0wNi0yNiAgTGVhbmRybyBHcmFjaWEgR2ls ICA8bGVhbmRyb2dyYWNpYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJbXBs ZW1lbnQgYSBMYXlvdXQgVGVzdCBmb3IgZWRpdGluZy9TdXJyb3VuZGluZ1RleHQKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTgyNDYxCisKKyAgICAgICAg QWRkIGEgbmV3IG1ldGhvZCB0byB0aGUgbGF5b3V0IHRlc3QgY29udHJvbGxlciBpbiBvcmRlciB0 byByZXRyaWV2ZSB0aGUKKyAgICAgICAgdGV4dCBzdXJyb3VuZGluZyBhIHByb3ZpZGVkIGVsZW1l bnQuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBE dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIpOgorICAgICAgICAo TGF5b3V0VGVzdENvbnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQpOgorICAgICAgICAq IER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAg IChMYXlvdXRUZXN0Q29udHJvbGxlcik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21p dW0vV2ViVmlld0hvc3QuY3BwOgorICAgICAgICAoV2ViVmlld0hvc3Q6OnRleHRTdXJyb3VuZGlu Z0VsZW1lbnQpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0 Lmg6CisgICAgICAgIChXZWJWaWV3SG9zdCk6CisKIDIwMTItMDYtMjUgIFNpbW9uIEhhdXNtYW5u ICA8c2ltb24uaGF1c21hbm5Abm9raWEuY29tPgogCiAgICAgICAgIFtRdF0gRml4IFdpbjMyIGRl YnVnIGJ1aWxkCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlv dXRUZXN0Q29udHJvbGxlci5jcHAgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlv dXRUZXN0Q29udHJvbGxlci5jcHAKaW5kZXggMDZmMTQ2YzFjM2Q1Zjk1NDM1ODU4NmIyNjc5ZDdk OGNiMWU5Y2E1ZS4uMDAzNzM4NWI2MWFlMDNkMDhmMWFkNTE5YzUxYzFkNDcwYmQ1YzQyOSAxMDA2 NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xs ZXIuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250 cm9sbGVyLmNwcApAQCAtMjc3LDcgKzI3Nyw4IEBAIExheW91dFRlc3RDb250cm9sbGVyOjpMYXlv dXRUZXN0Q29udHJvbGxlcihUZXN0U2hlbGwqIHNoZWxsKQogICAgIGJpbmRNZXRob2QoInNldEZp eGVkTGF5b3V0U2l6ZSIsICZMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0Rml4ZWRMYXlvdXRTaXpl KTsKICAgICBiaW5kTWV0aG9kKCJzZWxlY3Rpb25Bc01hcmt1cCIsICZMYXlvdXRUZXN0Q29udHJv bGxlcjo6c2VsZWN0aW9uQXNNYXJrdXApOwogICAgIGJpbmRNZXRob2QoInNldEhhc0N1c3RvbUZ1 bGxTY3JlZW5CZWhhdmlvciIsICZMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0SGFzQ3VzdG9tRnVs bFNjcmVlbkJlaGF2aW9yKTsKLSAgICAKKyAgICBiaW5kTWV0aG9kKCJ0ZXh0U3Vycm91bmRpbmdF bGVtZW50IiwgJkxheW91dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KTsK KwogICAgIC8vIFRoZSBmYWxsYmFjayBtZXRob2QgaXMgY2FsbGVkIHdoZW4gYW4gdW5rbm93biBt ZXRob2QgaXMgaW52b2tlZC4KICAgICBiaW5kRmFsbGJhY2tNZXRob2QoJkxheW91dFRlc3RDb250 cm9sbGVyOjpmYWxsYmFja01ldGhvZCk7CiAKQEAgLTIzMTAsMyArMjMxMSwxNyBAQCB2b2lkIExh eW91dFRlc3RDb250cm9sbGVyOjpzZXRQb2ludGVyTG9ja1dpbGxGYWlsU3luY2hyb25vdXNseShj b25zdCBDcHBBcmd1bWVudAogICAgIHJlc3VsdC0+c2V0TnVsbCgpOwogfQogI2VuZGlmCisKK3Zv aWQgTGF5b3V0VGVzdENvbnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQoY29uc3QgQ3Bw QXJndW1lbnRMaXN0JiBhcmd1bWVudHMsIENwcFZhcmlhbnQqIHJlc3VsdCkKK3sKKyAgICByZXN1 bHQtPnNldE51bGwoKTsKKyAgICBpZiAoYXJndW1lbnRzLnNpemUoKSA8IDMgfHwgIWFyZ3VtZW50 c1swXS5pc09iamVjdCgpIHx8ICFhcmd1bWVudHNbMV0uaXNOdW1iZXIoKSB8fCAhYXJndW1lbnRz WzJdLmlzTnVtYmVyKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFdlYk5vZGUgbm9kZTsKKyAg ICBpZiAoIVdlYkJpbmRpbmdzOjpnZXROb2RlKGFyZ3VtZW50c1swXS52YWx1ZS5vYmplY3RWYWx1 ZSwgJm5vZGUpKQorICAgICAgICByZXR1cm47CisKKyAgICBXZWJTdHJpbmcgY29udGVudCA9IG1f c2hlbGwtPndlYlZpZXdIb3N0KCktPnRleHRTdXJyb3VuZGluZ0VsZW1lbnQobm9kZSwgYXJndW1l bnRzWzFdLnRvSW50MzIoKSwgYXJndW1lbnRzWzJdLnRvSW50MzIoKSk7CisgICAgcmVzdWx0LT5z ZXQoY29udGVudC51dGY4KCkpOworfQpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUv Y2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2No cm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmgKaW5kZXggYWYzOWIyZWY2ODYwZjYzNjE2OWFi OTVhNGUzMDI4MmY3NzA5NmY4OS4uMGU3NDg0MWI1NzYyMzNlYjRiOThkZTQ2YjY1MGQzM2UyNDc3 Nzc2NCAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVz dENvbnRyb2xsZXIuaAorKysgYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oCkBAIC00NTMsNiArNDUzLDExIEBAIHB1YmxpYzoKICAgICAvLyByZXN1 bHRpbmcgaW4gdGhlIGNoYW5nZWQgc2V0dGluZyBiZWluZyBpZ25vcmVkLgogICAgIHZvaWQgc2V0 VGV4dFN1YnBpeGVsUG9zaXRpb25pbmcoY29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFyaWFu dCopOwogCisgICAgLy8gUmV0cmlldmVzIHRoZSB0ZXh0IHN1cnJvdW5kaW5nIGEgcG9zaXRpb24g aW4gYSB0ZXh0IG5vZGUuCisgICAgLy8gVGhlIGZpcnN0IGNoaWxkIG9mIHRoZSBlbGVtZW50IGdp dmVuIHkgaXRzIGlkIHdpbGwgYmUgdXNlZCBhcyByZWZlcmVuY2UsCisgICAgLy8gb3IgaXRzIG5l eHQgc2libGluZyBpZiBub3QgcHJlc2VudC4gSXQgbXVzdCBiZSBhIHRleHQgbm9kZS4KKyAgICB2 b2lkIHRleHRTdXJyb3VuZGluZ0VsZW1lbnQoY29uc3QgQ3BwQXJndW1lbnRMaXN0JiwgQ3BwVmFy aWFudCopOworCiBwdWJsaWM6CiAgICAgLy8gVGhlIGZvbGxvd2luZyBtZXRob2RzIGFyZSBub3Qg ZXhwb3NlZCB0byBKYXZhU2NyaXB0LgogICAgIHZvaWQgc2V0V29ya1F1ZXVlRnJvemVuKGJvb2wg ZnJvemVuKSB7IG1fd29ya1F1ZXVlLnNldEZyb3plbihmcm96ZW4pOyB9CmRpZmYgLS1naXQgYS9U b29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAKaW5kZXggODhlMDczNzhmNDU3ZDll NTgyMGE1ZDU5NjJiZDBmYzNjMWQ4YmM0Zi4uZjcwYjRkZmFiMjRmN2M5Mjc4OWMyZGYwODM4NTYz MTFlZmNkMjVjNSAxMDA2NDQKLS0tIGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2Vi Vmlld0hvc3QuY3BwCisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdI b3N0LmNwcApAQCAtNjQsNiArNjQsNyBAQAogI2luY2x1ZGUgInBsYXRmb3JtL1dlYlNlcmlhbGl6 ZWRTY3JpcHRWYWx1ZS5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYlNpemUuaCIKICNpbmNsdWRl ICJXZWJTdG9yYWdlTmFtZXNwYWNlLmgiCisjaW5jbHVkZSAiV2ViU3Vycm91bmRpbmdUZXh0Lmgi CiAjaW5jbHVkZSAiV2ViVGV4dENoZWNraW5nQ29tcGxldGlvbi5oIgogI2luY2x1ZGUgIldlYlRl eHRDaGVja2luZ1Jlc3VsdC5oIgogI2luY2x1ZGUgIldlYlVzZXJNZWRpYUNsaWVudE1vY2suaCIK QEAgLTkwMSw2ICs5MDIsMTYgQEAgdm9pZCBXZWJWaWV3SG9zdDo6ZGlkTG9zZVBvaW50ZXJMb2Nr KCkKIH0KICNlbmRpZgogCitXZWJLaXQ6OldlYlN0cmluZyBXZWJWaWV3SG9zdDo6dGV4dFN1cnJv dW5kaW5nRWxlbWVudChjb25zdCBXZWJLaXQ6OldlYk5vZGUmIG5vZGUsIHVuc2lnbmVkIG9mZnNl dCwgdW5zaWduZWQgbWF4TGVuZ3RoKQoreworICAgIGlmIChub2RlLmlzTnVsbCgpIHx8ICFub2Rl LmlzVGV4dE5vZGUoKSB8fCBvZmZzZXQgPj0gbm9kZS5ub2RlVmFsdWUoKS5sZW5ndGgoKSkKKyAg ICAgICAgcmV0dXJuIFdlYlN0cmluZygpOworCisgICAgV2ViU3Vycm91bmRpbmdUZXh0IHN1cnJv dW5kaW5nVGV4dDsKKyAgICBzdXJyb3VuZGluZ1RleHQuaW5pdGlhbGl6ZShub2RlLCBvZmZzZXQs IG1heExlbmd0aCk7CisgICAgcmV0dXJuIHN1cnJvdW5kaW5nVGV4dC50ZXh0Q29udGVudCgpOwor fQorCiB2b2lkIFdlYlZpZXdIb3N0OjpzaG93KFdlYk5hdmlnYXRpb25Qb2xpY3kpCiB7CiAgICAg bV9oYXNXaW5kb3cgPSB0cnVlOwpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vV2ViVmlld0hvc3QuaCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZp ZXdIb3N0LmgKaW5kZXggY2UxODlkOTE1NGNiNDkwZWExMzRiMzNmZDQ5YzA2MjNlNjI5N2Y5Yi4u NDk0MDQyMTEyOTVjYTlkMzZjYTNkYTZiMTA4NDliZDI3MGYzMDNmMyAxMDA2NDQKLS0tIGEvVG9v bHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuaAorKysgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCkBAIC0xMjgsNiArMTI4LDggQEAgY2xh c3MgV2ViVmlld0hvc3QgOiBwdWJsaWMgV2ViS2l0OjpXZWJWaWV3Q2xpZW50LCBwdWJsaWMgV2Vi S2l0OjpXZWJGcmFtZUNsaWVudCwKICAgICB2b2lkIHNldFBvaW50ZXJMb2NrV2lsbEZhaWxTeW5j aHJvbm91c2x5KCkgeyBtX3BvaW50ZXJMb2NrUGxhbm5lZFJlc3VsdCA9IFBvaW50ZXJMb2NrV2ls bEZhaWxTeW5jOyB9CiAjZW5kaWYKIAorICAgIFdlYktpdDo6V2ViU3RyaW5nIHRleHRTdXJyb3Vu ZGluZ0VsZW1lbnQoY29uc3QgV2ViS2l0OjpXZWJOb2RlJiwgdW5zaWduZWQgb2Zmc2V0LCB1bnNp Z25lZCBtYXhMZW5ndGgpOworCiAgICAgLy8gTmF2aWdhdGlvbkhvc3QKICAgICB2aXJ0dWFsIGJv b2wgbmF2aWdhdGUoY29uc3QgVGVzdE5hdmlnYXRpb25FbnRyeSYsIGJvb2wgcmVsb2FkKTsKIApk aWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CmluZGV4IGYxMTRkZjIwMjZiNDM4MGM1OWIzYjhkZGJhM2NkMGU3YWVjMjkzZjIuLjBmNWM5MTI1 MzA4MmYwMGIzMzdhM2MxYjE3NThjMTBjMmM4ZGY0YjEgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3Rz L0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAor MjAxMi0wNi0yNiAgTGVhbmRybyBHcmFjaWEgR2lsICA8bGVhbmRyb2dyYWNpYUBjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJbXBsZW1lbnQgYSBMYXlvdXQgVGVzdCBmb3IgZWRp dGluZy9TdXJyb3VuZGluZ1RleHQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTgyNDYxCisKKyAgICAgICAgQWRkIGEgbmV3IGxheW91dCB0ZXN0IGZvciB0 aGUgc3Vycm91bmRpbmcgdGV4dCBmZWF0dXJlLgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJv dW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJv bWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC5odG1sOiBBZGRlZC4KKwogMjAxMi0wNi0y NSAgQWxsYW4gU2FuZGZlbGQgSmVuc2VuICA8YWxsYW4uamVuc2VuQG5va2lhLmNvbT4KIAogICAg ICAgICBbUXRdIFVuc2tpcCAzRCB0cmFuc2Zvcm0gdGVzdHMuCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3Rl ZC50eHQgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRp bmctdGV4dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTEyYzFjNTJkYmJjM2Q1YjAxNjNiYjk2 NDgwMmQ5NGI3ZTRkYmVkZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRmb3Jt L2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDIxIEBACitUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRoZSB0ZXh0IHN1cnJvdW5kaW5nIGFu IGVsZW1lbnQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIg bWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIHN1cnJvdW5k aW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwv cD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgMCwgMTAwKSBpcyAiMTIzNDUgNjc4OSAxMjM0NSA2 Nzg5IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9 ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDUsIDYpIGlzICI4 OSAxMjMiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBp ZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgNSwgMCkgaXMg IiIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJo ZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA1LCAxKSBpcyAiMSIK K1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJl Ij42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA2LCAyKSBpcyAiMTIiCitQ QVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+ Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgMTAwLCA1KSBpcyAiIgorUEFT UyBzdXJyb3VuZGluZ1RleHQoJzxzZWxlY3Q+Ljwvc2VsZWN0PjxkaXY+NTd0aCBTdHJlZXQgYW5k IExha2UgU2hvcmUgRHJpdmU8L2Rpdj4gPHNwYW4+Q2hpY2Fnbzwvc3Bhbj4gPHNwYW4gaWQ9Imhl cmUiPklMPC9zcGFuPiA8c3Bhbj42MDYzNzwvc3Bhbj48c2VsZWN0Pi48L3NlbGVjdD4nLCAwLCAx MDApIGlzICI1N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZSBDaGljYWdvIElMIDYwNjM3 IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxmaWVsZHNldD4uPC9maWVsZHNldD4xMjM0NTxidXR0 b24+YWJjPC9idXR0b24+PHA+Njc4OTxiciBpZD0iaGVyZSIvPjEyMzQ1PC9wPjY3ODk8dGV4dGFy ZWE+YWJjPC90ZXh0YXJlYT4wMTIzPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PicsIDAsIDEwMCkgaXMg IjY3ODkgMTIzNDUgNjc4OSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRv bj48ZGl2IGlkPSJoZXJlIj5UaGlzIGlzIDwhLS0gY29tbWVudCAtLSE+YSB0ZXN0IDwnICsgJ3Nj cmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCI+PCcgKyAnL3NjcmlwdD5leGFtcGxlPGJ1dHRvbj4u PC9idXR0b24+JywgMCwgMTAwKSBpcyAiVGhpcyBpcyBhIHRlc3QgZXhhbXBsZSIKK1BBU1Mgc3Vy cm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj4wMTIzNDU2Nzg5 MDEyMzQ1Njc4OTAxMjM0NTY3ODk8L2Rpdj48YnV0dG9uPi48L2J1dHRvbj4nLCAxNSwgMTIpIGlz ICI5MDEyMzQ1Njc4OTAiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPG9wdGlvbj4uPC9vcHRpb24+ MTIzNDU8YnV0dG9uIGlkPSJoZXJlIj50ZXN0PC9idXR0b24+PG9wdGlvbj4uPC9vcHRpb24+Jywg MCwgMTAwKSBpcyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxvcHRpb24+Ljwvb3B0aW9uPjEy MzQ1PGJ1dHRvbj50ZTxzcGFuIGlkPSJoZXJlIj5zdDwvc3Bhbj48L2J1dHRvbj48b3B0aW9uPi48 L29wdGlvbj4nLCAwLCAxMDApIGlzICIiCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl CisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hy b21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbCBiL0xheW91dFRlc3RzL3BsYXRm b3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0Lmh0bWwKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4u Yjk0YjMyNjFmMjM0OTE4Y2FjYTA2NTAzMmMxNDk4YTg0OWI3NmM3MwotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10 ZXh0Lmh0bWwKQEAgLTAsMCArMSw2MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxoZWFk PgorPG1ldGEgY2hhcnNldD0idXRmLTgiPgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL2Zhc3Qv anMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxib2R5Pgor PGRpdiBpZD0idGVzdCI+Cis8L2Rpdj4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBp ZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+CitkZXNj cmlwdGlvbignVGVzdCB0aGUgZXh0cmFjdGlvbiBvZiB0aGUgdGV4dCBzdXJyb3VuZGluZyBhbiBl bGVtZW50LicpOworCitmdW5jdGlvbiBzdXJyb3VuZGluZ1RleHQoaHRtbCwgb2Zmc2V0LCBtYXhM ZW5ndGgpIHsKKyAgdmFyIHRlc3QgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpOwor ICB0ZXN0LmlubmVySFRNTCA9IGh0bWw7CisKKyAgdmFyIGhlcmUgPSBkb2N1bWVudC5nZXRFbGVt ZW50QnlJZCgnaGVyZScpOworICBpZiAoaGVyZSA9PSBudWxsKSB7CisgICAgICB0aHJvdyAnVGVz dCBjYXNlIG5lZWRzIGFuIGVsZW1lbnQgd2l0aCBpZCAiaGVyZSInOworICB9CisKKyAgdmFyIG5v ZGUgPSBoZXJlLmhhc0NoaWxkTm9kZXMoKSA/IGhlcmUuZmlyc3RDaGlsZCA6IGhlcmUubmV4dFNp Ymxpbmc7CisgIGlmIChub2RlID09IG51bGwpIHsKKyAgICAgIHRocm93ICdObyBub2RlIGFmdGVy ICJoZXJlIiBlbGVtZW50JzsKKyAgfQorCisgIHZhciB0ZXh0ID0gd2luZG93LnRlc3RSdW5uZXIu dGV4dFN1cnJvdW5kaW5nRWxlbWVudChub2RlLCBvZmZzZXQsIG1heExlbmd0aCk7CisgIHJldHVy biB0ZXh0LnJlcGxhY2UoL1xzKy9nLCAnICcpLnJlcGxhY2UoL15ccyp8XHMqJC9nLCAnJyk7Cit9 CisKK2Z1bmN0aW9uIHJ1bigpIHsKKyAgICBpZiAoIXdpbmRvdy50ZXN0UnVubmVyKQorICAgICAg ICByZXR1cm47CisKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChc JzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxi dXR0b24+LjwvYnV0dG9uPlwnLCAwLCAxMDApJywgJzEyMzQ1IDY3ODkgMTIzNDUgNjc4OScpOwor ICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9i dXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0 b24+XCcsIDUsIDYpJywgJzg5IDEyMycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vy cm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAx MjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDUsIDApJywgJycpOworICAgIHNob3Vs ZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIz NDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDUs IDEpJywgJzEnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChc JzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxi dXR0b24+LjwvYnV0dG9uPlwnLCA2LCAyKScsICcxMicpOworICAgIHNob3VsZEJlRXF1YWxUb1N0 cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVy ZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDEwMCwgNSknLCAnJyk7 CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8c2VsZWN0Pi48 L3NlbGVjdD48ZGl2PjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3JlIERyaXZlPC9kaXY+IDxzcGFu PkNoaWNhZ288L3NwYW4+IDxzcGFuIGlkPSJoZXJlIj5JTDwvc3Bhbj4gPHNwYW4+NjA2Mzc8L3Nw YW4+PHNlbGVjdD4uPC9zZWxlY3Q+XCcsIDAsIDEwMCknLCAnNTd0aCBTdHJlZXQgYW5kIExha2Ug U2hvcmUgRHJpdmUgQ2hpY2FnbyBJTCA2MDYzNycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmlu Zygnc3Vycm91bmRpbmdUZXh0KFwnPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PjEyMzQ1PGJ1dHRvbj5h YmM8L2J1dHRvbj48cD42Nzg5PGJyIGlkPSJoZXJlIi8+MTIzNDU8L3A+Njc4OTx0ZXh0YXJlYT5h YmM8L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+XCcsIDAsIDEwMCknLCAnNjc4 OSAxMjM0NSA2Nzg5Jyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1Rl eHQoXCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj5UaGlzIGlzIDwhLS0gY29tbWVu dCAtLSE+YSB0ZXN0IDxcJyArIFwnc2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0Ij48XCcgKyBc Jy9zY3JpcHQ+ZXhhbXBsZTxidXR0b24+LjwvYnV0dG9uPlwnLCAwLCAxMDApJywgJ1RoaXMgaXMg YSB0ZXN0IGV4YW1wbGUnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5n VGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPjAxMjM0NTY3ODkwMTIzNDU2 Nzg5MDEyMzQ1Njc4OTwvZGl2PjxidXR0b24+LjwvYnV0dG9uPlwnLCAxNSwgMTIpJywgJzkwMTIz NDU2Nzg5MCcpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwn PG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uIGlkPSJoZXJlIj50ZXN0PC9idXR0b24+PG9w dGlvbj4uPC9vcHRpb24+XCcsIDAsIDEwMCknLCAnJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8b3B0aW9uPi48L29wdGlvbj4xMjM0NTxidXR0b24+dGU8 c3BhbiBpZD0iaGVyZSI+c3Q8L3NwYW4+PC9idXR0b24+PG9wdGlvbj4uPC9vcHRpb24+XCcsIDAs IDEwMCknLCAnJyk7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxkKGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCd0ZXN0JykpOworICAgIGZpbmlzaEpTVGVzdCgpOworfQorCit3aW5kb3cu b25sb2FkID0gcnVuOword2luZG93LmpzVGVzdElzQXN5bmMgPSB0cnVlOword2luZG93LnN1Y2Nl c3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi8u Li9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgo= 149724 2012-06-27 04:25:56 -0700 2012-07-02 10:15:28 -0700 Patch bug-82461-20120627122555.patch text/plain 15239 leandrogracia U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxMzM1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IDM2NWQwZWIzY2NhNTFmMmVmYmM1MjVhMjE3YzFhMzYwZWI5YzU5ZTguLmI5YmZiMDM4NmY4Mjhl NjEwYzQxNDk2NWIzYzM2ZmVlY2ZjMTkzMTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTkgQEAKKzIwMTItMDYtMjYgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9n cmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5 b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAgIEFsbG93IHBhc3Np bmcgbm9kZXMgYXMgYXJndW1lbnRzIGZvciBsYXlvdXQgdGVzdCBtZXRob2RzLgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL1dlYkJpbmRp bmdzLmg6CisgICAgICAgIChXZWJCaW5kaW5ncyk6CisgICAgICAgICogc3JjL1dlYkJpbmRpbmdz LmNwcDoKKyAgICAgICAgKFdlYktpdDo6Z2V0Tm9kZUltcGwpOgorICAgICAgICAoV2ViS2l0KToK KyAgICAgICAgKFdlYktpdDo6V2ViQmluZGluZ3M6OmdldE5vZGUpOgorCiAyMDEyLTA2LTI2ICBT aGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJl dmlld2VkLiAgUm9sbGVkIERFUFMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJCaW5kaW5ncy5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi QmluZGluZ3MuaAppbmRleCAzNGEzMjA1NTdkMTNiZTg5NjQ1MTQ4OTZiOGNiNDk4NDA3YmM0OGM0 Li5kMWI2YjhlMTBhYTM3MzAzZmJlZTk1NjhjZGFkZmMyNjRiYzRjNWE0IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJCaW5kaW5ncy5oCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkJpbmRpbmdzLmgKQEAgLTE1Miw2ICsxNTIsMTAgQEAg cHVibGljOgogICAgIC8vIElmIHNvLCByZXR1cm4gaXQgYXMgYSBXZWJBcnJheUJ1ZmZlclZpZXcg b2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0QXJyYXlCdWZmZXJWaWV3 KE5QT2JqZWN0KiBhcnJheUJ1ZmZlclZpZXcsIFdlYkFycmF5QnVmZmVyVmlldyopOwogCisgICAg Ly8gUmV0dXJuIHRydWUgKHN1Y2Nlc3MpIGlmIHRoZSBnaXZlbiBucG9iaiBpcyBhIG5vZGUuCisg ICAgLy8gSWYgc28sIHJldHVybiB0aGF0IGVsZW1lbnQgYXMgYSBXZWJOb2RlIG9iamVjdC4KKyAg ICBXRUJLSVRfRVhQT1JUIHN0YXRpYyBib29sIGdldE5vZGUoTlBPYmplY3QqIGVsZW1lbnQsIFdl Yk5vZGUqKTsKKwogICAgIC8vIFJldHVybiB0cnVlIChzdWNjZXNzKSBpZiB0aGUgZ2l2ZW4gbnBv YmogaXMgYW4gZWxlbWVudC4KICAgICAvLyBJZiBzbywgcmV0dXJuIHRoYXQgZWxlbWVudCBhcyBh IFdlYkVsZW1lbnQgb2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0RWxl bWVudChOUE9iamVjdCogZWxlbWVudCwgV2ViRWxlbWVudCopOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViQmluZGluZ3MuY3BwIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvV2ViQmluZGluZ3MuY3BwCmluZGV4IGM0ZjQwZGYzZDQwZTcyNWU2Yjk4ZTJmZjRl OGViNWMxODQ1ZjMwMGYuLjkyNmRiM2IxMTFjZmU1NzVlNGM4M2E2YjA1MGQxOGI4MzVlMjcyYjgg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkJpbmRpbmdzLmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJCaW5kaW5ncy5jcHAKQEAgLTIyMSw2 ICsyMjEsMjEgQEAgc3RhdGljIGJvb2wgZ2V0UmFuZ2VJbXBsKE5QT2JqZWN0KiBvYmplY3QsIFdl YlJhbmdlKiB3ZWJSYW5nZSkKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorc3RhdGljIGJvb2wgZ2V0 Tm9kZUltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViTm9kZSogd2ViTm9kZSkKK3sKKyAgICBpZiAo IW9iamVjdCB8fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmplY3RDbGFzcykpCisgICAg ICAgIHJldHVybiBmYWxzZTsKKworICAgIFY4TlBPYmplY3QqIHY4TlBPYmplY3QgPSByZWludGVy cHJldF9jYXN0PFY4TlBPYmplY3QqPihvYmplY3QpOworICAgIHY4OjpIYW5kbGU8djg6Ok9iamVj dD4gdjhPYmplY3QodjhOUE9iamVjdC0+djhPYmplY3QpOworICAgIE5vZGUqIG5hdGl2ZSA9IFY4 Tm9kZTo6SGFzSW5zdGFuY2UodjhPYmplY3QpID8gVjhOb2RlOjp0b05hdGl2ZSh2OE9iamVjdCkg OiAwOworICAgIGlmICghbmF0aXZlKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAqd2Vi Tm9kZSA9IFdlYk5vZGUobmF0aXZlKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogc3RhdGljIGJv b2wgZ2V0RWxlbWVudEltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViRWxlbWVudCogd2ViRWxlbWVu dCkKIHsKICAgICBpZiAoIW9iamVjdCB8fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmpl Y3RDbGFzcykpCkBAIC0zMjAsNiArMzM1LDE2IEBAIGJvb2wgV2ViQmluZGluZ3M6OmdldEFycmF5 QnVmZmVyVmlldyhOUE9iamVjdCogYXJyYXlCdWZmZXJWaWV3LCBXZWJBcnJheUJ1ZmZlclZpCiAj ZW5kaWYKIH0KIAorYm9vbCBXZWJCaW5kaW5nczo6Z2V0Tm9kZShOUE9iamVjdCogbm9kZSwgV2Vi Tm9kZSogd2ViTm9kZSkKK3sKKyNpZiBVU0UoVjgpCisgICAgcmV0dXJuIGdldE5vZGVJbXBsKG5v ZGUsIHdlYk5vZGUpOworI2Vsc2UKKyAgICAvLyBOb3Qgc3VwcG9ydGVkIG9uIG90aGVyIHBvcnRz IChKU0MsIGV0Yy4pLgorICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorfQorCiBib29sIFdlYkJp bmRpbmdzOjpnZXRFbGVtZW50KE5QT2JqZWN0KiBlbGVtZW50LCBXZWJFbGVtZW50KiB3ZWJFbGVt ZW50KQogewogI2lmIFVTRShWOCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xz L0NoYW5nZUxvZwppbmRleCBkNzc3ZWUzZTM4YmM5MWEwOTFhNWE2OThhNjY0NDRhNGJkOWI1YTZm Li5iNDNlOWRlMDU5MjVhYjA1YmFiYzgzMjdmZWRlYzZhOGU4ZjZhNTJhIDEwMDY0NAotLS0gYS9U b29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIw MTItMDYtMjYgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9ncmFjaWFAY2hyb21pdW0ub3Jn PgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5b3V0IFRlc3QgZm9yIGVkaXRp bmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAgIEFkZCBhIG5ldyBtZXRob2QgdG8gdGhlIGxheW91 dCB0ZXN0IGNvbnRyb2xsZXIgaW4gb3JkZXIgdG8gcmV0cmlldmUgdGhlCisgICAgICAgIHRleHQg c3Vycm91bmRpbmcgYSBwcm92aWRlZCBlbGVtZW50LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5P Qk9EWSAoT09QUyEpLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0 VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91 dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vy cm91bmRpbmdFbGVtZW50KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlv dXRUZXN0Q29udHJvbGxlci5oOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXIpOgorICAg ICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcDoKKyAgICAgICAg KFdlYlZpZXdIb3N0Ojp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KToKKyAgICAgICAgKiBEdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oOgorICAgICAgICAoV2ViVmlld0hvc3QpOgor CiAyMDEyLTA2LTI3ICBaYW4gRG9iZXJzZWsgIDx6YW5kb2JlcnNla0BnbWFpbC5jb20+CiAKICAg ICAgICAgW0d0a10gQWRkIHN1cHBvcnQgZm9yIHRoZSBHYW1lcGFkIEFQSQpkaWZmIC0tZ2l0IGEv VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCmlu ZGV4IDA2ZjE0NmMxYzNkNWY5NTQzNTg1ODZiMjY3OWQ3ZDhjYjFlOWNhNWUuLjAwMzczODViNjFh ZTAzZDA4ZjFhZDUxOWM1MWMxZDQ3MGJkNWM0MjkgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5k ZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAorKysgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKQEAgLTI3Nyw3ICsy NzcsOCBAQCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIoVGVzdFNo ZWxsKiBzaGVsbCkKICAgICBiaW5kTWV0aG9kKCJzZXRGaXhlZExheW91dFNpemUiLCAmTGF5b3V0 VGVzdENvbnRyb2xsZXI6OnNldEZpeGVkTGF5b3V0U2l6ZSk7CiAgICAgYmluZE1ldGhvZCgic2Vs ZWN0aW9uQXNNYXJrdXAiLCAmTGF5b3V0VGVzdENvbnRyb2xsZXI6OnNlbGVjdGlvbkFzTWFya3Vw KTsKICAgICBiaW5kTWV0aG9kKCJzZXRIYXNDdXN0b21GdWxsU2NyZWVuQmVoYXZpb3IiLCAmTGF5 b3V0VGVzdENvbnRyb2xsZXI6OnNldEhhc0N1c3RvbUZ1bGxTY3JlZW5CZWhhdmlvcik7Ci0gICAg CisgICAgYmluZE1ldGhvZCgidGV4dFN1cnJvdW5kaW5nRWxlbWVudCIsICZMYXlvdXRUZXN0Q29u dHJvbGxlcjo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudCk7CisKICAgICAvLyBUaGUgZmFsbGJhY2sg bWV0aG9kIGlzIGNhbGxlZCB3aGVuIGFuIHVua25vd24gbWV0aG9kIGlzIGludm9rZWQuCiAgICAg YmluZEZhbGxiYWNrTWV0aG9kKCZMYXlvdXRUZXN0Q29udHJvbGxlcjo6ZmFsbGJhY2tNZXRob2Qp OwogCkBAIC0yMzEwLDMgKzIzMTEsMTcgQEAgdm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0 UG9pbnRlckxvY2tXaWxsRmFpbFN5bmNocm9ub3VzbHkoY29uc3QgQ3BwQXJndW1lbnQKICAgICBy ZXN1bHQtPnNldE51bGwoKTsKIH0KICNlbmRpZgorCit2b2lkIExheW91dFRlc3RDb250cm9sbGVy Ojp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNvbnN0IENwcEFyZ3VtZW50TGlzdCYgYXJndW1lbnRz LCBDcHBWYXJpYW50KiByZXN1bHQpCit7CisgICAgcmVzdWx0LT5zZXROdWxsKCk7CisgICAgaWYg KGFyZ3VtZW50cy5zaXplKCkgPCAzIHx8ICFhcmd1bWVudHNbMF0uaXNPYmplY3QoKSB8fCAhYXJn dW1lbnRzWzFdLmlzTnVtYmVyKCkgfHwgIWFyZ3VtZW50c1syXS5pc051bWJlcigpKQorICAgICAg ICByZXR1cm47CisKKyAgICBXZWJOb2RlIG5vZGU7CisgICAgaWYgKCFXZWJCaW5kaW5nczo6Z2V0 Tm9kZShhcmd1bWVudHNbMF0udmFsdWUub2JqZWN0VmFsdWUsICZub2RlKSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgV2ViU3RyaW5nIGNvbnRlbnQgPSBtX3NoZWxsLT53ZWJWaWV3SG9zdCgpLT50 ZXh0U3Vycm91bmRpbmdFbGVtZW50KG5vZGUsIGFyZ3VtZW50c1sxXS50b0ludDMyKCksIGFyZ3Vt ZW50c1syXS50b0ludDMyKCkpOworICAgIHJlc3VsdC0+c2V0KGNvbnRlbnQudXRmOCgpKTsKK30K ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250 cm9sbGVyLmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCmluZGV4IGFmMzliMmVmNjg2MGY2MzYxNjlhYjk1YTRlMzAyODJmNzcwOTZmODkuLjBl NzQ4NDFiNTc2MjMzZWI0Yjk4ZGU0NmI2NTBkMzNlMjQ3Nzc3NjQgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmgKKysrIGIvVG9v bHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuaApAQCAtNDUz LDYgKzQ1MywxMSBAQCBwdWJsaWM6CiAgICAgLy8gcmVzdWx0aW5nIGluIHRoZSBjaGFuZ2VkIHNl dHRpbmcgYmVpbmcgaWdub3JlZC4KICAgICB2b2lkIHNldFRleHRTdWJwaXhlbFBvc2l0aW9uaW5n KGNvbnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsKIAorICAgIC8vIFJldHJpZXZl cyB0aGUgdGV4dCBzdXJyb3VuZGluZyBhIHBvc2l0aW9uIGluIGEgdGV4dCBub2RlLgorICAgIC8v IFRoZSBmaXJzdCBjaGlsZCBvZiB0aGUgZWxlbWVudCBnaXZlbiB5IGl0cyBpZCB3aWxsIGJlIHVz ZWQgYXMgcmVmZXJlbmNlLAorICAgIC8vIG9yIGl0cyBuZXh0IHNpYmxpbmcgaWYgbm90IHByZXNl bnQuIEl0IG11c3QgYmUgYSB0ZXh0IG5vZGUuCisgICAgdm9pZCB0ZXh0U3Vycm91bmRpbmdFbGVt ZW50KGNvbnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsKKwogcHVibGljOgogICAg IC8vIFRoZSBmb2xsb3dpbmcgbWV0aG9kcyBhcmUgbm90IGV4cG9zZWQgdG8gSmF2YVNjcmlwdC4K ICAgICB2b2lkIHNldFdvcmtRdWV1ZUZyb3plbihib29sIGZyb3plbikgeyBtX3dvcmtRdWV1ZS5z ZXRGcm96ZW4oZnJvemVuKTsgfQpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hy b21pdW0vV2ViVmlld0hvc3QuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2Vi Vmlld0hvc3QuY3BwCmluZGV4IDg4ZTA3Mzc4ZjQ1N2Q5ZTU4MjBhNWQ1OTYyYmQwZmMzYzFkOGJj NGYuLmY3MGI0ZGZhYjI0ZjdjOTI3ODljMmRmMDgzODU2MzExZWZjZDI1YzUgMTAwNjQ0Ci0tLSBh L1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAorKysgYi9Ub29s cy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAKQEAgLTY0LDYgKzY0LDcg QEAKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJTZXJpYWxpemVkU2NyaXB0VmFsdWUuaCIKICNpbmNs dWRlICJwbGF0Zm9ybS9XZWJTaXplLmgiCiAjaW5jbHVkZSAiV2ViU3RvcmFnZU5hbWVzcGFjZS5o IgorI2luY2x1ZGUgIldlYlN1cnJvdW5kaW5nVGV4dC5oIgogI2luY2x1ZGUgIldlYlRleHRDaGVj a2luZ0NvbXBsZXRpb24uaCIKICNpbmNsdWRlICJXZWJUZXh0Q2hlY2tpbmdSZXN1bHQuaCIKICNp bmNsdWRlICJXZWJVc2VyTWVkaWFDbGllbnRNb2NrLmgiCkBAIC05MDEsNiArOTAyLDE2IEBAIHZv aWQgV2ViVmlld0hvc3Q6OmRpZExvc2VQb2ludGVyTG9jaygpCiB9CiAjZW5kaWYKIAorV2ViS2l0 OjpXZWJTdHJpbmcgV2ViVmlld0hvc3Q6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQoY29uc3QgV2Vi S2l0OjpXZWJOb2RlJiBub2RlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIG1heExlbmd0aCkK K3sKKyAgICBpZiAobm9kZS5pc051bGwoKSB8fCAhbm9kZS5pc1RleHROb2RlKCkgfHwgb2Zmc2V0 ID49IG5vZGUubm9kZVZhbHVlKCkubGVuZ3RoKCkpCisgICAgICAgIHJldHVybiBXZWJTdHJpbmco KTsKKworICAgIFdlYlN1cnJvdW5kaW5nVGV4dCBzdXJyb3VuZGluZ1RleHQ7CisgICAgc3Vycm91 bmRpbmdUZXh0LmluaXRpYWxpemUobm9kZSwgb2Zmc2V0LCBtYXhMZW5ndGgpOworICAgIHJldHVy biBzdXJyb3VuZGluZ1RleHQudGV4dENvbnRlbnQoKTsKK30KKwogdm9pZCBXZWJWaWV3SG9zdDo6 c2hvdyhXZWJOYXZpZ2F0aW9uUG9saWN5KQogewogICAgIG1faGFzV2luZG93ID0gdHJ1ZTsKZGlm ZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmggYi9U b29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCmluZGV4IGNlMTg5ZDkx NTRjYjQ5MGVhMTM0YjMzZmQ0OWMwNjIzZTYyOTdmOWIuLjQ5NDA0MjExMjk1Y2E5ZDM2Y2EzZGE2 YjEwODQ5YmQyNzBmMzAzZjMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9t aXVtL1dlYlZpZXdIb3N0LmgKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2Vi Vmlld0hvc3QuaApAQCAtMTI4LDYgKzEyOCw4IEBAIGNsYXNzIFdlYlZpZXdIb3N0IDogcHVibGlj IFdlYktpdDo6V2ViVmlld0NsaWVudCwgcHVibGljIFdlYktpdDo6V2ViRnJhbWVDbGllbnQsCiAg ICAgdm9pZCBzZXRQb2ludGVyTG9ja1dpbGxGYWlsU3luY2hyb25vdXNseSgpIHsgbV9wb2ludGVy TG9ja1BsYW5uZWRSZXN1bHQgPSBQb2ludGVyTG9ja1dpbGxGYWlsU3luYzsgfQogI2VuZGlmCiAK KyAgICBXZWJLaXQ6OldlYlN0cmluZyB0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNvbnN0IFdlYktp dDo6V2ViTm9kZSYsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgbWF4TGVuZ3RoKTsKKwogICAg IC8vIE5hdmlnYXRpb25Ib3N0CiAgICAgdmlydHVhbCBib29sIG5hdmlnYXRlKGNvbnN0IFRlc3RO YXZpZ2F0aW9uRW50cnkmLCBib29sIHJlbG9hZCk7CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3Rz L0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCBlZmFiNWY5MTBlNzY1Yzk2 NTQ2MDE4MWViZDMwMzY3MDYwMGU2NTI1Li4yYTU2NjFmMGJiYjM2NDhlZmM0MzI0OTg0NDNmZjI3 MTFjZjU2ZmJhIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMDYtMjYgIExlYW5kcm8gR3Jh Y2lhIEdpbCAgPGxlYW5kcm9ncmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1 bV0gSW1wbGVtZW50IGEgTGF5b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0Cisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisg ICAgICAgIEFkZCBhIG5ldyBsYXlvdXQgdGVzdCBmb3IgdGhlIHN1cnJvdW5kaW5nIHRleHQgZmVh dHVyZS4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IHBsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4 dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5k aW5nLXRleHQuaHRtbDogQWRkZWQuCisKIDIwMTItMDYtMjcgIFpvbHRhbiBBcnZhaSAgPHphcnZh aUBpbmYudS1zemVnZWQuaHU+CiAKICAgICAgICAgW1F0XSBVbnJldmlld2VkIGdhcmRlbmluZywg cmViYXNlbGluZSBhZnRlciByMTIxMzAzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvcGxhdGZv cm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0IGIvTGF5 b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQtZXhw ZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAuLjkxMmMxYzUyZGJiYzNkNWIwMTYzYmI5NjQ4MDJkOTRiN2U0 ZGJlZGQKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9m YXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQKQEAgLTAsMCArMSwyMSBAQAor VGVzdCB0aGUgZXh0cmFjdGlvbiBvZiB0aGUgdGV4dCBzdXJyb3VuZGluZyBhbiBlbGVtZW50Lgor CitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBm b2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisKKworUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxi dXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0 b24+LjwvYnV0dG9uPicsIDAsIDEwMCkgaXMgIjEyMzQ1IDY3ODkgMTIzNDUgNjc4OSIKK1BBU1Mg c3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5 IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA1LCA2KSBpcyAiODkgMTIzIgorUEFT UyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3 ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDUsIDApIGlzICIiCitQQVNTIHN1 cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAx MjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgNSwgMSkgaXMgIjEiCitQQVNTIHN1cnJv dW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0 NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgNiwgMikgaXMgIjEyIgorUEFTUyBzdXJyb3Vu ZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8 L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDEwMCwgNSkgaXMgIiIKK1BBU1Mgc3Vycm91bmRp bmdUZXh0KCc8c2VsZWN0Pi48L3NlbGVjdD48ZGl2PjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3Jl IERyaXZlPC9kaXY+IDxzcGFuPkNoaWNhZ288L3NwYW4+IDxzcGFuIGlkPSJoZXJlIj5JTDwvc3Bh bj4gPHNwYW4+NjA2Mzc8L3NwYW4+PHNlbGVjdD4uPC9zZWxlY3Q+JywgMCwgMTAwKSBpcyAiNTd0 aCBTdHJlZXQgYW5kIExha2UgU2hvcmUgRHJpdmUgQ2hpY2FnbyBJTCA2MDYzNyIKK1BBU1Mgc3Vy cm91bmRpbmdUZXh0KCc8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+MTIzNDU8YnV0dG9uPmFiYzwvYnV0 dG9uPjxwPjY3ODk8YnIgaWQ9ImhlcmUiLz4xMjM0NTwvcD42Nzg5PHRleHRhcmVhPmFiYzwvdGV4 dGFyZWE+MDEyMzxmaWVsZHNldD4uPC9maWVsZHNldD4nLCAwLCAxMDApIGlzICI2Nzg5IDEyMzQ1 IDY3ODkiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+PGRpdiBpZD0i aGVyZSI+VGhpcyBpcyA8IS0tIGNvbW1lbnQgLS0hPmEgdGVzdCA8JyArICdzY3JpcHQgbGFuZ3Vh Z2U9ImphdmFzY3JpcHQiPjwnICsgJy9zY3JpcHQ+ZXhhbXBsZTxidXR0b24+LjwvYnV0dG9uPics IDAsIDEwMCkgaXMgIlRoaXMgaXMgYSB0ZXN0IGV4YW1wbGUiCitQQVNTIHN1cnJvdW5kaW5nVGV4 dCgnPGJ1dHRvbj4uPC9idXR0b24+PGRpdiBpZD0iaGVyZSI+MDEyMzQ1Njc4OTAxMjM0NTY3ODkw MTIzNDU2Nzg5PC9kaXY+PGJ1dHRvbj4uPC9idXR0b24+JywgMTUsIDEyKSBpcyAiOTAxMjM0NTY3 ODkwIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxvcHRpb24+Ljwvb3B0aW9uPjEyMzQ1PGJ1dHRv biBpZD0iaGVyZSI+dGVzdDwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0aW9uPicsIDAsIDEwMCkgaXMg IiIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8b3B0aW9uPi48L29wdGlvbj4xMjM0NTxidXR0b24+ dGU8c3BhbiBpZD0iaGVyZSI+c3Q8L3NwYW4+PC9idXR0b24+PG9wdGlvbj4uPC9vcHRpb24+Jywg MCwgMTAwKSBpcyAiIgorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENP TVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Zhc3Qv dGV4dC9zdXJyb3VuZGluZy10ZXh0Lmh0bWwgYi9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1 bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmRkM2QwOWVjMjNh YjU2NWViMzQ5NzFhMWRiNDg1Yjk1YTdjZTIwNWYKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRU ZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC5odG1sCkBA IC0wLDAgKzEsNTcgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8aGVhZD4KKzxtZXRhIGNo YXJzZXQ9InV0Zi04Ij4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi8uLi9mYXN0L2pzL3Jlc291cmNl cy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxkaXYgaWQ9InRl c3QiPgorPC9kaXY+Cis8cCBpZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUi PjwvZGl2PgorPHNjcmlwdCB0eXBlPSJ0ZXh0L2phdmFzY3JpcHQiPgorZGVzY3JpcHRpb24oJ1Rl c3QgdGhlIGV4dHJhY3Rpb24gb2YgdGhlIHRleHQgc3Vycm91bmRpbmcgYW4gZWxlbWVudC4nKTsK KworZnVuY3Rpb24gc3Vycm91bmRpbmdUZXh0KGh0bWwsIG9mZnNldCwgbWF4TGVuZ3RoKSB7Cisg IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0JykuaW5uZXJIVE1MID0gaHRtbDsKKworICB2 YXIgaGVyZSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdoZXJlJyk7CisgIGlmIChoZXJlID09 IG51bGwpCisgICAgICB0aHJvdyAnVGVzdCBjYXNlIG5lZWRzIGFuIGVsZW1lbnQgd2l0aCBpZCAi aGVyZSInOworCisgIHZhciBub2RlID0gaGVyZS5oYXNDaGlsZE5vZGVzKCkgPyBoZXJlLmZpcnN0 Q2hpbGQgOiBoZXJlLm5leHRTaWJsaW5nOworICBpZiAobm9kZSA9PSBudWxsKQorICAgICAgdGhy b3cgJ05vIG5vZGUgYWZ0ZXIgImhlcmUiIGVsZW1lbnQnOworCisgIHZhciB0ZXh0ID0gd2luZG93 LnRlc3RSdW5uZXIudGV4dFN1cnJvdW5kaW5nRWxlbWVudChub2RlLCBvZmZzZXQsIG1heExlbmd0 aCk7CisgIHJldHVybiB0ZXh0LnJlcGxhY2UoL1xzKy9nLCAnICcpLnJlcGxhY2UoL15ccyp8XHMq JC9nLCAnJyk7Cit9CisKK2Z1bmN0aW9uIHJ1bigpIHsKKyAgICBpZiAoIXdpbmRvdy50ZXN0UnVu bmVyKQorICAgICAgICByZXR1cm47CisKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJv dW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIz NDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPlwnLCAwLCAxMDApJywgJzEyMzQ1IDY3ODkgMTIz NDUgNjc4OScpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwn PGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1 dHRvbj4uPC9idXR0b24+XCcsIDUsIDYpJywgJzg5IDEyMycpOworICAgIHNob3VsZEJlRXF1YWxU b1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0i aGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDUsIDApJywgJycp OworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4u PC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9i dXR0b24+XCcsIDUsIDEpJywgJzEnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJv dW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIz NDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPlwnLCA2LCAyKScsICcxMicpOworICAgIHNob3Vs ZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIz NDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDEw MCwgNSknLCAnJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQo XCc8c2VsZWN0Pi48L3NlbGVjdD48ZGl2PjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3JlIERyaXZl PC9kaXY+IDxzcGFuPkNoaWNhZ288L3NwYW4+IDxzcGFuIGlkPSJoZXJlIj5JTDwvc3Bhbj4gPHNw YW4+NjA2Mzc8L3NwYW4+PHNlbGVjdD4uPC9zZWxlY3Q+XCcsIDAsIDEwMCknLCAnNTd0aCBTdHJl ZXQgYW5kIExha2UgU2hvcmUgRHJpdmUgQ2hpY2FnbyBJTCA2MDYzNycpOworICAgIHNob3VsZEJl RXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PjEy MzQ1PGJ1dHRvbj5hYmM8L2J1dHRvbj48cD42Nzg5PGJyIGlkPSJoZXJlIi8+MTIzNDU8L3A+Njc4 OTx0ZXh0YXJlYT5hYmM8L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+XCcsIDAs IDEwMCknLCAnNjc4OSAxMjM0NSA2Nzg5Jyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdz dXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj5UaGlzIGlz IDwhLS0gY29tbWVudCAtLSE+YSB0ZXN0IDxcJyArIFwnc2NyaXB0IGxhbmd1YWdlPSJqYXZhc2Ny aXB0Ij48XCcgKyBcJy9zY3JpcHQ+ZXhhbXBsZTxidXR0b24+LjwvYnV0dG9uPlwnLCAwLCAxMDAp JywgJ1RoaXMgaXMgYSB0ZXN0IGV4YW1wbGUnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmco J3N1cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPjAxMjM0 NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTwvZGl2PjxidXR0b24+LjwvYnV0dG9uPlwnLCAxNSwg MTIpJywgJzkwMTIzNDU2Nzg5MCcpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91 bmRpbmdUZXh0KFwnPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uIGlkPSJoZXJlIj50ZXN0 PC9idXR0b24+PG9wdGlvbj4uPC9vcHRpb24+XCcsIDAsIDEwMCknLCAnJyk7CisgICAgc2hvdWxk QmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8b3B0aW9uPi48L29wdGlvbj4xMjM0 NTxidXR0b24+dGU8c3BhbiBpZD0iaGVyZSI+c3Q8L3NwYW4+PC9idXR0b24+PG9wdGlvbj4uPC9v cHRpb24+XCcsIDAsIDEwMCknLCAnJyk7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxk KGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0JykpOworICAgIGZpbmlzaEpTVGVzdCgpOwor fQorCit3aW5kb3cub25sb2FkID0gcnVuOword2luZG93LmpzVGVzdElzQXN5bmMgPSB0cnVlOwor d2luZG93LnN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3Jj PSIuLi8uLi8uLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0 PgorPC9ib2R5PgorPC9odG1sPgo= 150441 2012-07-02 10:15:34 -0700 2012-07-02 10:22:42 -0700 Patch for landing bug-82461-20120702101533.patch text/plain 14597 abarth SW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiAxMjE2ODkpCisrKyBTb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE5 IEBACisyMDEyLTA3LTAyICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9t aXVtLm9yZz4KKworICAgICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZv ciBlZGl0aW5nL1N1cnJvdW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9ODI0NjEKKworICAgICAgICBBbGxvdyBwYXNzaW5nIG5vZGVzIGFz IGFyZ3VtZW50cyBmb3IgbGF5b3V0IHRlc3QgbWV0aG9kcy4KKworICAgICAgICBSZXZpZXdlZCBi eSBBZGFtIEJhcnRoLgorCisgICAgICAgICogcHVibGljL1dlYkJpbmRpbmdzLmg6CisgICAgICAg IChXZWJCaW5kaW5ncyk6CisgICAgICAgICogc3JjL1dlYkJpbmRpbmdzLmNwcDoKKyAgICAgICAg KFdlYktpdDo6Z2V0Tm9kZUltcGwpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYktp dDo6V2ViQmluZGluZ3M6OmdldE5vZGUpOgorCiAyMDEyLTA3LTAxICBLZWlzaGkgSGF0dG9yaSAg PGtlaXNoaUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIx MjE2NTAuCkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJCaW5kaW5ncy5o Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkJpbmRpbmdz LmgJKHJldmlzaW9uIDEyMTY4OSkKKysrIFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YkJpbmRpbmdzLmgJKHdvcmtpbmcgY29weSkKQEAgLTE1Miw2ICsxNTIsMTAgQEAgcHVibGljOgog ICAgIC8vIElmIHNvLCByZXR1cm4gaXQgYXMgYSBXZWJBcnJheUJ1ZmZlclZpZXcgb2JqZWN0Lgog ICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0QXJyYXlCdWZmZXJWaWV3KE5QT2JqZWN0 KiBhcnJheUJ1ZmZlclZpZXcsIFdlYkFycmF5QnVmZmVyVmlldyopOwogCisgICAgLy8gUmV0dXJu IHRydWUgKHN1Y2Nlc3MpIGlmIHRoZSBnaXZlbiBucG9iaiBpcyBhIG5vZGUuCisgICAgLy8gSWYg c28sIHJldHVybiB0aGF0IGVsZW1lbnQgYXMgYSBXZWJOb2RlIG9iamVjdC4KKyAgICBXRUJLSVRf RVhQT1JUIHN0YXRpYyBib29sIGdldE5vZGUoTlBPYmplY3QqIGVsZW1lbnQsIFdlYk5vZGUqKTsK KwogICAgIC8vIFJldHVybiB0cnVlIChzdWNjZXNzKSBpZiB0aGUgZ2l2ZW4gbnBvYmogaXMgYW4g ZWxlbWVudC4KICAgICAvLyBJZiBzbywgcmV0dXJuIHRoYXQgZWxlbWVudCBhcyBhIFdlYkVsZW1l bnQgb2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0RWxlbWVudChOUE9i amVjdCogZWxlbWVudCwgV2ViRWxlbWVudCopOwpJbmRleDogU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViQmluZGluZ3MuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL1dlYkJpbmRpbmdzLmNwcAkocmV2aXNpb24gMTIxNjg5KQorKysgU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViQmluZGluZ3MuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMjMsNiAr MjIzLDIxIEBAIHN0YXRpYyBib29sIGdldFJhbmdlSW1wbChOUE9iamVjdCogb2JqZWMKICAgICBy ZXR1cm4gdHJ1ZTsKIH0KIAorc3RhdGljIGJvb2wgZ2V0Tm9kZUltcGwoTlBPYmplY3QqIG9iamVj dCwgV2ViTm9kZSogd2ViTm9kZSkKK3sKKyAgICBpZiAoIW9iamVjdCB8fCAob2JqZWN0LT5fY2xh c3MgIT0gbnBTY3JpcHRPYmplY3RDbGFzcykpCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAg IFY4TlBPYmplY3QqIHY4TlBPYmplY3QgPSByZWludGVycHJldF9jYXN0PFY4TlBPYmplY3QqPihv YmplY3QpOworICAgIHY4OjpIYW5kbGU8djg6Ok9iamVjdD4gdjhPYmplY3QodjhOUE9iamVjdC0+ djhPYmplY3QpOworICAgIE5vZGUqIG5hdGl2ZSA9IFY4Tm9kZTo6SGFzSW5zdGFuY2UodjhPYmpl Y3QpID8gVjhOb2RlOjp0b05hdGl2ZSh2OE9iamVjdCkgOiAwOworICAgIGlmICghbmF0aXZlKQor ICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAqd2ViTm9kZSA9IFdlYk5vZGUobmF0aXZlKTsK KyAgICByZXR1cm4gdHJ1ZTsKK30KKwogc3RhdGljIGJvb2wgZ2V0RWxlbWVudEltcGwoTlBPYmpl Y3QqIG9iamVjdCwgV2ViRWxlbWVudCogd2ViRWxlbWVudCkKIHsKICAgICBpZiAoIW9iamVjdCB8 fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmplY3RDbGFzcykpCkBAIC0zMjgsNiArMzQz LDE2IEBAIGJvb2wgV2ViQmluZGluZ3M6OmdldEFycmF5QnVmZmVyVmlldyhOUE8KICNlbmRpZgog fQogCitib29sIFdlYkJpbmRpbmdzOjpnZXROb2RlKE5QT2JqZWN0KiBub2RlLCBXZWJOb2RlKiB3 ZWJOb2RlKQoreworI2lmIFVTRShWOCkKKyAgICByZXR1cm4gZ2V0Tm9kZUltcGwobm9kZSwgd2Vi Tm9kZSk7CisjZWxzZQorICAgIC8vIE5vdCBzdXBwb3J0ZWQgb24gb3RoZXIgcG9ydHMgKEpTQywg ZXRjLikuCisgICAgcmV0dXJuIGZhbHNlOworI2VuZGlmCit9CisKIGJvb2wgV2ViQmluZGluZ3M6 OmdldEVsZW1lbnQoTlBPYmplY3QqIGVsZW1lbnQsIFdlYkVsZW1lbnQqIHdlYkVsZW1lbnQpCiB7 CiAjaWYgVVNFKFY4KQpJbmRleDogVG9vbHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xz L0NoYW5nZUxvZwkocmV2aXNpb24gMTIxNjg5KQorKysgVG9vbHMvQ2hhbmdlTG9nCSh3b3JraW5n IGNvcHkpCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTItMDctMDIgIExlYW5kcm8gR3JhY2lhIEdpbCAg PGxlYW5kcm9ncmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVt ZW50IGEgTGF5b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAgIEFk ZCBhIG5ldyBtZXRob2QgdG8gdGhlIGxheW91dCB0ZXN0IGNvbnRyb2xsZXIgaW4gb3JkZXIgdG8g cmV0cmlldmUgdGhlCisgICAgICAgIHRleHQgc3Vycm91bmRpbmcgYSBwcm92aWRlZCBlbGVtZW50 LgorCisgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gQmFydGguCisKKyAgICAgICAgKiBEdW1wUmVu ZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHA6CisgICAgICAgIChMYXlv dXRUZXN0Q29udHJvbGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsZXIpOgorICAgICAgICAoTGF5b3V0 VGVzdENvbnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQpOgorICAgICAgICAqIER1bXBS ZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmg6CisgICAgICAgIChMYXlv dXRUZXN0Q29udHJvbGxlcik6CisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2Vi Vmlld0hvc3QuY3BwOgorICAgICAgICAoV2ViVmlld0hvc3Q6OnRleHRTdXJyb3VuZGluZ0VsZW1l bnQpOgorICAgICAgICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0Lmg6Cisg ICAgICAgIChXZWJWaWV3SG9zdCk6CisKIDIwMTItMDctMDIgIENhcmxvcyBHYXJjaWEgQ2FtcG9z ICA8Y2dhcmNpYUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIFJlYWQgZm9udHMgcGF0aCB3 aGVuIHJ1bm5pbmcgbGF5b3V0IHRlc3RzIGZyb20gYWx0ZXJuYXRpdmUgZm9udHMgZGlyIHdoZW4g bWFpbiBkaXIgZG9lc24ndCBleGlzdApJbmRleDogVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21p dW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL0R1bXBSZW5k ZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAkocmV2aXNpb24gMTIxNjg5 KQorKysgVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yNzUsNyArMjc1LDggQEAgTGF5b3V0VGVzdENvbnRyb2xs ZXI6OkxheW91dFRlc3RDb250cm9sbAogICAgIGJpbmRNZXRob2QoInNldEZpeGVkTGF5b3V0U2l6 ZSIsICZMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0Rml4ZWRMYXlvdXRTaXplKTsKICAgICBiaW5k TWV0aG9kKCJzZWxlY3Rpb25Bc01hcmt1cCIsICZMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2VsZWN0 aW9uQXNNYXJrdXApOwogICAgIGJpbmRNZXRob2QoInNldEhhc0N1c3RvbUZ1bGxTY3JlZW5CZWhh dmlvciIsICZMYXlvdXRUZXN0Q29udHJvbGxlcjo6c2V0SGFzQ3VzdG9tRnVsbFNjcmVlbkJlaGF2 aW9yKTsKLSAgICAKKyAgICBiaW5kTWV0aG9kKCJ0ZXh0U3Vycm91bmRpbmdFbGVtZW50IiwgJkxh eW91dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KTsKKwogICAgIC8vIFRo ZSBmYWxsYmFjayBtZXRob2QgaXMgY2FsbGVkIHdoZW4gYW4gdW5rbm93biBtZXRob2QgaXMgaW52 b2tlZC4KICAgICBiaW5kRmFsbGJhY2tNZXRob2QoJkxheW91dFRlc3RDb250cm9sbGVyOjpmYWxs YmFja01ldGhvZCk7CiAKQEAgLTIzNDMsMyArMjM0NCwxNyBAQCB2b2lkIExheW91dFRlc3RDb250 cm9sbGVyOjpzZXRQb2ludGVyTG9jCiAgICAgcmVzdWx0LT5zZXROdWxsKCk7CiB9CiAjZW5kaWYK Kwordm9pZCBMYXlvdXRUZXN0Q29udHJvbGxlcjo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudChjb25z dCBDcHBBcmd1bWVudExpc3QmIGFyZ3VtZW50cywgQ3BwVmFyaWFudCogcmVzdWx0KQoreworICAg IHJlc3VsdC0+c2V0TnVsbCgpOworICAgIGlmIChhcmd1bWVudHMuc2l6ZSgpIDwgMyB8fCAhYXJn dW1lbnRzWzBdLmlzT2JqZWN0KCkgfHwgIWFyZ3VtZW50c1sxXS5pc051bWJlcigpIHx8ICFhcmd1 bWVudHNbMl0uaXNOdW1iZXIoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgV2ViTm9kZSBub2Rl OworICAgIGlmICghV2ViQmluZGluZ3M6OmdldE5vZGUoYXJndW1lbnRzWzBdLnZhbHVlLm9iamVj dFZhbHVlLCAmbm9kZSkpCisgICAgICAgIHJldHVybjsKKworICAgIFdlYlN0cmluZyBjb250ZW50 ID0gbV9zaGVsbC0+d2ViVmlld0hvc3QoKS0+dGV4dFN1cnJvdW5kaW5nRWxlbWVudChub2RlLCBh cmd1bWVudHNbMV0udG9JbnQzMigpLCBhcmd1bWVudHNbMl0udG9JbnQzMigpKTsKKyAgICByZXN1 bHQtPnNldChjb250ZW50LnV0ZjgoKSk7Cit9CkluZGV4OiBUb29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL0R1bXBS ZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmgJKHJldmlzaW9uIDEyMTY4 OSkKKysrIFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVy LmgJKHdvcmtpbmcgY29weSkKQEAgLTQ1Niw2ICs0NTYsMTEgQEAgcHVibGljOgogICAgIC8vIFVz ZWQgdG8gc2V0IHRoZSBkZXZpY2Ugc2NhbGUgZmFjdG9yLgogICAgIHZvaWQgc2V0QmFja2luZ1Nj YWxlRmFjdG9yKGNvbnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsKIAorICAgIC8v IFJldHJpZXZlcyB0aGUgdGV4dCBzdXJyb3VuZGluZyBhIHBvc2l0aW9uIGluIGEgdGV4dCBub2Rl LgorICAgIC8vIFRoZSBmaXJzdCBjaGlsZCBvZiB0aGUgZWxlbWVudCBnaXZlbiB5IGl0cyBpZCB3 aWxsIGJlIHVzZWQgYXMgcmVmZXJlbmNlLAorICAgIC8vIG9yIGl0cyBuZXh0IHNpYmxpbmcgaWYg bm90IHByZXNlbnQuIEl0IG11c3QgYmUgYSB0ZXh0IG5vZGUuCisgICAgdm9pZCB0ZXh0U3Vycm91 bmRpbmdFbGVtZW50KGNvbnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsKKwogcHVi bGljOgogICAgIC8vIFRoZSBmb2xsb3dpbmcgbWV0aG9kcyBhcmUgbm90IGV4cG9zZWQgdG8gSmF2 YVNjcmlwdC4KICAgICB2b2lkIHNldFdvcmtRdWV1ZUZyb3plbihib29sIGZyb3plbikgeyBtX3dv cmtRdWV1ZS5zZXRGcm96ZW4oZnJvemVuKTsgfQpJbmRleDogVG9vbHMvRHVtcFJlbmRlclRyZWUv Y2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xzL0R1bXBSZW5kZXJU cmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAkocmV2aXNpb24gMTIxNjg5KQorKysgVG9vbHMv RHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hvc3QuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC02NCw2ICs2NCw3IEBACiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViU2VyaWFsaXplZFNjcmlwdFZh bHVlLmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViU2l6ZS5oIgogI2luY2x1ZGUgIldlYlN0b3Jh Z2VOYW1lc3BhY2UuaCIKKyNpbmNsdWRlICJXZWJTdXJyb3VuZGluZ1RleHQuaCIKICNpbmNsdWRl ICJXZWJUZXh0Q2hlY2tpbmdDb21wbGV0aW9uLmgiCiAjaW5jbHVkZSAiV2ViVGV4dENoZWNraW5n UmVzdWx0LmgiCiAjaW5jbHVkZSAiV2ViVXNlck1lZGlhQ2xpZW50TW9jay5oIgpAQCAtOTAxLDYg KzkwMiwxNiBAQCB2b2lkIFdlYlZpZXdIb3N0OjpkaWRMb3NlUG9pbnRlckxvY2soKQogfQogI2Vu ZGlmCiAKK1dlYktpdDo6V2ViU3RyaW5nIFdlYlZpZXdIb3N0Ojp0ZXh0U3Vycm91bmRpbmdFbGVt ZW50KGNvbnN0IFdlYktpdDo6V2ViTm9kZSYgbm9kZSwgdW5zaWduZWQgb2Zmc2V0LCB1bnNpZ25l ZCBtYXhMZW5ndGgpCit7CisgICAgaWYgKG5vZGUuaXNOdWxsKCkgfHwgIW5vZGUuaXNUZXh0Tm9k ZSgpIHx8IG9mZnNldCA+PSBub2RlLm5vZGVWYWx1ZSgpLmxlbmd0aCgpKQorICAgICAgICByZXR1 cm4gV2ViU3RyaW5nKCk7CisKKyAgICBXZWJTdXJyb3VuZGluZ1RleHQgc3Vycm91bmRpbmdUZXh0 OworICAgIHN1cnJvdW5kaW5nVGV4dC5pbml0aWFsaXplKG5vZGUsIG9mZnNldCwgbWF4TGVuZ3Ro KTsKKyAgICByZXR1cm4gc3Vycm91bmRpbmdUZXh0LnRleHRDb250ZW50KCk7Cit9CisKIHZvaWQg V2ViVmlld0hvc3Q6OnNob3coV2ViTmF2aWdhdGlvblBvbGljeSkKIHsKICAgICBtX2hhc1dpbmRv dyA9IHRydWU7CkluZGV4OiBUb29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9z dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KLS0tIFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdI b3N0LmgJKHJldmlzaW9uIDEyMTY4OSkKKysrIFRvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVt L1dlYlZpZXdIb3N0LmgJKHdvcmtpbmcgY29weSkKQEAgLTEyOCw2ICsxMjgsOCBAQCBjbGFzcyBX ZWJWaWV3SG9zdCA6IHB1YmxpYyBXZWJLaXQ6OldlYlZpCiAgICAgdm9pZCBzZXRQb2ludGVyTG9j a1dpbGxGYWlsU3luY2hyb25vdXNseSgpIHsgbV9wb2ludGVyTG9ja1BsYW5uZWRSZXN1bHQgPSBQ b2ludGVyTG9ja1dpbGxGYWlsU3luYzsgfQogI2VuZGlmCiAKKyAgICBXZWJLaXQ6OldlYlN0cmlu ZyB0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNvbnN0IFdlYktpdDo6V2ViTm9kZSYsIHVuc2lnbmVk IG9mZnNldCwgdW5zaWduZWQgbWF4TGVuZ3RoKTsKKwogICAgIC8vIE5hdmlnYXRpb25Ib3N0CiAg ICAgdmlydHVhbCBib29sIG5hdmlnYXRlKGNvbnN0IFRlc3ROYXZpZ2F0aW9uRW50cnkmLCBib29s IHJlbG9hZCk7CiAKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDEyMTY4OSkKKysrIExheW91dFRlc3RzL0No YW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDEyLTA3LTAyICBMZWFu ZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9taXVtLm9yZz4KKworICAgICAgICBb Q2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZvciBlZGl0aW5nL1N1cnJvdW5kaW5n VGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODI0 NjEKKworICAgICAgICBBZGQgYSBuZXcgbGF5b3V0IHRlc3QgZm9yIHRoZSBzdXJyb3VuZGluZyB0 ZXh0IGZlYXR1cmUuCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KKworICAgICAg ICAqIHBsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4cGVjdGVk LnR4dDogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJv dW5kaW5nLXRleHQuaHRtbDogQWRkZWQuCisKIDIwMTItMDctMDIgIEVtaWwgQSBFa2x1bmQgIDxl YWVAY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgY2hyb21pdW0gZXhwZWN0YXRp b25zIHVwZGF0ZS4KSW5kZXg6IExheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4 dC9zdXJyb3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50 eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3Rl eHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs MjEgQEAKK1Rlc3QgdGhlIGV4dHJhY3Rpb24gb2YgdGhlIHRleHQgc3Vycm91bmRpbmcgYW4gZWxl bWVudC4KKworT24gc3VjY2VzcywgeW91IHdpbGwgc2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNz YWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExFVEUiLgorCisKK1BBU1Mgc3Vycm91bmRpbmdU ZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3 ODk8YnV0dG9uPi48L2J1dHRvbj4nLCAwLCAxMDApIGlzICIxMjM0NSA2Nzg5IDEyMzQ1IDY3ODki CitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVy ZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgNSwgNikgaXMgIjg5IDEy MyIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJo ZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA1LCAwKSBpcyAiIgor UEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUi PjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDUsIDEpIGlzICIxIgorUEFT UyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3 ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDYsIDIpIGlzICIxMiIKK1BBU1Mg c3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5 IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCAxMDAsIDUpIGlzICIiCitQQVNTIHN1 cnJvdW5kaW5nVGV4dCgnPHNlbGVjdD4uPC9zZWxlY3Q+PGRpdj41N3RoIFN0cmVldCBhbmQgTGFr ZSBTaG9yZSBEcml2ZTwvZGl2PiA8c3Bhbj5DaGljYWdvPC9zcGFuPiA8c3BhbiBpZD0iaGVyZSI+ SUw8L3NwYW4+IDxzcGFuPjYwNjM3PC9zcGFuPjxzZWxlY3Q+Ljwvc2VsZWN0PicsIDAsIDEwMCkg aXMgIjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3JlIERyaXZlIENoaWNhZ28gSUwgNjA2MzciCitQ QVNTIHN1cnJvdW5kaW5nVGV4dCgnPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PjEyMzQ1PGJ1dHRvbj5h YmM8L2J1dHRvbj48cD42Nzg5PGJyIGlkPSJoZXJlIi8+MTIzNDU8L3A+Njc4OTx0ZXh0YXJlYT5h YmM8L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+JywgMCwgMTAwKSBpcyAiNjc4 OSAxMjM0NSA2Nzg5IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjxk aXYgaWQ9ImhlcmUiPlRoaXMgaXMgPCEtLSBjb21tZW50IC0tIT5hIHRlc3QgPCcgKyAnc2NyaXB0 IGxhbmd1YWdlPSJqYXZhc2NyaXB0Ij48JyArICcvc2NyaXB0PmV4YW1wbGU8YnV0dG9uPi48L2J1 dHRvbj4nLCAwLCAxMDApIGlzICJUaGlzIGlzIGEgdGVzdCBleGFtcGxlIgorUEFTUyBzdXJyb3Vu ZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPjAxMjM0NTY3ODkwMTIz NDU2Nzg5MDEyMzQ1Njc4OTwvZGl2PjxidXR0b24+LjwvYnV0dG9uPicsIDE1LCAxMikgaXMgIjkw MTIzNDU2Nzg5MCIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8b3B0aW9uPi48L29wdGlvbj4xMjM0 NTxidXR0b24gaWQ9ImhlcmUiPnRlc3Q8L2J1dHRvbj48b3B0aW9uPi48L29wdGlvbj4nLCAwLCAx MDApIGlzICIiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8 YnV0dG9uPnRlPHNwYW4gaWQ9ImhlcmUiPnN0PC9zcGFuPjwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0 aW9uPicsIDAsIDEwMCkgaXMgIiIKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKwor VEVTVCBDT01QTEVURQorCkluZGV4OiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0 L3RleHQvc3Vycm91bmRpbmctdGV4dC5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3Bs YXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0Lmh0bWwJKHJldmlzaW9u IDApCisrKyBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRp bmctdGV4dC5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDU3IEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+Cis8c2NyaXB0IHNyYz0i Li4vLi4vLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0Pgor PC9oZWFkPgorPGJvZHk+Cis8ZGl2IGlkPSJ0ZXN0Ij4KKzwvZGl2PgorPHAgaWQ9ImRlc2NyaXB0 aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0idGV4dC9q YXZhc2NyaXB0Ij4KK2Rlc2NyaXB0aW9uKCdUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRoZSB0ZXh0 IHN1cnJvdW5kaW5nIGFuIGVsZW1lbnQuJyk7CisKK2Z1bmN0aW9uIHN1cnJvdW5kaW5nVGV4dCho dG1sLCBvZmZzZXQsIG1heExlbmd0aCkgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0 ZXN0JykuaW5uZXJIVE1MID0gaHRtbDsKKworICAgIHZhciBoZXJlID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoJ2hlcmUnKTsKKyAgICBpZiAoaGVyZSA9PSBudWxsKQorICAgICAgdGhyb3cgJ1Rl c3QgY2FzZSBuZWVkcyBhbiBlbGVtZW50IHdpdGggaWQgImhlcmUiJzsKKworICAgIHZhciBub2Rl ID0gaGVyZS5oYXNDaGlsZE5vZGVzKCkgPyBoZXJlLmZpcnN0Q2hpbGQgOiBoZXJlLm5leHRTaWJs aW5nOworICAgIGlmIChub2RlID09IG51bGwpCisgICAgICB0aHJvdyAnTm8gbm9kZSBhZnRlciAi aGVyZSIgZWxlbWVudCc7CisKKyAgICB2YXIgdGV4dCA9IHdpbmRvdy50ZXN0UnVubmVyLnRleHRT dXJyb3VuZGluZ0VsZW1lbnQobm9kZSwgb2Zmc2V0LCBtYXhMZW5ndGgpOworICAgIHJldHVybiB0 ZXh0LnJlcGxhY2UoL1xzKy9nLCAnICcpLnJlcGxhY2UoL15ccyp8XHMqJC9nLCAnJyk7Cit9CisK K2Z1bmN0aW9uIHJ1bigpIHsKKyAgICBpZiAoIXdpbmRvdy50ZXN0UnVubmVyKQorICAgICAgICBy ZXR1cm47CisKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxi dXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0 b24+LjwvYnV0dG9uPlwnLCAwLCAxMDApJywgJzEyMzQ1IDY3ODkgMTIzNDUgNjc4OScpOworICAg IHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0 b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+ XCcsIDUsIDYpJywgJzg5IDEyMycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91 bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0 NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDUsIDApJywgJycpOworICAgIHNob3VsZEJl RXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8 cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDUsIDEp JywgJzEnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxi dXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0 b24+LjwvYnV0dG9uPlwnLCA2LCAyKScsICcxMicpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmlu Zygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+ Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+XCcsIDEwMCwgNSknLCAnJyk7Cisg ICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8c2VsZWN0Pi48L3Nl bGVjdD48ZGl2PjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3JlIERyaXZlPC9kaXY+IDxzcGFuPkNo aWNhZ288L3NwYW4+IDxzcGFuIGlkPSJoZXJlIj5JTDwvc3Bhbj4gPHNwYW4+NjA2Mzc8L3NwYW4+ PHNlbGVjdD4uPC9zZWxlY3Q+XCcsIDAsIDEwMCknLCAnNTd0aCBTdHJlZXQgYW5kIExha2UgU2hv cmUgRHJpdmUgQ2hpY2FnbyBJTCA2MDYzNycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygn c3Vycm91bmRpbmdUZXh0KFwnPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PjEyMzQ1PGJ1dHRvbj5hYmM8 L2J1dHRvbj48cD42Nzg5PGJyIGlkPSJoZXJlIi8+MTIzNDU8L3A+Njc4OTx0ZXh0YXJlYT5hYmM8 L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+XCcsIDAsIDEwMCknLCAnNjc4OSAx MjM0NSA2Nzg5Jyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQo XCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj5UaGlzIGlzIDwhLS0gY29tbWVudCAt LSE+YSB0ZXN0IDxcJyArIFwnc2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0Ij48XCcgKyBcJy9z Y3JpcHQ+ZXhhbXBsZTxidXR0b24+LjwvYnV0dG9uPlwnLCAwLCAxMDApJywgJ1RoaXMgaXMgYSB0 ZXN0IGV4YW1wbGUnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4 dChcJzxidXR0b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPjAxMjM0NTY3ODkwMTIzNDU2Nzg5 MDEyMzQ1Njc4OTwvZGl2PjxidXR0b24+LjwvYnV0dG9uPlwnLCAxNSwgMTIpJywgJzkwMTIzNDU2 Nzg5MCcpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPG9w dGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uIGlkPSJoZXJlIj50ZXN0PC9idXR0b24+PG9wdGlv bj4uPC9vcHRpb24+XCcsIDAsIDEwMCknLCAnJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5n KCdzdXJyb3VuZGluZ1RleHQoXCc8b3B0aW9uPi48L29wdGlvbj4xMjM0NTxidXR0b24+dGU8c3Bh biBpZD0iaGVyZSI+c3Q8L3NwYW4+PC9idXR0b24+PG9wdGlvbj4uPC9vcHRpb24+XCcsIDAsIDEw MCknLCAnJyk7CisKKyAgICBkb2N1bWVudC5ib2R5LnJlbW92ZUNoaWxkKGRvY3VtZW50LmdldEVs ZW1lbnRCeUlkKCd0ZXN0JykpOworICAgIGZpbmlzaEpTVGVzdCgpOworfQorCit3aW5kb3cub25s b2FkID0gcnVuOword2luZG93LmpzVGVzdElzQXN5bmMgPSB0cnVlOword2luZG93LnN1Y2Nlc3Nm dWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi8uLi8uLi9m YXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9o dG1sPgo= 150444 2012-07-02 10:22:07 -0700 2012-07-02 11:16:24 -0700 Patch bug-82461-20120702182205.patch text/plain 15291 leandrogracia U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxNjg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGJiZjhmN2I3NGYzZDgwZTBiNjc5NDBlOTg2YTU3N2I5MTRmMWM1MTguLjYyZDE5YWY0OWIzYjY5 YjI4N2Q0NGVjN2JlODY1NDhlM2Y1YjBkMTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTkgQEAKKzIwMTItMDYtMjYgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9n cmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5 b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAgIEFsbG93IHBhc3Np bmcgbm9kZXMgYXMgYXJndW1lbnRzIGZvciBsYXlvdXQgdGVzdCBtZXRob2RzLgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL1dlYkJpbmRp bmdzLmg6CisgICAgICAgIChXZWJCaW5kaW5ncyk6CisgICAgICAgICogc3JjL1dlYkJpbmRpbmdz LmNwcDoKKyAgICAgICAgKFdlYktpdDo6Z2V0Tm9kZUltcGwpOgorICAgICAgICAoV2ViS2l0KToK KyAgICAgICAgKFdlYktpdDo6V2ViQmluZGluZ3M6OmdldE5vZGUpOgorCiAyMDEyLTA3LTAxICBL ZWlzaGkgSGF0dG9yaSAgPGtlaXNoaUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQs IHJvbGxpbmcgb3V0IHIxMjE2NTAuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJCaW5kaW5ncy5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi QmluZGluZ3MuaAppbmRleCAzNGEzMjA1NTdkMTNiZTg5NjQ1MTQ4OTZiOGNiNDk4NDA3YmM0OGM0 Li5kYzdiNDVmMzJhNWZlNDI2NDhjNTZlMmRiNWRlNmI0ZjY3NDBkMDE1IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJCaW5kaW5ncy5oCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkJpbmRpbmdzLmgKQEAgLTE1Miw2ICsxNTIsMTAgQEAg cHVibGljOgogICAgIC8vIElmIHNvLCByZXR1cm4gaXQgYXMgYSBXZWJBcnJheUJ1ZmZlclZpZXcg b2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0QXJyYXlCdWZmZXJWaWV3 KE5QT2JqZWN0KiBhcnJheUJ1ZmZlclZpZXcsIFdlYkFycmF5QnVmZmVyVmlldyopOwogCisgICAg Ly8gUmV0dXJuIHRydWUgKHN1Y2Nlc3MpIGlmIHRoZSBnaXZlbiBucG9iaiBpcyBhIG5vZGUuCisg ICAgLy8gSWYgc28sIHJldHVybiB0aGF0IG5vZGUgYXMgYSBXZWJOb2RlIG9iamVjdC4KKyAgICBX RUJLSVRfRVhQT1JUIHN0YXRpYyBib29sIGdldE5vZGUoTlBPYmplY3QqIGVsZW1lbnQsIFdlYk5v ZGUqKTsKKwogICAgIC8vIFJldHVybiB0cnVlIChzdWNjZXNzKSBpZiB0aGUgZ2l2ZW4gbnBvYmog aXMgYW4gZWxlbWVudC4KICAgICAvLyBJZiBzbywgcmV0dXJuIHRoYXQgZWxlbWVudCBhcyBhIFdl YkVsZW1lbnQgb2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0RWxlbWVu dChOUE9iamVjdCogZWxlbWVudCwgV2ViRWxlbWVudCopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViQmluZGluZ3MuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViQmluZGluZ3MuY3BwCmluZGV4IDIzMmI1YjQ2OTRiZWM0OGYyZmIxNzBiYTI3OWY2 MmI2YjE3MTJiMTMuLmI5YmJkNWQzNzY3MmZkZmUxMzRhZDgyYTkxYzc1YWRlNjQzNDEzMGYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkJpbmRpbmdzLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJCaW5kaW5ncy5jcHAKQEAgLTIyMyw2ICsy MjMsMjEgQEAgc3RhdGljIGJvb2wgZ2V0UmFuZ2VJbXBsKE5QT2JqZWN0KiBvYmplY3QsIFdlYlJh bmdlKiB3ZWJSYW5nZSkKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorc3RhdGljIGJvb2wgZ2V0Tm9k ZUltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViTm9kZSogd2ViTm9kZSkKK3sKKyAgICBpZiAoIW9i amVjdCB8fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmplY3RDbGFzcykpCisgICAgICAg IHJldHVybiBmYWxzZTsKKworICAgIFY4TlBPYmplY3QqIHY4TlBPYmplY3QgPSByZWludGVycHJl dF9jYXN0PFY4TlBPYmplY3QqPihvYmplY3QpOworICAgIHY4OjpIYW5kbGU8djg6Ok9iamVjdD4g djhPYmplY3QodjhOUE9iamVjdC0+djhPYmplY3QpOworICAgIE5vZGUqIG5hdGl2ZSA9IFY4Tm9k ZTo6SGFzSW5zdGFuY2UodjhPYmplY3QpID8gVjhOb2RlOjp0b05hdGl2ZSh2OE9iamVjdCkgOiAw OworICAgIGlmICghbmF0aXZlKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAqd2ViTm9k ZSA9IFdlYk5vZGUobmF0aXZlKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogc3RhdGljIGJvb2wg Z2V0RWxlbWVudEltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViRWxlbWVudCogd2ViRWxlbWVudCkK IHsKICAgICBpZiAoIW9iamVjdCB8fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmplY3RD bGFzcykpCkBAIC0zMjgsNiArMzQzLDE2IEBAIGJvb2wgV2ViQmluZGluZ3M6OmdldEFycmF5QnVm ZmVyVmlldyhOUE9iamVjdCogYXJyYXlCdWZmZXJWaWV3LCBXZWJBcnJheUJ1ZmZlclZpCiAjZW5k aWYKIH0KIAorYm9vbCBXZWJCaW5kaW5nczo6Z2V0Tm9kZShOUE9iamVjdCogbm9kZSwgV2ViTm9k ZSogd2ViTm9kZSkKK3sKKyNpZiBVU0UoVjgpCisgICAgcmV0dXJuIGdldE5vZGVJbXBsKG5vZGUs IHdlYk5vZGUpOworI2Vsc2UKKyAgICAvLyBOb3Qgc3VwcG9ydGVkIG9uIG90aGVyIHBvcnRzIChK U0MsIGV0Yy4pLgorICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorfQorCiBib29sIFdlYkJpbmRp bmdzOjpnZXRFbGVtZW50KE5QT2JqZWN0KiBlbGVtZW50LCBXZWJFbGVtZW50KiB3ZWJFbGVtZW50 KQogewogI2lmIFVTRShWOCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0No YW5nZUxvZwppbmRleCBjMGMwYmRhNzc4NWQ2ODFiN2E2ZDhlMTgwODRiZWE4ZTMyMzFhNWU0Li42 ZGQ1ZmFmNWU5YjZmNGIyNjAxZDc4YzQ0NDljNjMzYzA0NDEzM2NmIDEwMDY0NAotLS0gYS9Ub29s cy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjMgQEAKKzIwMTIt MDYtMjYgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9ncmFjaWFAY2hyb21pdW0ub3JnPgor CisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5b3V0IFRlc3QgZm9yIGVkaXRpbmcv U3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD04MjQ2MQorCisgICAgICAgIEFkZCBhIG5ldyBtZXRob2QgdG8gdGhlIGxheW91dCB0 ZXN0IGNvbnRyb2xsZXIgaW4gb3JkZXIgdG8gcmV0cmlldmUgdGhlCisgICAgICAgIHRleHQgc3Vy cm91bmRpbmcgYSBwcm92aWRlZCBlbGVtZW50LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVz dENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRl c3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vycm91 bmRpbmdFbGVtZW50KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXIpOgorICAgICAg ICAqIER1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcDoKKyAgICAgICAgKFdl YlZpZXdIb3N0Ojp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KToKKyAgICAgICAgKiBEdW1wUmVuZGVy VHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oOgorICAgICAgICAoV2ViVmlld0hvc3QpOgorCiAy MDEyLTA3LTAyICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAog ICAgICAgICBbR1RLXSBSZWFkIGZvbnRzIHBhdGggd2hlbiBydW5uaW5nIGxheW91dCB0ZXN0cyBm cm9tIGFsdGVybmF0aXZlIGZvbnRzIGRpciB3aGVuIG1haW4gZGlyIGRvZXNuJ3QgZXhpc3QKZGlm ZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9s bGVyLmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9s bGVyLmNwcAppbmRleCBlZmJmM2ZmNjllZmU0NmVjZTE1ZjYzMDE2MzM0MTkyOWQ4OGUwNjE4Li5i OWQ0Nzg4MzJhNWYzYTY5Y2E0YWU0OWRhM2JlNjMwNjUyYjJhMzU1IDEwMDY0NAotLS0gYS9Ub29s cy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIv VG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBA IC0yNzUsNyArMjc1LDggQEAgTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9s bGVyKFRlc3RTaGVsbCogc2hlbGwpCiAgICAgYmluZE1ldGhvZCgic2V0Rml4ZWRMYXlvdXRTaXpl IiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZXRGaXhlZExheW91dFNpemUpOwogICAgIGJpbmRN ZXRob2QoInNlbGVjdGlvbkFzTWFya3VwIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZWxlY3Rp b25Bc01hcmt1cCk7CiAgICAgYmluZE1ldGhvZCgic2V0SGFzQ3VzdG9tRnVsbFNjcmVlbkJlaGF2 aW9yIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZXRIYXNDdXN0b21GdWxsU2NyZWVuQmVoYXZp b3IpOwotICAgIAorICAgIGJpbmRNZXRob2QoInRleHRTdXJyb3VuZGluZ0VsZW1lbnQiLCAmTGF5 b3V0VGVzdENvbnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQpOworCiAgICAgLy8gVGhl IGZhbGxiYWNrIG1ldGhvZCBpcyBjYWxsZWQgd2hlbiBhbiB1bmtub3duIG1ldGhvZCBpcyBpbnZv a2VkLgogICAgIGJpbmRGYWxsYmFja01ldGhvZCgmTGF5b3V0VGVzdENvbnRyb2xsZXI6OmZhbGxi YWNrTWV0aG9kKTsKIApAQCAtMjM0MywzICsyMzQ0LDE3IEBAIHZvaWQgTGF5b3V0VGVzdENvbnRy b2xsZXI6OnNldFBvaW50ZXJMb2NrV2lsbEZhaWxTeW5jaHJvbm91c2x5KGNvbnN0IENwcEFyZ3Vt ZW50CiAgICAgcmVzdWx0LT5zZXROdWxsKCk7CiB9CiAjZW5kaWYKKwordm9pZCBMYXlvdXRUZXN0 Q29udHJvbGxlcjo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudChjb25zdCBDcHBBcmd1bWVudExpc3Qm IGFyZ3VtZW50cywgQ3BwVmFyaWFudCogcmVzdWx0KQoreworICAgIHJlc3VsdC0+c2V0TnVsbCgp OworICAgIGlmIChhcmd1bWVudHMuc2l6ZSgpIDwgMyB8fCAhYXJndW1lbnRzWzBdLmlzT2JqZWN0 KCkgfHwgIWFyZ3VtZW50c1sxXS5pc051bWJlcigpIHx8ICFhcmd1bWVudHNbMl0uaXNOdW1iZXIo KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgV2ViTm9kZSBub2RlOworICAgIGlmICghV2ViQmlu ZGluZ3M6OmdldE5vZGUoYXJndW1lbnRzWzBdLnZhbHVlLm9iamVjdFZhbHVlLCAmbm9kZSkpCisg ICAgICAgIHJldHVybjsKKworICAgIFdlYlN0cmluZyBjb250ZW50ID0gbV9zaGVsbC0+d2ViVmll d0hvc3QoKS0+dGV4dFN1cnJvdW5kaW5nRWxlbWVudChub2RlLCBhcmd1bWVudHNbMV0udG9JbnQz MigpLCBhcmd1bWVudHNbMl0udG9JbnQzMigpKTsKKyAgICByZXN1bHQtPnNldChjb250ZW50LnV0 ZjgoKSk7Cit9CmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlv dXRUZXN0Q29udHJvbGxlci5oIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0 VGVzdENvbnRyb2xsZXIuaAppbmRleCBlNzIzODYwYTgwNWIwOWM4NjA0MTJiMTQzOWJmZmQ4MDdl Y2I5Yjg5Li5mNWJhMDY2MDZiZTJlNjZhYTFjMTY3MDMyYWJkYzk0N2I3ZmJiZDdjIDEwMDY0NAot LS0gYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5o CisrKyBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVy LmgKQEAgLTQ1Niw2ICs0NTYsMTEgQEAgcHVibGljOgogICAgIC8vIFVzZWQgdG8gc2V0IHRoZSBk ZXZpY2Ugc2NhbGUgZmFjdG9yLgogICAgIHZvaWQgc2V0QmFja2luZ1NjYWxlRmFjdG9yKGNvbnN0 IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsKIAorICAgIC8vIFJldHJpZXZlcyB0aGUg dGV4dCBzdXJyb3VuZGluZyBhIHBvc2l0aW9uIGluIGEgdGV4dCBub2RlLgorICAgIC8vIFRoZSBm aXJzdCBjaGlsZCBvZiB0aGUgZWxlbWVudCBnaXZlbiB5IGl0cyBpZCB3aWxsIGJlIHVzZWQgYXMg cmVmZXJlbmNlLAorICAgIC8vIG9yIGl0cyBuZXh0IHNpYmxpbmcgaWYgbm90IHByZXNlbnQuIEl0 IG11c3QgYmUgYSB0ZXh0IG5vZGUuCisgICAgdm9pZCB0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNv bnN0IENwcEFyZ3VtZW50TGlzdCYsIENwcFZhcmlhbnQqKTsKKwogcHVibGljOgogICAgIC8vIFRo ZSBmb2xsb3dpbmcgbWV0aG9kcyBhcmUgbm90IGV4cG9zZWQgdG8gSmF2YVNjcmlwdC4KICAgICB2 b2lkIHNldFdvcmtRdWV1ZUZyb3plbihib29sIGZyb3plbikgeyBtX3dvcmtRdWV1ZS5zZXRGcm96 ZW4oZnJvemVuKTsgfQpkaWZmIC0tZ2l0IGEvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0v V2ViVmlld0hvc3QuY3BwIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hv c3QuY3BwCmluZGV4IDg4ZTA3Mzc4ZjQ1N2Q5ZTU4MjBhNWQ1OTYyYmQwZmMzYzFkOGJjNGYuLmY3 MGI0ZGZhYjI0ZjdjOTI3ODljMmRmMDgzODU2MzExZWZjZDI1YzUgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmNwcAorKysgYi9Ub29scy9EdW1w UmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5jcHAKQEAgLTY0LDYgKzY0LDcgQEAKICNp bmNsdWRlICJwbGF0Zm9ybS9XZWJTZXJpYWxpemVkU2NyaXB0VmFsdWUuaCIKICNpbmNsdWRlICJw bGF0Zm9ybS9XZWJTaXplLmgiCiAjaW5jbHVkZSAiV2ViU3RvcmFnZU5hbWVzcGFjZS5oIgorI2lu Y2x1ZGUgIldlYlN1cnJvdW5kaW5nVGV4dC5oIgogI2luY2x1ZGUgIldlYlRleHRDaGVja2luZ0Nv bXBsZXRpb24uaCIKICNpbmNsdWRlICJXZWJUZXh0Q2hlY2tpbmdSZXN1bHQuaCIKICNpbmNsdWRl ICJXZWJVc2VyTWVkaWFDbGllbnRNb2NrLmgiCkBAIC05MDEsNiArOTAyLDE2IEBAIHZvaWQgV2Vi Vmlld0hvc3Q6OmRpZExvc2VQb2ludGVyTG9jaygpCiB9CiAjZW5kaWYKIAorV2ViS2l0OjpXZWJT dHJpbmcgV2ViVmlld0hvc3Q6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQoY29uc3QgV2ViS2l0OjpX ZWJOb2RlJiBub2RlLCB1bnNpZ25lZCBvZmZzZXQsIHVuc2lnbmVkIG1heExlbmd0aCkKK3sKKyAg ICBpZiAobm9kZS5pc051bGwoKSB8fCAhbm9kZS5pc1RleHROb2RlKCkgfHwgb2Zmc2V0ID49IG5v ZGUubm9kZVZhbHVlKCkubGVuZ3RoKCkpCisgICAgICAgIHJldHVybiBXZWJTdHJpbmcoKTsKKwor ICAgIFdlYlN1cnJvdW5kaW5nVGV4dCBzdXJyb3VuZGluZ1RleHQ7CisgICAgc3Vycm91bmRpbmdU ZXh0LmluaXRpYWxpemUobm9kZSwgb2Zmc2V0LCBtYXhMZW5ndGgpOworICAgIHJldHVybiBzdXJy b3VuZGluZ1RleHQudGV4dENvbnRlbnQoKTsKK30KKwogdm9pZCBXZWJWaWV3SG9zdDo6c2hvdyhX ZWJOYXZpZ2F0aW9uUG9saWN5KQogewogICAgIG1faGFzV2luZG93ID0gdHJ1ZTsKZGlmZiAtLWdp dCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dlYlZpZXdIb3N0LmggYi9Ub29scy9E dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9XZWJWaWV3SG9zdC5oCmluZGV4IGNlMTg5ZDkxNTRjYjQ5 MGVhMTM0YjMzZmQ0OWMwNjIzZTYyOTdmOWIuLjQ5NDA0MjExMjk1Y2E5ZDM2Y2EzZGE2YjEwODQ5 YmQyNzBmMzAzZjMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL1dl YlZpZXdIb3N0LmgKKysrIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vV2ViVmlld0hv c3QuaApAQCAtMTI4LDYgKzEyOCw4IEBAIGNsYXNzIFdlYlZpZXdIb3N0IDogcHVibGljIFdlYktp dDo6V2ViVmlld0NsaWVudCwgcHVibGljIFdlYktpdDo6V2ViRnJhbWVDbGllbnQsCiAgICAgdm9p ZCBzZXRQb2ludGVyTG9ja1dpbGxGYWlsU3luY2hyb25vdXNseSgpIHsgbV9wb2ludGVyTG9ja1Bs YW5uZWRSZXN1bHQgPSBQb2ludGVyTG9ja1dpbGxGYWlsU3luYzsgfQogI2VuZGlmCiAKKyAgICBX ZWJLaXQ6OldlYlN0cmluZyB0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNvbnN0IFdlYktpdDo6V2Vi Tm9kZSYsIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgbWF4TGVuZ3RoKTsKKwogICAgIC8vIE5h dmlnYXRpb25Ib3N0CiAgICAgdmlydHVhbCBib29sIG5hdmlnYXRlKGNvbnN0IFRlc3ROYXZpZ2F0 aW9uRW50cnkmLCBib29sIHJlbG9hZCk7CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA2YWFhNWMxYWFjY2RkYjMwMWVlNmU0 NDNmMTZlOTUwMjhlMGUxM2ZlLi5hM2JjODJlZjkzM2IxNjk4ZTY1NmRmNjJjMzY3NTNhYTU4NDI3 NjNmIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTItMDYtMjYgIExlYW5kcm8gR3JhY2lhIEdp bCAgPGxlYW5kcm9ncmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1w bGVtZW50IGEgTGF5b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAg IEFkZCBhIG5ldyBsYXlvdXQgdGVzdCBmb3IgdGhlIHN1cnJvdW5kaW5nIHRleHQgZmVhdHVyZS4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHBsYXRm b3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRl eHQuaHRtbDogQWRkZWQuCisKIDIwMTItMDctMDIgIEVtaWwgQSBFa2x1bmQgIDxlYWVAY2hyb21p dW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQgY2hyb21pdW0gZXhwZWN0YXRpb25zIHVwZGF0 ZS4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2Zhc3QvdGV4dC9z dXJyb3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9t aXVtL2Zhc3QvdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45 MTJjMWM1MmRiYmMzZDViMDE2M2JiOTY0ODAyZDk0YjdlNGRiZWRkCi0tLSAvZGV2L251bGwKKysr IGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRl eHQtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMjEgQEAKK1Rlc3QgdGhlIGV4dHJhY3Rpb24gb2Yg dGhlIHRleHQgc3Vycm91bmRpbmcgYW4gZWxlbWVudC4KKworT24gc3VjY2VzcywgeW91IHdpbGwg c2VlIGEgc2VyaWVzIG9mICJQQVNTIiBtZXNzYWdlcywgZm9sbG93ZWQgYnkgIlRFU1QgQ09NUExF VEUiLgorCisKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxw IGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCAwLCAxMDAp IGlzICIxMjM0NSA2Nzg5IDEyMzQ1IDY3ODkiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRv bj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4u PC9idXR0b24+JywgNSwgNikgaXMgIjg5IDEyMyIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0 dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9u Pi48L2J1dHRvbj4nLCA1LCAwKSBpcyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+ LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+Ljwv YnV0dG9uPicsIDUsIDEpIGlzICIxIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+Ljwv YnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0 dG9uPicsIDYsIDIpIGlzICIxMiIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1 dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRv bj4nLCAxMDAsIDUpIGlzICIiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPHNlbGVjdD4uPC9zZWxl Y3Q+PGRpdj41N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZTwvZGl2PiA8c3Bhbj5DaGlj YWdvPC9zcGFuPiA8c3BhbiBpZD0iaGVyZSI+SUw8L3NwYW4+IDxzcGFuPjYwNjM3PC9zcGFuPjxz ZWxlY3Q+Ljwvc2VsZWN0PicsIDAsIDEwMCkgaXMgIjU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3Jl IERyaXZlIENoaWNhZ28gSUwgNjA2MzciCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGZpZWxkc2V0 Pi48L2ZpZWxkc2V0PjEyMzQ1PGJ1dHRvbj5hYmM8L2J1dHRvbj48cD42Nzg5PGJyIGlkPSJoZXJl Ii8+MTIzNDU8L3A+Njc4OTx0ZXh0YXJlYT5hYmM8L3RleHRhcmVhPjAxMjM8ZmllbGRzZXQ+Ljwv ZmllbGRzZXQ+JywgMCwgMTAwKSBpcyAiNjc4OSAxMjM0NSA2Nzg5IgorUEFTUyBzdXJyb3VuZGlu Z1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPlRoaXMgaXMgPCEtLSBjb21t ZW50IC0tIT5hIHRlc3QgPCcgKyAnc2NyaXB0IGxhbmd1YWdlPSJqYXZhc2NyaXB0Ij48JyArICcv c2NyaXB0PmV4YW1wbGU8YnV0dG9uPi48L2J1dHRvbj4nLCAwLCAxMDApIGlzICJUaGlzIGlzIGEg dGVzdCBleGFtcGxlIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjxk aXYgaWQ9ImhlcmUiPjAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTwvZGl2PjxidXR0b24+ LjwvYnV0dG9uPicsIDE1LCAxMikgaXMgIjkwMTIzNDU2Nzg5MCIKK1BBU1Mgc3Vycm91bmRpbmdU ZXh0KCc8b3B0aW9uPi48L29wdGlvbj4xMjM0NTxidXR0b24gaWQ9ImhlcmUiPnRlc3Q8L2J1dHRv bj48b3B0aW9uPi48L29wdGlvbj4nLCAwLCAxMDApIGlzICIiCitQQVNTIHN1cnJvdW5kaW5nVGV4 dCgnPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uPnRlPHNwYW4gaWQ9ImhlcmUiPnN0PC9z cGFuPjwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0aW9uPicsIDAsIDEwMCkgaXMgIiIKK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9mYXN0L3RleHQvc3Vycm91bmRpbmctdGV4dC5o dG1sIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZmFzdC90ZXh0L3N1cnJvdW5kaW5n LXRleHQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xN2U1OGViNDNlZDkwYWY2YWFhMmI5Zjc0N2JlYmRkMzNk YmRlMGQ5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0v ZmFzdC90ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbApAQCAtMCwwICsxLDU3IEBACis8IURPQ1RZ UEUgaHRtbD4KKzxodG1sPgorPGhlYWQ+Cis8bWV0YSBjaGFyc2V0PSJ1dGYtOCI+Cis8c2NyaXB0 IHNyYz0iLi4vLi4vLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2Ny aXB0PgorPC9oZWFkPgorPGJvZHk+Cis8ZGl2IGlkPSJ0ZXN0Ij4KKzwvZGl2PgorPHAgaWQ9ImRl c2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxzY3JpcHQgdHlwZT0i dGV4dC9qYXZhc2NyaXB0Ij4KK2Rlc2NyaXB0aW9uKCdUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRo ZSB0ZXh0IHN1cnJvdW5kaW5nIGFuIGVsZW1lbnQuJyk7CisKK2Z1bmN0aW9uIHN1cnJvdW5kaW5n VGV4dChodG1sLCBvZmZzZXQsIG1heExlbmd0aCkgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRC eUlkKCd0ZXN0JykuaW5uZXJIVE1MID0gaHRtbDsKKworICAgIHZhciBoZXJlID0gZG9jdW1lbnQu Z2V0RWxlbWVudEJ5SWQoJ2hlcmUnKTsKKyAgICBpZiAoaGVyZSA9PSBudWxsKQorICAgICAgICB0 aHJvdyAnVGVzdCBjYXNlIG5lZWRzIGFuIGVsZW1lbnQgd2l0aCBpZCAiaGVyZSInOworCisgICAg dmFyIG5vZGUgPSBoZXJlLmhhc0NoaWxkTm9kZXMoKSA/IGhlcmUuZmlyc3RDaGlsZCA6IGhlcmUu bmV4dFNpYmxpbmc7CisgICAgaWYgKG5vZGUgPT0gbnVsbCkKKyAgICAgICAgdGhyb3cgJ05vIG5v ZGUgYWZ0ZXIgImhlcmUiIGVsZW1lbnQnOworCisgICAgdmFyIHRleHQgPSB3aW5kb3cudGVzdFJ1 bm5lci50ZXh0U3Vycm91bmRpbmdFbGVtZW50KG5vZGUsIG9mZnNldCwgbWF4TGVuZ3RoKTsKKyAg ICByZXR1cm4gdGV4dC5yZXBsYWNlKC9ccysvZywgJyAnKS5yZXBsYWNlKC9eXHMqfFxzKiQvZywg JycpOworfQorCitmdW5jdGlvbiBydW4oKSB7CisgICAgaWYgKCF3aW5kb3cudGVzdFJ1bm5lcikK KyAgICAgICAgcmV0dXJuOworCisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGlu Z1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9w PjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgMCwgMTAwKScsICcxMjM0NSA2Nzg5IDEyMzQ1IDY3 ODknKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0 b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+ LjwvYnV0dG9uPlwnLCA1LCA2KScsICc4OSAxMjMnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJp bmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUi PjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPlwnLCA1LCAwKScsICcnKTsKKyAg ICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0 dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9u PlwnLCA1LCAxKScsICcxJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGlu Z1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9w PjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgNiwgMiknLCAnMTInKTsKKyAgICBzaG91bGRCZUVx dWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAg aWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPlwnLCAxMDAsIDUp JywgJycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPHNl bGVjdD4uPC9zZWxlY3Q+PGRpdj41N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZTwvZGl2 PiA8c3Bhbj5DaGljYWdvPC9zcGFuPiA8c3BhbiBpZD0iaGVyZSI+SUw8L3NwYW4+IDxzcGFuPjYw NjM3PC9zcGFuPjxzZWxlY3Q+Ljwvc2VsZWN0PlwnLCAwLCAxMDApJywgJzU3dGggU3RyZWV0IGFu ZCBMYWtlIFNob3JlIERyaXZlIENoaWNhZ28gSUwgNjA2MzcnKTsKKyAgICBzaG91bGRCZUVxdWFs VG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxmaWVsZHNldD4uPC9maWVsZHNldD4xMjM0NTxi dXR0b24+YWJjPC9idXR0b24+PHA+Njc4OTxiciBpZD0iaGVyZSIvPjEyMzQ1PC9wPjY3ODk8dGV4 dGFyZWE+YWJjPC90ZXh0YXJlYT4wMTIzPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PlwnLCAwLCAxMDAp JywgJzY3ODkgMTIzNDUgNjc4OScpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91 bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0b24+PGRpdiBpZD0iaGVyZSI+VGhpcyBpcyA8IS0t IGNvbW1lbnQgLS0hPmEgdGVzdCA8XCcgKyBcJ3NjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCI+ PFwnICsgXCcvc2NyaXB0PmV4YW1wbGU8YnV0dG9uPi48L2J1dHRvbj5cJywgMCwgMTAwKScsICdU aGlzIGlzIGEgdGVzdCBleGFtcGxlJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJy b3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj4wMTIzNDU2Nzg5 MDEyMzQ1Njc4OTAxMjM0NTY3ODk8L2Rpdj48YnV0dG9uPi48L2J1dHRvbj5cJywgMTUsIDEyKScs ICc5MDEyMzQ1Njc4OTAnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5n VGV4dChcJzxvcHRpb24+Ljwvb3B0aW9uPjEyMzQ1PGJ1dHRvbiBpZD0iaGVyZSI+dGVzdDwvYnV0 dG9uPjxvcHRpb24+Ljwvb3B0aW9uPlwnLCAwLCAxMDApJywgJycpOworICAgIHNob3VsZEJlRXF1 YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0 dG9uPnRlPHNwYW4gaWQ9ImhlcmUiPnN0PC9zcGFuPjwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0aW9u PlwnLCAwLCAxMDApJywgJycpOworCisgICAgZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChkb2N1 bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpKTsKKyAgICBmaW5pc2hKU1Rlc3QoKTsKK30KKwor d2luZG93Lm9ubG9hZCA9IHJ1bjsKK3dpbmRvdy5qc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKK3dpbmRv dy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4v Li4vLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwv Ym9keT4KKzwvaHRtbD4K 150453 2012-07-02 11:16:31 -0700 2012-07-02 14:49:03 -0700 Patch bug-82461-20120702191630.patch text/plain 13906 leandrogracia U3VidmVyc2lvbiBSZXZpc2lvbjogMTIxNjg5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGJiZjhmN2I3NGYzZDgwZTBiNjc5NDBlOTg2YTU3N2I5MTRmMWM1MTguLjYyNzA1MmZjNTVmZWVm MGI5ZTlhYmMwYjdiN2ZjNWI0M2VlZTBiNjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMTkgQEAKKzIwMTItMDctMDIgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9n cmFjaWFAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5 b3V0IFRlc3QgZm9yIGVkaXRpbmcvU3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04MjQ2MQorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFsbG93IHBhc3Npbmcgbm9kZXMgYXMgYXJndW1l bnRzIGZvciBsYXlvdXQgdGVzdCBtZXRob2RzLgorCisgICAgICAgICogcHVibGljL1dlYkJpbmRp bmdzLmg6CisgICAgICAgIChXZWJCaW5kaW5ncyk6CisgICAgICAgICogc3JjL1dlYkJpbmRpbmdz LmNwcDoKKyAgICAgICAgKFdlYktpdDo6Z2V0Tm9kZUltcGwpOgorICAgICAgICAoV2ViS2l0KToK KyAgICAgICAgKFdlYktpdDo6V2ViQmluZGluZ3M6OmdldE5vZGUpOgorCiAyMDEyLTA3LTAxICBL ZWlzaGkgSGF0dG9yaSAgPGtlaXNoaUB3ZWJraXQub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQs IHJvbGxpbmcgb3V0IHIxMjE2NTAuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9XZWJCaW5kaW5ncy5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi QmluZGluZ3MuaAppbmRleCAzNGEzMjA1NTdkMTNiZTg5NjQ1MTQ4OTZiOGNiNDk4NDA3YmM0OGM0 Li5kYzdiNDVmMzJhNWZlNDI2NDhjNTZlMmRiNWRlNmI0ZjY3NDBkMDE1IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJCaW5kaW5ncy5oCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkJpbmRpbmdzLmgKQEAgLTE1Miw2ICsxNTIsMTAgQEAg cHVibGljOgogICAgIC8vIElmIHNvLCByZXR1cm4gaXQgYXMgYSBXZWJBcnJheUJ1ZmZlclZpZXcg b2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0QXJyYXlCdWZmZXJWaWV3 KE5QT2JqZWN0KiBhcnJheUJ1ZmZlclZpZXcsIFdlYkFycmF5QnVmZmVyVmlldyopOwogCisgICAg Ly8gUmV0dXJuIHRydWUgKHN1Y2Nlc3MpIGlmIHRoZSBnaXZlbiBucG9iaiBpcyBhIG5vZGUuCisg ICAgLy8gSWYgc28sIHJldHVybiB0aGF0IG5vZGUgYXMgYSBXZWJOb2RlIG9iamVjdC4KKyAgICBX RUJLSVRfRVhQT1JUIHN0YXRpYyBib29sIGdldE5vZGUoTlBPYmplY3QqIGVsZW1lbnQsIFdlYk5v ZGUqKTsKKwogICAgIC8vIFJldHVybiB0cnVlIChzdWNjZXNzKSBpZiB0aGUgZ2l2ZW4gbnBvYmog aXMgYW4gZWxlbWVudC4KICAgICAvLyBJZiBzbywgcmV0dXJuIHRoYXQgZWxlbWVudCBhcyBhIFdl YkVsZW1lbnQgb2JqZWN0LgogICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGJvb2wgZ2V0RWxlbWVu dChOUE9iamVjdCogZWxlbWVudCwgV2ViRWxlbWVudCopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvV2ViQmluZGluZ3MuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViQmluZGluZ3MuY3BwCmluZGV4IDIzMmI1YjQ2OTRiZWM0OGYyZmIxNzBiYTI3OWY2 MmI2YjE3MTJiMTMuLmI5YmJkNWQzNzY3MmZkZmUxMzRhZDgyYTkxYzc1YWRlNjQzNDEzMGYgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkJpbmRpbmdzLmNwcAorKysg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJCaW5kaW5ncy5jcHAKQEAgLTIyMyw2ICsy MjMsMjEgQEAgc3RhdGljIGJvb2wgZ2V0UmFuZ2VJbXBsKE5QT2JqZWN0KiBvYmplY3QsIFdlYlJh bmdlKiB3ZWJSYW5nZSkKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorc3RhdGljIGJvb2wgZ2V0Tm9k ZUltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViTm9kZSogd2ViTm9kZSkKK3sKKyAgICBpZiAoIW9i amVjdCB8fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmplY3RDbGFzcykpCisgICAgICAg IHJldHVybiBmYWxzZTsKKworICAgIFY4TlBPYmplY3QqIHY4TlBPYmplY3QgPSByZWludGVycHJl dF9jYXN0PFY4TlBPYmplY3QqPihvYmplY3QpOworICAgIHY4OjpIYW5kbGU8djg6Ok9iamVjdD4g djhPYmplY3QodjhOUE9iamVjdC0+djhPYmplY3QpOworICAgIE5vZGUqIG5hdGl2ZSA9IFY4Tm9k ZTo6SGFzSW5zdGFuY2UodjhPYmplY3QpID8gVjhOb2RlOjp0b05hdGl2ZSh2OE9iamVjdCkgOiAw OworICAgIGlmICghbmF0aXZlKQorICAgICAgICByZXR1cm4gZmFsc2U7CisKKyAgICAqd2ViTm9k ZSA9IFdlYk5vZGUobmF0aXZlKTsKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwogc3RhdGljIGJvb2wg Z2V0RWxlbWVudEltcGwoTlBPYmplY3QqIG9iamVjdCwgV2ViRWxlbWVudCogd2ViRWxlbWVudCkK IHsKICAgICBpZiAoIW9iamVjdCB8fCAob2JqZWN0LT5fY2xhc3MgIT0gbnBTY3JpcHRPYmplY3RD bGFzcykpCkBAIC0zMjgsNiArMzQzLDE2IEBAIGJvb2wgV2ViQmluZGluZ3M6OmdldEFycmF5QnVm ZmVyVmlldyhOUE9iamVjdCogYXJyYXlCdWZmZXJWaWV3LCBXZWJBcnJheUJ1ZmZlclZpCiAjZW5k aWYKIH0KIAorYm9vbCBXZWJCaW5kaW5nczo6Z2V0Tm9kZShOUE9iamVjdCogbm9kZSwgV2ViTm9k ZSogd2ViTm9kZSkKK3sKKyNpZiBVU0UoVjgpCisgICAgcmV0dXJuIGdldE5vZGVJbXBsKG5vZGUs IHdlYk5vZGUpOworI2Vsc2UKKyAgICAvLyBOb3Qgc3VwcG9ydGVkIG9uIG90aGVyIHBvcnRzIChK U0MsIGV0Yy4pLgorICAgIHJldHVybiBmYWxzZTsKKyNlbmRpZgorfQorCiBib29sIFdlYkJpbmRp bmdzOjpnZXRFbGVtZW50KE5QT2JqZWN0KiBlbGVtZW50LCBXZWJFbGVtZW50KiB3ZWJFbGVtZW50 KQogewogI2lmIFVTRShWOCkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0No YW5nZUxvZwppbmRleCBjMGMwYmRhNzc4NWQ2ODFiN2E2ZDhlMTgwODRiZWE4ZTMyMzFhNWU0Li45 YzgzNGM2OGQ2YzkxMjllMjU2NWZhOTc2YWNkM2JlMDYyNTY5OWUxIDEwMDY0NAotLS0gYS9Ub29s cy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMTIt MDctMDIgIExlYW5kcm8gR3JhY2lhIEdpbCAgPGxlYW5kcm9ncmFjaWFAY2hyb21pdW0ub3JnPgor CisgICAgICAgIFtDaHJvbWl1bV0gSW1wbGVtZW50IGEgTGF5b3V0IFRlc3QgZm9yIGVkaXRpbmcv U3Vycm91bmRpbmdUZXh0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD04MjQ2MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZCBhIG5ldyBtZXRob2QgdG8gdGhlIGxheW91dCB0ZXN0IGNvbnRyb2xsZXIgaW4g b3JkZXIgdG8gcmV0cmlldmUgdGhlCisgICAgICAgIHRleHQgc3Vycm91bmRpbmcgYSBwcm92aWRl ZCBlbGVtZW50LgorCisgICAgICAgICogRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVz dENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRl c3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vycm91 bmRpbmdFbGVtZW50KToKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRU ZXN0Q29udHJvbGxlci5oOgorICAgICAgICAoTGF5b3V0VGVzdENvbnRyb2xsZXIpOgorCiAyMDEy LTA3LTAyICBDYXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAg ICAgICBbR1RLXSBSZWFkIGZvbnRzIHBhdGggd2hlbiBydW5uaW5nIGxheW91dCB0ZXN0cyBmcm9t IGFsdGVybmF0aXZlIGZvbnRzIGRpciB3aGVuIG1haW4gZGlyIGRvZXNuJ3QgZXhpc3QKZGlmZiAt LWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVy LmNwcCBiL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVy LmNwcAppbmRleCBlZmJmM2ZmNjllZmU0NmVjZTE1ZjYzMDE2MzM0MTkyOWQ4OGUwNjE4Li43MmIx MzA0Zjg1ZmQyNGFlNTgzZTUxMmZjODc2NWIyODUzMjJiOTk0IDEwMDY0NAotLS0gYS9Ub29scy9E dW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5jcHAKKysrIGIvVG9v bHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCkBAIC02 MSw2ICs2MSw3IEBACiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViU2VyaWFsaXplZFNjcmlwdFZhbHVl LmgiCiAjaW5jbHVkZSAiV2ViU2V0dGluZ3MuaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJTaXpl LmgiCisjaW5jbHVkZSAiV2ViU3Vycm91bmRpbmdUZXh0LmgiCiAjaW5jbHVkZSAicGxhdGZvcm0v V2ViVVJMLmgiCiAjaW5jbHVkZSAiV2ViVmlldy5oIgogI2luY2x1ZGUgIldlYlZpZXdIb3N0Lmgi CkBAIC0yNzUsNyArMjc2LDggQEAgTGF5b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250 cm9sbGVyKFRlc3RTaGVsbCogc2hlbGwpCiAgICAgYmluZE1ldGhvZCgic2V0Rml4ZWRMYXlvdXRT aXplIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZXRGaXhlZExheW91dFNpemUpOwogICAgIGJp bmRNZXRob2QoInNlbGVjdGlvbkFzTWFya3VwIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZWxl Y3Rpb25Bc01hcmt1cCk7CiAgICAgYmluZE1ldGhvZCgic2V0SGFzQ3VzdG9tRnVsbFNjcmVlbkJl aGF2aW9yIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZXRIYXNDdXN0b21GdWxsU2NyZWVuQmVo YXZpb3IpOwotICAgIAorICAgIGJpbmRNZXRob2QoInRleHRTdXJyb3VuZGluZ0VsZW1lbnQiLCAm TGF5b3V0VGVzdENvbnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQpOworCiAgICAgLy8g VGhlIGZhbGxiYWNrIG1ldGhvZCBpcyBjYWxsZWQgd2hlbiBhbiB1bmtub3duIG1ldGhvZCBpcyBp bnZva2VkLgogICAgIGJpbmRGYWxsYmFja01ldGhvZCgmTGF5b3V0VGVzdENvbnRyb2xsZXI6OmZh bGxiYWNrTWV0aG9kKTsKIApAQCAtMjM0MywzICsyMzQ1LDI4IEBAIHZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OnNldFBvaW50ZXJMb2NrV2lsbEZhaWxTeW5jaHJvbm91c2x5KGNvbnN0IENwcEFy Z3VtZW50CiAgICAgcmVzdWx0LT5zZXROdWxsKCk7CiB9CiAjZW5kaWYKKwordm9pZCBMYXlvdXRU ZXN0Q29udHJvbGxlcjo6dGV4dFN1cnJvdW5kaW5nRWxlbWVudChjb25zdCBDcHBBcmd1bWVudExp c3QmIGFyZ3VtZW50cywgQ3BwVmFyaWFudCogcmVzdWx0KQoreworICAgIHJlc3VsdC0+c2V0TnVs bCgpOworICAgIGlmIChhcmd1bWVudHMuc2l6ZSgpIDwgMyB8fCAhYXJndW1lbnRzWzBdLmlzT2Jq ZWN0KCkgfHwgIWFyZ3VtZW50c1sxXS5pc051bWJlcigpIHx8ICFhcmd1bWVudHNbMl0uaXNOdW1i ZXIoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgV2ViTm9kZSBub2RlOworICAgIGlmICghV2Vi QmluZGluZ3M6OmdldE5vZGUoYXJndW1lbnRzWzBdLnZhbHVlLm9iamVjdFZhbHVlLCAmbm9kZSkp CisgICAgICAgIHJldHVybjsKKworICAgIGlmIChub2RlLmlzTnVsbCgpIHx8ICFub2RlLmlzVGV4 dE5vZGUoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgdW5zaWduZWQgb2Zmc2V0ID0gYXJndW1l bnRzWzFdLnRvSW50MzIoKTsKKyAgICBpZiAob2Zmc2V0ID49IG5vZGUubm9kZVZhbHVlKCkubGVu Z3RoKCkpIHsKKyAgICAgICAgcmVzdWx0LT5zZXQoV2ViU3RyaW5nKCkudXRmOCgpKTsKKyAgICAg ICAgcmV0dXJuOworICAgIH0KKworICAgIFdlYlN1cnJvdW5kaW5nVGV4dCBzdXJyb3VuZGluZ1Rl eHQ7CisgICAgdW5zaWduZWQgbWF4TGVuZ3RoID0gYXJndW1lbnRzWzJdLnRvSW50MzIoKTsKKyAg ICBzdXJyb3VuZGluZ1RleHQuaW5pdGlhbGl6ZShub2RlLCBvZmZzZXQsIG1heExlbmd0aCk7Cisg ICAgcmVzdWx0LT5zZXQoc3Vycm91bmRpbmdUZXh0LnRleHRDb250ZW50KCkudXRmOCgpKTsKK30K ZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250 cm9sbGVyLmggYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJv bGxlci5oCmluZGV4IGU3MjM4NjBhODA1YjA5Yzg2MDQxMmIxNDM5YmZmZDgwN2VjYjliODkuLmY1 YmEwNjYwNmJlMmU2NmFhMWMxNjcwMzJhYmRjOTQ3YjdmYmJkN2MgMTAwNjQ0Ci0tLSBhL1Rvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmgKKysrIGIvVG9v bHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuaApAQCAtNDU2 LDYgKzQ1NiwxMSBAQCBwdWJsaWM6CiAgICAgLy8gVXNlZCB0byBzZXQgdGhlIGRldmljZSBzY2Fs ZSBmYWN0b3IuCiAgICAgdm9pZCBzZXRCYWNraW5nU2NhbGVGYWN0b3IoY29uc3QgQ3BwQXJndW1l bnRMaXN0JiwgQ3BwVmFyaWFudCopOwogCisgICAgLy8gUmV0cmlldmVzIHRoZSB0ZXh0IHN1cnJv dW5kaW5nIGEgcG9zaXRpb24gaW4gYSB0ZXh0IG5vZGUuCisgICAgLy8gVGhlIGZpcnN0IGNoaWxk IG9mIHRoZSBlbGVtZW50IGdpdmVuIHkgaXRzIGlkIHdpbGwgYmUgdXNlZCBhcyByZWZlcmVuY2Us CisgICAgLy8gb3IgaXRzIG5leHQgc2libGluZyBpZiBub3QgcHJlc2VudC4gSXQgbXVzdCBiZSBh IHRleHQgbm9kZS4KKyAgICB2b2lkIHRleHRTdXJyb3VuZGluZ0VsZW1lbnQoY29uc3QgQ3BwQXJn dW1lbnRMaXN0JiwgQ3BwVmFyaWFudCopOworCiBwdWJsaWM6CiAgICAgLy8gVGhlIGZvbGxvd2lu ZyBtZXRob2RzIGFyZSBub3QgZXhwb3NlZCB0byBKYXZhU2NyaXB0LgogICAgIHZvaWQgc2V0V29y a1F1ZXVlRnJvemVuKGJvb2wgZnJvemVuKSB7IG1fd29ya1F1ZXVlLnNldEZyb3plbihmcm96ZW4p OyB9CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFu Z2VMb2cKaW5kZXggNmFhYTVjMWFhY2NkZGIzMDFlZTZlNDQzZjE2ZTk1MDI4ZTBlMTNmZS4uNjgw ZjAzOTY0MzFjNzkxODIzMDdjOTViNDk1YzE3MGIwMTQ3MDk5MSAxMDA2NDQKLS0tIGEvTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1 IEBACisyMDEyLTA3LTAyICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9t aXVtLm9yZz4KKworICAgICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZv ciBlZGl0aW5nL1N1cnJvdW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9ODI0NjEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBBZGQgYSBuZXcgbGF5b3V0IHRlc3QgZm9yIHRoZSBzdXJyb3VuZGlu ZyB0ZXh0IGZlYXR1cmUuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9jaHJvbWl1bS9lZGl0aW5nL3N1 cnJvdW5kaW5nLXRleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAg ICAgICAqIHBsYXRmb3JtL2Nocm9taXVtL2VkaXRpbmcvc3Vycm91bmRpbmctdGV4dC9zdXJyb3Vu ZGluZy10ZXh0Lmh0bWw6IEFkZGVkLgorCiAyMDEyLTA3LTAyICBFbWlsIEEgRWtsdW5kICA8ZWFl QGNocm9taXVtLm9yZz4KIAogICAgICAgICBVbnJldmlld2VkIGNocm9taXVtIGV4cGVjdGF0aW9u cyB1cGRhdGUuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9lZGl0 aW5nL3N1cnJvdW5kaW5nLXRleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQgYi9MYXlv dXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9lZGl0aW5nL3N1cnJvdW5kaW5nLXRleHQvc3Vycm91 bmRpbmctdGV4dC1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uOTEyYzFjNTJkYmJjM2Q1YjAxNjNi Yjk2NDgwMmQ5NGI3ZTRkYmVkZAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL3BsYXRm b3JtL2Nocm9taXVtL2VkaXRpbmcvc3Vycm91bmRpbmctdGV4dC9zdXJyb3VuZGluZy10ZXh0LWV4 cGVjdGVkLnR4dApAQCAtMCwwICsxLDIxIEBACitUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRoZSB0 ZXh0IHN1cnJvdW5kaW5nIGFuIGVsZW1lbnQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBh IHNlcmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4K KworCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0i aGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgMCwgMTAwKSBpcyAi MTIzNDUgNjc4OSAxMjM0NSA2Nzg5IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+Ljwv YnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0 dG9uPicsIDUsIDYpIGlzICI4OSAxMjMiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4u PC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9i dXR0b24+JywgNSwgMCkgaXMgIiIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1 dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRv bj4nLCA1LCAxKSBpcyAiMSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRv bj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4n LCA2LCAyKSBpcyAiMTIiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+ MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+Jywg MTAwLCA1KSBpcyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxzZWxlY3Q+Ljwvc2VsZWN0Pjxk aXY+NTd0aCBTdHJlZXQgYW5kIExha2UgU2hvcmUgRHJpdmU8L2Rpdj4gPHNwYW4+Q2hpY2Fnbzwv c3Bhbj4gPHNwYW4gaWQ9ImhlcmUiPklMPC9zcGFuPiA8c3Bhbj42MDYzNzwvc3Bhbj48c2VsZWN0 Pi48L3NlbGVjdD4nLCAwLCAxMDApIGlzICI1N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2 ZSBDaGljYWdvIElMIDYwNjM3IgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxmaWVsZHNldD4uPC9m aWVsZHNldD4xMjM0NTxidXR0b24+YWJjPC9idXR0b24+PHA+Njc4OTxiciBpZD0iaGVyZSIvPjEy MzQ1PC9wPjY3ODk8dGV4dGFyZWE+YWJjPC90ZXh0YXJlYT4wMTIzPGZpZWxkc2V0Pi48L2ZpZWxk c2V0PicsIDAsIDEwMCkgaXMgIjY3ODkgMTIzNDUgNjc4OSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0 KCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj5UaGlzIGlzIDwhLS0gY29tbWVudCAt LSE+YSB0ZXN0IDwnICsgJ3NjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCI+PCcgKyAnL3Njcmlw dD5leGFtcGxlPGJ1dHRvbj4uPC9idXR0b24+JywgMCwgMTAwKSBpcyAiVGhpcyBpcyBhIHRlc3Qg ZXhhbXBsZSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlk PSJoZXJlIj4wMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODk8L2Rpdj48YnV0dG9uPi48L2J1 dHRvbj4nLCAxNSwgMTIpIGlzICI5MDEyMzQ1Njc4OTAiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgn PG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uIGlkPSJoZXJlIj50ZXN0PC9idXR0b24+PG9w dGlvbj4uPC9vcHRpb24+JywgMCwgMTAwKSBpcyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxv cHRpb24+Ljwvb3B0aW9uPjEyMzQ1PGJ1dHRvbj50ZTxzcGFuIGlkPSJoZXJlIj5zdDwvc3Bhbj48 L2J1dHRvbj48b3B0aW9uPi48L29wdGlvbj4nLCAwLCAxMDApIGlzICIiCitQQVNTIHN1Y2Nlc3Nm dWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1QgQ09NUExFVEUKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0 VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZWRpdGluZy9zdXJyb3VuZGluZy10ZXh0L3N1cnJvdW5k aW5nLXRleHQuaHRtbCBiL0xheW91dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2VkaXRpbmcvc3Vy cm91bmRpbmctdGV4dC9zdXJyb3VuZGluZy10ZXh0Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uMTdlNThlYjQz ZWQ5MGFmNmFhYTJiOWY3NDdiZWJkZDMzZGJkZTBkOQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL3BsYXRmb3JtL2Nocm9taXVtL2VkaXRpbmcvc3Vycm91bmRpbmctdGV4dC9zdXJyb3Vu ZGluZy10ZXh0Lmh0bWwKQEAgLTAsMCArMSw1NyBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4K KzxoZWFkPgorPG1ldGEgY2hhcnNldD0idXRmLTgiPgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4u L2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4KKzxi b2R5PgorPGRpdiBpZD0idGVzdCI+Cis8L2Rpdj4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgor PGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHR5cGU9InRleHQvamF2YXNjcmlwdCI+ CitkZXNjcmlwdGlvbignVGVzdCB0aGUgZXh0cmFjdGlvbiBvZiB0aGUgdGV4dCBzdXJyb3VuZGlu ZyBhbiBlbGVtZW50LicpOworCitmdW5jdGlvbiBzdXJyb3VuZGluZ1RleHQoaHRtbCwgb2Zmc2V0 LCBtYXhMZW5ndGgpIHsKKyAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcpLmlubmVy SFRNTCA9IGh0bWw7CisKKyAgICB2YXIgaGVyZSA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdo ZXJlJyk7CisgICAgaWYgKGhlcmUgPT0gbnVsbCkKKyAgICAgICAgdGhyb3cgJ1Rlc3QgY2FzZSBu ZWVkcyBhbiBlbGVtZW50IHdpdGggaWQgImhlcmUiJzsKKworICAgIHZhciBub2RlID0gaGVyZS5o YXNDaGlsZE5vZGVzKCkgPyBoZXJlLmZpcnN0Q2hpbGQgOiBoZXJlLm5leHRTaWJsaW5nOworICAg IGlmIChub2RlID09IG51bGwpCisgICAgICAgIHRocm93ICdObyBub2RlIGFmdGVyICJoZXJlIiBl bGVtZW50JzsKKworICAgIHZhciB0ZXh0ID0gd2luZG93LnRlc3RSdW5uZXIudGV4dFN1cnJvdW5k aW5nRWxlbWVudChub2RlLCBvZmZzZXQsIG1heExlbmd0aCk7CisgICAgcmV0dXJuIHRleHQucmVw bGFjZSgvXHMrL2csICcgJykucmVwbGFjZSgvXlxzKnxccyokL2csICcnKTsKK30KKworZnVuY3Rp b24gcnVuKCkgeworICAgIGlmICghd2luZG93LnRlc3RSdW5uZXIpCisgICAgICAgIHJldHVybjsK KworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4u PC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9i dXR0b24+XCcsIDAsIDEwMCknLCAnMTIzNDUgNjc4OSAxMjM0NSA2Nzg5Jyk7CisgICAgc2hvdWxk QmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0 NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgNSwg NiknLCAnODkgMTIzJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1Rl eHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3 ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgNSwgMCknLCAnJyk7CisgICAgc2hvdWxkQmVFcXVhbFRv U3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJo ZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgNSwgMSknLCAnMScp OworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4u PC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9i dXR0b24+XCcsIDYsIDIpJywgJzEyJyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJy b3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEy MzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywgMTAwLCA1KScsICcnKTsKKyAgICBzaG91 bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxzZWxlY3Q+Ljwvc2VsZWN0Pjxk aXY+NTd0aCBTdHJlZXQgYW5kIExha2UgU2hvcmUgRHJpdmU8L2Rpdj4gPHNwYW4+Q2hpY2Fnbzwv c3Bhbj4gPHNwYW4gaWQ9ImhlcmUiPklMPC9zcGFuPiA8c3Bhbj42MDYzNzwvc3Bhbj48c2VsZWN0 Pi48L3NlbGVjdD5cJywgMCwgMTAwKScsICc1N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2 ZSBDaGljYWdvIElMIDYwNjM3Jyk7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3Vu ZGluZ1RleHQoXCc8ZmllbGRzZXQ+LjwvZmllbGRzZXQ+MTIzNDU8YnV0dG9uPmFiYzwvYnV0dG9u PjxwPjY3ODk8YnIgaWQ9ImhlcmUiLz4xMjM0NTwvcD42Nzg5PHRleHRhcmVhPmFiYzwvdGV4dGFy ZWE+MDEyMzxmaWVsZHNldD4uPC9maWVsZHNldD5cJywgMCwgMTAwKScsICc2Nzg5IDEyMzQ1IDY3 ODknKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0 b24+LjwvYnV0dG9uPjxkaXYgaWQ9ImhlcmUiPlRoaXMgaXMgPCEtLSBjb21tZW50IC0tIT5hIHRl c3QgPFwnICsgXCdzY3JpcHQgbGFuZ3VhZ2U9ImphdmFzY3JpcHQiPjxcJyArIFwnL3NjcmlwdD5l eGFtcGxlPGJ1dHRvbj4uPC9idXR0b24+XCcsIDAsIDEwMCknLCAnVGhpcyBpcyBhIHRlc3QgZXhh bXBsZScpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1 dHRvbj4uPC9idXR0b24+PGRpdiBpZD0iaGVyZSI+MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2 Nzg5PC9kaXY+PGJ1dHRvbj4uPC9idXR0b24+XCcsIDE1LCAxMiknLCAnOTAxMjM0NTY3ODkwJyk7 CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8b3B0aW9uPi48 L29wdGlvbj4xMjM0NTxidXR0b24gaWQ9ImhlcmUiPnRlc3Q8L2J1dHRvbj48b3B0aW9uPi48L29w dGlvbj5cJywgMCwgMTAwKScsICcnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJv dW5kaW5nVGV4dChcJzxvcHRpb24+Ljwvb3B0aW9uPjEyMzQ1PGJ1dHRvbj50ZTxzcGFuIGlkPSJo ZXJlIj5zdDwvc3Bhbj48L2J1dHRvbj48b3B0aW9uPi48L29wdGlvbj5cJywgMCwgMTAwKScsICcn KTsKKworICAgIGRvY3VtZW50LmJvZHkucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoJ3Rlc3QnKSk7CisgICAgZmluaXNoSlNUZXN0KCk7Cit9CisKK3dpbmRvdy5vbmxvYWQgPSBy dW47Cit3aW5kb3cuanNUZXN0SXNBc3luYyA9IHRydWU7Cit3aW5kb3cuc3VjY2Vzc2Z1bGx5UGFy c2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL2Zhc3QvanMv cmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 150478 2012-07-02 14:49:20 -0700 2012-07-02 17:53:44 -0700 Patch for landing bug-82461-20120702144919.patch text/plain 14181 abarth SW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCShyZXZpc2lvbiAxMjE3MDUpCisrKyBTb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE5 IEBACisyMDEyLTA3LTAyICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9t aXVtLm9yZz4KKworICAgICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZv ciBlZGl0aW5nL1N1cnJvdW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9ODI0NjEKKworICAgICAgICBSZXZpZXdlZCBieSBSeW9zdWtlIE5p d2EuCisKKyAgICAgICAgQWxsb3cgcGFzc2luZyBub2RlcyBhcyBhcmd1bWVudHMgZm9yIGxheW91 dCB0ZXN0IG1ldGhvZHMuCisKKyAgICAgICAgKiBwdWJsaWMvV2ViQmluZGluZ3MuaDoKKyAgICAg ICAgKFdlYkJpbmRpbmdzKToKKyAgICAgICAgKiBzcmMvV2ViQmluZGluZ3MuY3BwOgorICAgICAg ICAoV2ViS2l0OjpnZXROb2RlSW1wbCk6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2Vi S2l0OjpXZWJCaW5kaW5nczo6Z2V0Tm9kZSk6CisKIDIwMTItMDctMDEgIEtlaXNoaSBIYXR0b3Jp ICA8a2Vpc2hpQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQg cjEyMTY1MC4KSW5kZXg6IFNvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYkJpbmRpbmdz LmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViQmluZGlu Z3MuaAkocmV2aXNpb24gMTIxNzA1KQorKysgU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMv V2ViQmluZGluZ3MuaAkod29ya2luZyBjb3B5KQpAQCAtMTUyLDYgKzE1MiwxMCBAQCBwdWJsaWM6 CiAgICAgLy8gSWYgc28sIHJldHVybiBpdCBhcyBhIFdlYkFycmF5QnVmZmVyVmlldyBvYmplY3Qu CiAgICAgV0VCS0lUX0VYUE9SVCBzdGF0aWMgYm9vbCBnZXRBcnJheUJ1ZmZlclZpZXcoTlBPYmpl Y3QqIGFycmF5QnVmZmVyVmlldywgV2ViQXJyYXlCdWZmZXJWaWV3Kik7CiAKKyAgICAvLyBSZXR1 cm4gdHJ1ZSAoc3VjY2VzcykgaWYgdGhlIGdpdmVuIG5wb2JqIGlzIGEgbm9kZS4KKyAgICAvLyBJ ZiBzbywgcmV0dXJuIHRoYXQgbm9kZSBhcyBhIFdlYk5vZGUgb2JqZWN0LgorICAgIFdFQktJVF9F WFBPUlQgc3RhdGljIGJvb2wgZ2V0Tm9kZShOUE9iamVjdCogZWxlbWVudCwgV2ViTm9kZSopOwor CiAgICAgLy8gUmV0dXJuIHRydWUgKHN1Y2Nlc3MpIGlmIHRoZSBnaXZlbiBucG9iaiBpcyBhbiBl bGVtZW50LgogICAgIC8vIElmIHNvLCByZXR1cm4gdGhhdCBlbGVtZW50IGFzIGEgV2ViRWxlbWVu dCBvYmplY3QuCiAgICAgV0VCS0lUX0VYUE9SVCBzdGF0aWMgYm9vbCBnZXRFbGVtZW50KE5QT2Jq ZWN0KiBlbGVtZW50LCBXZWJFbGVtZW50Kik7CkluZGV4OiBTb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9XZWJCaW5kaW5ncy5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViQmluZGluZ3MuY3BwCShyZXZpc2lvbiAxMjE3MDUpCisrKyBTb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJCaW5kaW5ncy5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTIyMyw2ICsy MjMsMjEgQEAgc3RhdGljIGJvb2wgZ2V0UmFuZ2VJbXBsKE5QT2JqZWN0KiBvYmplYwogICAgIHJl dHVybiB0cnVlOwogfQogCitzdGF0aWMgYm9vbCBnZXROb2RlSW1wbChOUE9iamVjdCogb2JqZWN0 LCBXZWJOb2RlKiB3ZWJOb2RlKQoreworICAgIGlmICghb2JqZWN0IHx8IChvYmplY3QtPl9jbGFz cyAhPSBucFNjcmlwdE9iamVjdENsYXNzKSkKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAg VjhOUE9iamVjdCogdjhOUE9iamVjdCA9IHJlaW50ZXJwcmV0X2Nhc3Q8VjhOUE9iamVjdCo+KG9i amVjdCk7CisgICAgdjg6OkhhbmRsZTx2ODo6T2JqZWN0PiB2OE9iamVjdCh2OE5QT2JqZWN0LT52 OE9iamVjdCk7CisgICAgTm9kZSogbmF0aXZlID0gVjhOb2RlOjpIYXNJbnN0YW5jZSh2OE9iamVj dCkgPyBWOE5vZGU6OnRvTmF0aXZlKHY4T2JqZWN0KSA6IDA7CisgICAgaWYgKCFuYXRpdmUpCisg ICAgICAgIHJldHVybiBmYWxzZTsKKworICAgICp3ZWJOb2RlID0gV2ViTm9kZShuYXRpdmUpOwor ICAgIHJldHVybiB0cnVlOworfQorCiBzdGF0aWMgYm9vbCBnZXRFbGVtZW50SW1wbChOUE9iamVj dCogb2JqZWN0LCBXZWJFbGVtZW50KiB3ZWJFbGVtZW50KQogewogICAgIGlmICghb2JqZWN0IHx8 IChvYmplY3QtPl9jbGFzcyAhPSBucFNjcmlwdE9iamVjdENsYXNzKSkKQEAgLTMyOCw2ICszNDMs MTYgQEAgYm9vbCBXZWJCaW5kaW5nczo6Z2V0QXJyYXlCdWZmZXJWaWV3KE5QTwogI2VuZGlmCiB9 CiAKK2Jvb2wgV2ViQmluZGluZ3M6OmdldE5vZGUoTlBPYmplY3QqIG5vZGUsIFdlYk5vZGUqIHdl Yk5vZGUpCit7CisjaWYgVVNFKFY4KQorICAgIHJldHVybiBnZXROb2RlSW1wbChub2RlLCB3ZWJO b2RlKTsKKyNlbHNlCisgICAgLy8gTm90IHN1cHBvcnRlZCBvbiBvdGhlciBwb3J0cyAoSlNDLCBl dGMuKS4KKyAgICByZXR1cm4gZmFsc2U7CisjZW5kaWYKK30KKwogYm9vbCBXZWJCaW5kaW5nczo6 Z2V0RWxlbWVudChOUE9iamVjdCogZWxlbWVudCwgV2ViRWxlbWVudCogd2ViRWxlbWVudCkKIHsK ICNpZiBVU0UoVjgpCkluZGV4OiBUb29scy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gVG9vbHMv Q2hhbmdlTG9nCShyZXZpc2lvbiAxMjE3MDUpCisrKyBUb29scy9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwxOSBAQAorMjAxMi0wNy0wMiAgTGVhbmRybyBHcmFjaWEgR2lsICA8 bGVhbmRyb2dyYWNpYUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJbXBsZW1l bnQgYSBMYXlvdXQgVGVzdCBmb3IgZWRpdGluZy9TdXJyb3VuZGluZ1RleHQKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTgyNDYxCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgUnlvc3VrZSBOaXdhLgorCisgICAgICAgIEFkZCBhIG5ldyBtZXRob2QgdG8gdGhl IGxheW91dCB0ZXN0IGNvbnRyb2xsZXIgaW4gb3JkZXIgdG8gcmV0cmlldmUgdGhlCisgICAgICAg IHRleHQgc3Vycm91bmRpbmcgYSBwcm92aWRlZCBlbGVtZW50LgorCisgICAgICAgICogRHVtcFJl bmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwOgorICAgICAgICAoTGF5 b3V0VGVzdENvbnRyb2xsZXI6OkxheW91dFRlc3RDb250cm9sbGVyKToKKyAgICAgICAgKExheW91 dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KToKKyAgICAgICAgKiBEdW1w UmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5oOgorICAgICAgICAoTGF5 b3V0VGVzdENvbnRyb2xsZXIpOgorCiAyMDEyLTA3LTAyICBDc2FiYSBPc3p0cm9nb27DoWMgIDxv c3N5QHdlYmtpdC5vcmc+CiAKICAgICAgICAgUkVHUkVTU0lPTihyMTIxNDk3KTogSXQgc3dpdGNo ZWQgb2ZmIGFuZCBicm9rZSBtYW55IHVuaXR0ZXN0cwpJbmRleDogVG9vbHMvRHVtcFJlbmRlclRy ZWUvY2hyb21pdW0vTGF5b3V0VGVzdENvbnRyb2xsZXIuY3BwCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFRvb2xz L0R1bXBSZW5kZXJUcmVlL2Nocm9taXVtL0xheW91dFRlc3RDb250cm9sbGVyLmNwcAkocmV2aXNp b24gMTIxNzA1KQorKysgVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5b3V0VGVzdENv bnRyb2xsZXIuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0zOCw5ICszOCw3IEBACiAjaW5jbHVkZSAi VGVzdFNoZWxsLmgiCiAjaW5jbHVkZSAiV2ViQW5pbWF0aW9uQ29udHJvbGxlci5oIgogI2luY2x1 ZGUgIldlYkJpbmRpbmdzLmgiCi0jaW5jbHVkZSAiV2ViV29ya2VySW5mby5oIgogI2luY2x1ZGUg IldlYkNvbnNvbGVNZXNzYWdlLmgiCi0jaW5jbHVkZSAicGxhdGZvcm0vV2ViRGF0YS5oIgogI2lu Y2x1ZGUgIldlYkRldmljZU9yaWVudGF0aW9uLmgiCiAjaW5jbHVkZSAiV2ViRGV2aWNlT3JpZW50 YXRpb25DbGllbnRNb2NrLmgiCiAjaW5jbHVkZSAiV2ViRG9jdW1lbnQuaCIKQEAgLTU4LDEyICs1 NiwxNSBAQAogI2luY2x1ZGUgIldlYlByaW50UGFyYW1zLmgiCiAjaW5jbHVkZSAiV2ViU2NyaXB0 U291cmNlLmgiCiAjaW5jbHVkZSAiV2ViU2VjdXJpdHlQb2xpY3kuaCIKLSNpbmNsdWRlICJwbGF0 Zm9ybS9XZWJTZXJpYWxpemVkU2NyaXB0VmFsdWUuaCIKICNpbmNsdWRlICJXZWJTZXR0aW5ncy5o IgotI2luY2x1ZGUgInBsYXRmb3JtL1dlYlNpemUuaCIKLSNpbmNsdWRlICJwbGF0Zm9ybS9XZWJV UkwuaCIKKyNpbmNsdWRlICJXZWJTdXJyb3VuZGluZ1RleHQuaCIKICNpbmNsdWRlICJXZWJWaWV3 LmgiCiAjaW5jbHVkZSAiV2ViVmlld0hvc3QuaCIKKyNpbmNsdWRlICJXZWJXb3JrZXJJbmZvLmgi CisjaW5jbHVkZSAicGxhdGZvcm0vV2ViRGF0YS5oIgorI2luY2x1ZGUgInBsYXRmb3JtL1dlYlNl cmlhbGl6ZWRTY3JpcHRWYWx1ZS5oIgorI2luY2x1ZGUgInBsYXRmb3JtL1dlYlNpemUuaCIKKyNp bmNsdWRlICJwbGF0Zm9ybS9XZWJVUkwuaCIKICNpbmNsdWRlICJ2OC9pbmNsdWRlL3Y4LmgiCiAj aW5jbHVkZSAid2Via2l0L3N1cHBvcnQvd2Via2l0X3N1cHBvcnQuaCIKICNpbmNsdWRlIDxhbGdv cml0aG0+CkBAIC03Miw4ICs3Myw4IEBACiAjaW5jbHVkZSA8Y3N0ZGxpYj4KICNpbmNsdWRlIDxs aW1pdHM+CiAjaW5jbHVkZSA8c3N0cmVhbT4KLSNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcu aD4KICNpbmNsdWRlIDx3dGYvT3duQXJyYXlQdHIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZT dHJpbmcuaD4KIAogI2lmIE9TKExJTlVYKSB8fCBPUyhBTkRST0lEKQogI2luY2x1ZGUgImxpbnV4 L1dlYkZvbnRSZW5kZXJpbmcuaCIKQEAgLTI3NSw3ICsyNzYsOCBAQCBMYXlvdXRUZXN0Q29udHJv bGxlcjo6TGF5b3V0VGVzdENvbnRyb2xsCiAgICAgYmluZE1ldGhvZCgic2V0Rml4ZWRMYXlvdXRT aXplIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZXRGaXhlZExheW91dFNpemUpOwogICAgIGJp bmRNZXRob2QoInNlbGVjdGlvbkFzTWFya3VwIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZWxl Y3Rpb25Bc01hcmt1cCk7CiAgICAgYmluZE1ldGhvZCgic2V0SGFzQ3VzdG9tRnVsbFNjcmVlbkJl aGF2aW9yIiwgJkxheW91dFRlc3RDb250cm9sbGVyOjpzZXRIYXNDdXN0b21GdWxsU2NyZWVuQmVo YXZpb3IpOwotICAgIAorICAgIGJpbmRNZXRob2QoInRleHRTdXJyb3VuZGluZ0VsZW1lbnQiLCAm TGF5b3V0VGVzdENvbnRyb2xsZXI6OnRleHRTdXJyb3VuZGluZ0VsZW1lbnQpOworCiAgICAgLy8g VGhlIGZhbGxiYWNrIG1ldGhvZCBpcyBjYWxsZWQgd2hlbiBhbiB1bmtub3duIG1ldGhvZCBpcyBp bnZva2VkLgogICAgIGJpbmRGYWxsYmFja01ldGhvZCgmTGF5b3V0VGVzdENvbnRyb2xsZXI6OmZh bGxiYWNrTWV0aG9kKTsKIApAQCAtMjM0MywzICsyMzQ1LDI4IEBAIHZvaWQgTGF5b3V0VGVzdENv bnRyb2xsZXI6OnNldFBvaW50ZXJMb2MKICAgICByZXN1bHQtPnNldE51bGwoKTsKIH0KICNlbmRp ZgorCit2b2lkIExheW91dFRlc3RDb250cm9sbGVyOjp0ZXh0U3Vycm91bmRpbmdFbGVtZW50KGNv bnN0IENwcEFyZ3VtZW50TGlzdCYgYXJndW1lbnRzLCBDcHBWYXJpYW50KiByZXN1bHQpCit7Cisg ICAgcmVzdWx0LT5zZXROdWxsKCk7CisgICAgaWYgKGFyZ3VtZW50cy5zaXplKCkgPCAzIHx8ICFh cmd1bWVudHNbMF0uaXNPYmplY3QoKSB8fCAhYXJndW1lbnRzWzFdLmlzTnVtYmVyKCkgfHwgIWFy Z3VtZW50c1syXS5pc051bWJlcigpKQorICAgICAgICByZXR1cm47CisKKyAgICBXZWJOb2RlIG5v ZGU7CisgICAgaWYgKCFXZWJCaW5kaW5nczo6Z2V0Tm9kZShhcmd1bWVudHNbMF0udmFsdWUub2Jq ZWN0VmFsdWUsICZub2RlKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKG5vZGUuaXNOdWxs KCkgfHwgIW5vZGUuaXNUZXh0Tm9kZSgpKQorICAgICAgICByZXR1cm47CisKKyAgICB1bnNpZ25l ZCBvZmZzZXQgPSBhcmd1bWVudHNbMV0udG9JbnQzMigpOworICAgIGlmIChvZmZzZXQgPj0gbm9k ZS5ub2RlVmFsdWUoKS5sZW5ndGgoKSkgeworICAgICAgICByZXN1bHQtPnNldChXZWJTdHJpbmco KS51dGY4KCkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgV2ViU3Vycm91bmRpbmdU ZXh0IHN1cnJvdW5kaW5nVGV4dDsKKyAgICB1bnNpZ25lZCBtYXhMZW5ndGggPSBhcmd1bWVudHNb Ml0udG9JbnQzMigpOworICAgIHN1cnJvdW5kaW5nVGV4dC5pbml0aWFsaXplKG5vZGUsIG9mZnNl dCwgbWF4TGVuZ3RoKTsKKyAgICByZXN1bHQtPnNldChzdXJyb3VuZGluZ1RleHQudGV4dENvbnRl bnQoKS51dGY4KCkpOworfQpJbmRleDogVG9vbHMvRHVtcFJlbmRlclRyZWUvY2hyb21pdW0vTGF5 b3V0VGVzdENvbnRyb2xsZXIuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBUb29scy9EdW1wUmVuZGVyVHJlZS9j aHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCShyZXZpc2lvbiAxMjE3MDUpCisrKyBUb29s cy9EdW1wUmVuZGVyVHJlZS9jaHJvbWl1bS9MYXlvdXRUZXN0Q29udHJvbGxlci5oCSh3b3JraW5n IGNvcHkpCkBAIC00NTYsNiArNDU2LDExIEBAIHB1YmxpYzoKICAgICAvLyBVc2VkIHRvIHNldCB0 aGUgZGV2aWNlIHNjYWxlIGZhY3Rvci4KICAgICB2b2lkIHNldEJhY2tpbmdTY2FsZUZhY3Rvcihj b25zdCBDcHBBcmd1bWVudExpc3QmLCBDcHBWYXJpYW50Kik7CiAKKyAgICAvLyBSZXRyaWV2ZXMg dGhlIHRleHQgc3Vycm91bmRpbmcgYSBwb3NpdGlvbiBpbiBhIHRleHQgbm9kZS4KKyAgICAvLyBU aGUgZmlyc3QgY2hpbGQgb2YgdGhlIGVsZW1lbnQgZ2l2ZW4geSBpdHMgaWQgd2lsbCBiZSB1c2Vk IGFzIHJlZmVyZW5jZSwKKyAgICAvLyBvciBpdHMgbmV4dCBzaWJsaW5nIGlmIG5vdCBwcmVzZW50 LiBJdCBtdXN0IGJlIGEgdGV4dCBub2RlLgorICAgIHZvaWQgdGV4dFN1cnJvdW5kaW5nRWxlbWVu dChjb25zdCBDcHBBcmd1bWVudExpc3QmLCBDcHBWYXJpYW50Kik7CisKIHB1YmxpYzoKICAgICAv LyBUaGUgZm9sbG93aW5nIG1ldGhvZHMgYXJlIG5vdCBleHBvc2VkIHRvIEphdmFTY3JpcHQuCiAg ICAgdm9pZCBzZXRXb3JrUXVldWVGcm96ZW4oYm9vbCBmcm96ZW4pIHsgbV93b3JrUXVldWUuc2V0 RnJvemVuKGZyb3plbik7IH0KSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDEyMTcwNSkKKysrIExheW91dFRl c3RzL0NoYW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDEyLTA3LTAy ICBMZWFuZHJvIEdyYWNpYSBHaWwgIDxsZWFuZHJvZ3JhY2lhQGNocm9taXVtLm9yZz4KKworICAg ICAgICBbQ2hyb21pdW1dIEltcGxlbWVudCBhIExheW91dCBUZXN0IGZvciBlZGl0aW5nL1N1cnJv dW5kaW5nVGV4dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9ODI0NjEKKworICAgICAgICBSZXZpZXdlZCBieSBSeW9zdWtlIE5pd2EuCisKKyAgICAgICAg QWRkIGEgbmV3IGxheW91dCB0ZXN0IGZvciB0aGUgc3Vycm91bmRpbmcgdGV4dCBmZWF0dXJlLgor CisgICAgICAgICogcGxhdGZvcm0vY2hyb21pdW0vZWRpdGluZy9zdXJyb3VuZGluZy10ZXh0L3N1 cnJvdW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9j aHJvbWl1bS9lZGl0aW5nL3N1cnJvdW5kaW5nLXRleHQvc3Vycm91bmRpbmctdGV4dC5odG1sOiBB ZGRlZC4KKwogMjAxMi0wNy0wMiAgQWRhbSBCYXJ0aCAgPGFiYXJ0aEB3ZWJraXQub3JnPgogCiAg ICAgICAgIEFub3RoZXIgY3Jhc2hpbmcgdGVzdCBvbiB0aGUgRVdTLiBXZSB0aGluayB0aGlzIGlz IGJlY2F1c2Ugb2YgdGhlIGZsYXNoCkluZGV4OiBMYXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1 bS9lZGl0aW5nL3N1cnJvdW5kaW5nLXRleHQvc3Vycm91bmRpbmctdGV4dC1leHBlY3RlZC50eHQK PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZWRpdGluZy9zdXJy b3VuZGluZy10ZXh0L3N1cnJvdW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQor KysgTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZWRpdGluZy9zdXJyb3VuZGluZy10ZXh0 L3N1cnJvdW5kaW5nLXRleHQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDIx IEBACitUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRoZSB0ZXh0IHN1cnJvdW5kaW5nIGFuIGVsZW1l bnQuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIHN1cnJvdW5kaW5nVGV4 dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAxMjM0NTwvcD42Nzg5 PGJ1dHRvbj4uPC9idXR0b24+JywgMCwgMTAwKSBpcyAiMTIzNDUgNjc4OSAxMjM0NSA2Nzg5Igor UEFTUyBzdXJyb3VuZGluZ1RleHQoJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUi PjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPicsIDUsIDYpIGlzICI4OSAxMjMi CitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVy ZSI+Njc4OSAxMjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgNSwgMCkgaXMgIiIKK1BB U1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42 Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA1LCAxKSBpcyAiMSIKK1BBU1Mg c3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj4xMjM0NTxwIGlkPSJoZXJlIj42Nzg5 IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj4nLCA2LCAyKSBpcyAiMTIiCitQQVNTIHN1 cnJvdW5kaW5nVGV4dCgnPGJ1dHRvbj4uPC9idXR0b24+MTIzNDU8cCBpZD0iaGVyZSI+Njc4OSAx MjM0NTwvcD42Nzg5PGJ1dHRvbj4uPC9idXR0b24+JywgMTAwLCA1KSBpcyAiIgorUEFTUyBzdXJy b3VuZGluZ1RleHQoJzxzZWxlY3Q+Ljwvc2VsZWN0PjxkaXY+NTd0aCBTdHJlZXQgYW5kIExha2Ug U2hvcmUgRHJpdmU8L2Rpdj4gPHNwYW4+Q2hpY2Fnbzwvc3Bhbj4gPHNwYW4gaWQ9ImhlcmUiPklM PC9zcGFuPiA8c3Bhbj42MDYzNzwvc3Bhbj48c2VsZWN0Pi48L3NlbGVjdD4nLCAwLCAxMDApIGlz ICI1N3RoIFN0cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZSBDaGljYWdvIElMIDYwNjM3IgorUEFT UyBzdXJyb3VuZGluZ1RleHQoJzxmaWVsZHNldD4uPC9maWVsZHNldD4xMjM0NTxidXR0b24+YWJj PC9idXR0b24+PHA+Njc4OTxiciBpZD0iaGVyZSIvPjEyMzQ1PC9wPjY3ODk8dGV4dGFyZWE+YWJj PC90ZXh0YXJlYT4wMTIzPGZpZWxkc2V0Pi48L2ZpZWxkc2V0PicsIDAsIDEwMCkgaXMgIjY3ODkg MTIzNDUgNjc4OSIKK1BBU1Mgc3Vycm91bmRpbmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2 IGlkPSJoZXJlIj5UaGlzIGlzIDwhLS0gY29tbWVudCAtLSE+YSB0ZXN0IDwnICsgJ3NjcmlwdCBs YW5ndWFnZT0iamF2YXNjcmlwdCI+PCcgKyAnL3NjcmlwdD5leGFtcGxlPGJ1dHRvbj4uPC9idXR0 b24+JywgMCwgMTAwKSBpcyAiVGhpcyBpcyBhIHRlc3QgZXhhbXBsZSIKK1BBU1Mgc3Vycm91bmRp bmdUZXh0KCc8YnV0dG9uPi48L2J1dHRvbj48ZGl2IGlkPSJoZXJlIj4wMTIzNDU2Nzg5MDEyMzQ1 Njc4OTAxMjM0NTY3ODk8L2Rpdj48YnV0dG9uPi48L2J1dHRvbj4nLCAxNSwgMTIpIGlzICI5MDEy MzQ1Njc4OTAiCitQQVNTIHN1cnJvdW5kaW5nVGV4dCgnPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8 YnV0dG9uIGlkPSJoZXJlIj50ZXN0PC9idXR0b24+PG9wdGlvbj4uPC9vcHRpb24+JywgMCwgMTAw KSBpcyAiIgorUEFTUyBzdXJyb3VuZGluZ1RleHQoJzxvcHRpb24+Ljwvb3B0aW9uPjEyMzQ1PGJ1 dHRvbj50ZTxzcGFuIGlkPSJoZXJlIj5zdDwvc3Bhbj48L2J1dHRvbj48b3B0aW9uPi48L29wdGlv bj4nLCAwLCAxMDApIGlzICIiCitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RF U1QgQ09NUExFVEUKKwpJbmRleDogTGF5b3V0VGVzdHMvcGxhdGZvcm0vY2hyb21pdW0vZWRpdGlu Zy9zdXJyb3VuZGluZy10ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbAo9PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBM YXlvdXRUZXN0cy9wbGF0Zm9ybS9jaHJvbWl1bS9lZGl0aW5nL3N1cnJvdW5kaW5nLXRleHQvc3Vy cm91bmRpbmctdGV4dC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvcGxhdGZvcm0v Y2hyb21pdW0vZWRpdGluZy9zdXJyb3VuZGluZy10ZXh0L3N1cnJvdW5kaW5nLXRleHQuaHRtbAko cmV2aXNpb24gMCkKQEAgLTAsMCArMSw1NCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxi b2R5PgorPHNjcmlwdCBzcmM9Ii4uLy4uLy4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qt cHJlLmpzIj48L3NjcmlwdD4KKzxkaXYgaWQ9InRlc3QiPgorPC9kaXY+Cis8cCBpZD0iZGVzY3Jp cHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdD4KK2Rlc2NyaXB0 aW9uKCdUZXN0IHRoZSBleHRyYWN0aW9uIG9mIHRoZSB0ZXh0IHN1cnJvdW5kaW5nIGFuIGVsZW1l bnQuJyk7CisKK2Z1bmN0aW9uIHN1cnJvdW5kaW5nVGV4dChodG1sLCBvZmZzZXQsIG1heExlbmd0 aCkgeworICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0JykuaW5uZXJIVE1MID0gaHRt bDsKKworICAgIHZhciBoZXJlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ2hlcmUnKTsKKyAg ICBpZiAoaGVyZSA9PSBudWxsKQorICAgICAgICB0aHJvdyAnVGVzdCBjYXNlIG5lZWRzIGFuIGVs ZW1lbnQgd2l0aCBpZCAiaGVyZSInOworCisgICAgdmFyIG5vZGUgPSBoZXJlLmhhc0NoaWxkTm9k ZXMoKSA/IGhlcmUuZmlyc3RDaGlsZCA6IGhlcmUubmV4dFNpYmxpbmc7CisgICAgaWYgKG5vZGUg PT0gbnVsbCkKKyAgICAgICAgdGhyb3cgJ05vIG5vZGUgYWZ0ZXIgImhlcmUiIGVsZW1lbnQnOwor CisgICAgdmFyIHRleHQgPSB3aW5kb3cudGVzdFJ1bm5lci50ZXh0U3Vycm91bmRpbmdFbGVtZW50 KG5vZGUsIG9mZnNldCwgbWF4TGVuZ3RoKTsKKyAgICByZXR1cm4gdGV4dC5yZXBsYWNlKC9ccysv ZywgJyAnKS5yZXBsYWNlKC9eXHMqfFxzKiQvZywgJycpOworfQorCitmdW5jdGlvbiBydW4oKSB7 CisgICAgaWYgKCF3aW5kb3cudGVzdFJ1bm5lcikKKyAgICAgICAgcmV0dXJuOworCisgICAgc2hv dWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4x MjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywg MCwgMTAwKScsICcxMjM0NSA2Nzg5IDEyMzQ1IDY3ODknKTsKKyAgICBzaG91bGRCZUVxdWFsVG9T dHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9Imhl cmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPlwnLCA1LCA2KScsICc4OSAx MjMnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxidXR0 b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4OTxidXR0b24+ LjwvYnV0dG9uPlwnLCA1LCAwKScsICcnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1 cnJvdW5kaW5nVGV4dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkg MTIzNDU8L3A+Njc4OTxidXR0b24+LjwvYnV0dG9uPlwnLCA1LCAxKScsICcxJyk7CisgICAgc2hv dWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1dHRvbj4x MjM0NTxwIGlkPSJoZXJlIj42Nzg5IDEyMzQ1PC9wPjY3ODk8YnV0dG9uPi48L2J1dHRvbj5cJywg NiwgMiknLCAnMTInKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4 dChcJzxidXR0b24+LjwvYnV0dG9uPjEyMzQ1PHAgaWQ9ImhlcmUiPjY3ODkgMTIzNDU8L3A+Njc4 OTxidXR0b24+LjwvYnV0dG9uPlwnLCAxMDAsIDUpJywgJycpOworICAgIHNob3VsZEJlRXF1YWxU b1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPHNlbGVjdD4uPC9zZWxlY3Q+PGRpdj41N3RoIFN0 cmVldCBhbmQgTGFrZSBTaG9yZSBEcml2ZTwvZGl2PiA8c3Bhbj5DaGljYWdvPC9zcGFuPiA8c3Bh biBpZD0iaGVyZSI+SUw8L3NwYW4+IDxzcGFuPjYwNjM3PC9zcGFuPjxzZWxlY3Q+Ljwvc2VsZWN0 PlwnLCAwLCAxMDApJywgJzU3dGggU3RyZWV0IGFuZCBMYWtlIFNob3JlIERyaXZlIENoaWNhZ28g SUwgNjA2MzcnKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChc JzxmaWVsZHNldD4uPC9maWVsZHNldD4xMjM0NTxidXR0b24+YWJjPC9idXR0b24+PHA+Njc4OTxi ciBpZD0iaGVyZSIvPjEyMzQ1PC9wPjY3ODk8dGV4dGFyZWE+YWJjPC90ZXh0YXJlYT4wMTIzPGZp ZWxkc2V0Pi48L2ZpZWxkc2V0PlwnLCAwLCAxMDApJywgJzY3ODkgMTIzNDUgNjc4OScpOworICAg IHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0KFwnPGJ1dHRvbj4uPC9idXR0 b24+PGRpdiBpZD0iaGVyZSI+VGhpcyBpcyA8IS0tIGNvbW1lbnQgLS0hPmEgdGVzdCA8XCcgKyBc J3NjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCI+PFwnICsgXCcvc2NyaXB0PmV4YW1wbGU8YnV0 dG9uPi48L2J1dHRvbj5cJywgMCwgMTAwKScsICdUaGlzIGlzIGEgdGVzdCBleGFtcGxlJyk7Cisg ICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCdzdXJyb3VuZGluZ1RleHQoXCc8YnV0dG9uPi48L2J1 dHRvbj48ZGl2IGlkPSJoZXJlIj4wMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODk8L2Rpdj48 YnV0dG9uPi48L2J1dHRvbj5cJywgMTUsIDEyKScsICc5MDEyMzQ1Njc4OTAnKTsKKyAgICBzaG91 bGRCZUVxdWFsVG9TdHJpbmcoJ3N1cnJvdW5kaW5nVGV4dChcJzxvcHRpb24+Ljwvb3B0aW9uPjEy MzQ1PGJ1dHRvbiBpZD0iaGVyZSI+dGVzdDwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0aW9uPlwnLCAw LCAxMDApJywgJycpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygnc3Vycm91bmRpbmdUZXh0 KFwnPG9wdGlvbj4uPC9vcHRpb24+MTIzNDU8YnV0dG9uPnRlPHNwYW4gaWQ9ImhlcmUiPnN0PC9z cGFuPjwvYnV0dG9uPjxvcHRpb24+Ljwvb3B0aW9uPlwnLCAwLCAxMDApJywgJycpOworCisgICAg ZG9jdW1lbnQuYm9keS5yZW1vdmVDaGlsZChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgndGVzdCcp KTsKKyAgICBmaW5pc2hKU1Rlc3QoKTsKK30KKword2luZG93Lm9ubG9hZCA9IHJ1bjsKK3dpbmRv dy5qc1Rlc3RJc0FzeW5jID0gdHJ1ZTsKK3dpbmRvdy5zdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVl OworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMv anMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K