136883 2014-09-17 01:58:58 -0700 Changes in the stretchy attribute do not update rendering 2014-10-14 02:55:46 -0700 1 1 1 Unclassified WebKit MathML 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 alex alex cfleizach commit-queue darin dbarton esprehn+autocc fred.wang glenn kondapallykalyan mrobinson oldest_to_newest 1035688 0 238242 alex 2014-09-17 01:58:58 -0700 Created attachment 238242 Test showing the problem If uploaded a test to explain when this happend, in the test the operator should be stretched eventually. 1035690 1 238244 alex 2014-09-17 02:05:33 -0700 Created attachment 238244 Patch 1036167 2 238244 darin 2014-09-19 11:26:06 -0700 Comment on attachment 238244 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238244&action=review > Source/WebCore/mathml/MathMLElement.cpp:302 > + if (renderer() && (name == MathMLNames::stretchyAttr) && !equalIgnoringCase(oldValue, newValue)) > + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); This is a very unusual idiom. Do we have anything like this in any other element in WebKit? Also, it’s surprising to see this in the base MathML element. Is stretchy supported in every single specific MathML element? 1036169 3 238244 darin 2014-09-19 11:26:50 -0700 Comment on attachment 238244 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238244&action=review >> Source/WebCore/mathml/MathMLElement.cpp:302 >> + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); > > This is a very unusual idiom. Do we have anything like this in any other element in WebKit? > > Also, it’s surprising to see this in the base MathML element. Is stretchy supported in every single specific MathML element? We also would want to trigger the work based on a change in the parsed value, not based on a change in the string. For example, there are many ways to specify an invalid value and they should all be considered equal, not distinct. 1036186 4 alex 2014-09-19 12:42:32 -0700 (In reply to comment #2) > (From update of attachment 238244 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=238244&action=review > > > Source/WebCore/mathml/MathMLElement.cpp:302 > > + if (renderer() && (name == MathMLNames::stretchyAttr) && !equalIgnoringCase(oldValue, newValue)) > > + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); > > This is a very unusual idiom. Do we have anything like this in any other element in WebKit? > It is unusual, you are right, you just can find in HTMLTextAreaElement parseAttribute a call to setNeedsLayoutAndPrefWidthsRecalc when rowsAttr changes. I guess it means an attribute that modifies something visual that is not represented using a CSS property, I've seen MathML unfortunately uses a lot of style definition itself. Wrt to use parseAttribute or attributeChanged I decided using attributeChanged because we can check old and new value without creating a new attribute in the object. But your next comment explains clearly why a parsed and stored value is the right option. > Also, it’s surprising to see this in the base MathML element. Is stretchy supported in every single specific MathML element? It is just the mo tag, operator, you are right, when I checked the tags file I missed the MathMLTextElement which is the one representing it. Thanks for the review, I'll modify and update accordingly. 1036187 5 alex 2014-09-19 12:45:50 -0700 (In reply to comment #3) > We also would want to trigger the work based on a change in the parsed value, not based on a change in the string. For example, there are many ways to specify an invalid value and they should all be considered equal, not distinct. Very good point, I think storing the parsed value in an attribute using parseAttribute and checking the change of that value to request the relayout would be a better option. Thanks again for the advise. 1036342 6 238244 darin 2014-09-21 10:07:56 -0700 Comment on attachment 238244 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238244&action=review >>>> Source/WebCore/mathml/MathMLElement.cpp:302 >>>> + renderer()->setNeedsLayoutAndPrefWidthsRecalc(); >>> >>> This is a very unusual idiom. Do we have anything like this in any other element in WebKit? >>> >>> Also, it’s surprising to see this in the base MathML element. Is stretchy supported in every single specific MathML element? >> >> We also would want to trigger the work based on a change in the parsed value, not based on a change in the string. For example, there are many ways to specify an invalid value and they should all be considered equal, not distinct. > > It is unusual, you are right, you just can find in HTMLTextAreaElement parseAttribute a call to setNeedsLayoutAndPrefWidthsRecalc when rowsAttr changes. I guess it means an attribute that modifies something visual that is not represented using a CSS property, I've seen MathML unfortunately uses a lot of style definition itself. > > Wrt to use parseAttribute or attributeChanged I decided using attributeChanged because we can check old and new value without creating a new attribute in the object. But your next comment explains clearly why a parsed and stored value is the right option. Somehow we need to share the logic appropriately with RenderMathMLOperator, which is the code that actually parses the stretch attribute. 1037896 7 238845 alex 2014-09-29 02:15:29 -0700 Created attachment 238845 Patch 1037897 8 alex 2014-09-29 02:17:37 -0700 (In reply to comment #6) > Somehow we need to share the logic appropriately with RenderMathMLOperator, which is the code that actually parses the stretch attribute. Right, just implemented it using the parsing from the RenderMathMLOperator with this last patch. Thanks for the comments. 1037963 9 238845 darin 2014-09-29 09:41:08 -0700 Comment on attachment 238845 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238845&action=review Looks good. review- because of the bad cast > Source/WebCore/mathml/MathMLTextElement.cpp:69 > + if ((name == stretchyAttr) && renderer()) Don’t need the parentheses here. This is a common enough idiom and we don’t use the parentheses everywhere else. I understand that sometimes parentheses make operator precedence clearer, but == vs. && shows up so often that it doesn’t require the extra emphasis. > Source/WebCore/mathml/MathMLTextElement.cpp:70 > + toRenderMathMLOperator(renderer())->setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Stretchy, value, true); What guarantees the renderer is a RenderMathMLOperator? The createElementRenderer function creates objects of many different types; if this isn’t a RenderMathMLOperator then this will be a bad cast. > Source/WebCore/mathml/MathMLTextElement.cpp:72 > + else > + MathMLElement::parseAttribute(name, value); I don’t think this needs to be an else. I think we should call through to the base class parseAttribute even if we do the setOperatorFlagFromAttributeValue work. > Source/WebCore/mathml/MathMLTextElement.h:43 > +protected: > + virtual void parseAttribute(const QualifiedName&, const AtomicString&) override; Why protected instead of private? I don’t see any classes that derive from this one. I also suggest we mark this class final for the same reason. > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1181 > + const AtomicString& attributeValue = element().fastGetAttribute(name); > + > + setOperatorFlagFromAttributeValue(flag, attributeValue); This code would read better without the local variable. > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:81 > + void setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Flag, const AtomicString&, bool doLayoutIfNeeded = false); I think we might need the name "attributeValue" or "value" for the AtomicString argument. It’s not entirely clear what that argument is from the type alone. We try to avoid using booleans for these kinds of arguments where you pass a constant, because “true” is not clear at the call site. Instead we normally use enums or two separate functions for something like this. In this case, I think we should have two separate functions, an inner one that does not do setNeedsLayoutAndPrefWidthsRecalc and an outer one that does. I’m not sure that the right name for that is “layout”. It’s easy for the outer function to get the operator flags before and after; it can just call the inner function. 1037974 10 alex 2014-09-29 10:13:37 -0700 Thanks for the comments :). I'll review accordingly, just some comments inlined to explain some of the rationale of the original patch. (In reply to comment #9) > > Source/WebCore/mathml/MathMLTextElement.cpp:70 > > + toRenderMathMLOperator(renderer())->setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Stretchy, value, true); > > What guarantees the renderer is a RenderMathMLOperator? The createElementRenderer function creates objects of many different types; if this isn’t a RenderMathMLOperator then this will be a bad cast. > I was thinking about adding the condition but assumed if we are parsing the stretchy attribute we are checking a RenderMathMLOperator, I mean if (name == stretchyAttr) is true, and because operator is the only one that accepts stretchyAttr this is a RenderMathMLOperator. It is true this is my supposition about how the parseAttribute is being called. I'll add the condition because it is even clearer for the code. > > Source/WebCore/mathml/MathMLTextElement.cpp:72 > > + else > > + MathMLElement::parseAttribute(name, value); > > I don’t think this needs to be an else. I think we should call through to the base class parseAttribute even if we do the setOperatorFlagFromAttributeValue work. > My understanding to use the else was that no other class is parsing this attribute so we can avoid the call in that case. > > Source/WebCore/mathml/MathMLTextElement.h:43 > > +protected: > > + virtual void parseAttribute(const QualifiedName&, const AtomicString&) override; > > Why protected instead of private? I don’t see any classes that derive from this one. I also suggest we mark this class final for the same reason. > No good reason for this, I'll do it. > > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1181 > > + const AtomicString& attributeValue = element().fastGetAttribute(name); > > + > > + setOperatorFlagFromAttributeValue(flag, attributeValue); > > This code would read better without the local variable. > I agree. > > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:81 > > + void setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Flag, const AtomicString&, bool doLayoutIfNeeded = false); > > I think we might need the name "attributeValue" or "value" for the AtomicString argument. It’s not entirely clear what that argument is from the type alone. > > We try to avoid using booleans for these kinds of arguments where you pass a constant, because “true” is not clear at the call site. Instead we normally use enums or two separate functions for something like this. In this case, I think we should have two separate functions, an inner one that does not do setNeedsLayoutAndPrefWidthsRecalc and an outer one that does. I’m not sure that the right name for that is “layout”. It’s easy for the outer function to get the operator flags before and after; it can just call the inner function. It is interesting because I was trying both options, with two functions or with the attribute, this seemed to me a better approach even without the enum but it is true both were quite similar. I'll reimplement with the two functions now that you point out that solution. Thanks again for the detailed comments :). 1038183 11 238919 alex 2014-09-30 03:17:49 -0700 Created attachment 238919 Patch I've added the proposed modifications. 1039214 12 darin 2014-10-03 08:50:53 -0700 (In reply to comment #10) > I was thinking about adding the condition but assumed if we are parsing the stretchy attribute we are checking a RenderMathMLOperator, I mean if (name == stretchyAttr) is true, and because operator is the only one that accepts stretchyAttr this is a RenderMathMLOperator. It is true this is my supposition about how the parseAttribute is being called. I'll add the condition because it is even clearer for the code. A side note: You don’t have to guess about this. You can test by creating the element which would use a different kind of renderer and adding a stretchy attribute (which should be ignored). Then you will see that this code gets called in cases where this would be a bad cast, or provide that it doesn’t. > > > Source/WebCore/mathml/MathMLTextElement.cpp:72 > > > + else > > > + MathMLElement::parseAttribute(name, value); > > > > I don’t think this needs to be an else. I think we should call through to the base class parseAttribute even if we do the setOperatorFlagFromAttributeValue work. > > > > My understanding to use the else was that no other class is parsing this attribute so we can avoid the call in that case. We are inconsistent about this. Some classes call through to the base class even though the base class does nothing. HTMLElement::parseAttribute is an example of this. In other cases, the derived classes don’t call through because they know the base class won’t do anything with a particular attribute. The best argument for calling through is robustness as we change what attributes are handled over time. The best argument for not calling through is slightly better performance by skipping unneeded code. Given that, we should not call through to the base class for stretchyAttr unconditionally, regardless of the state of the renderer. 1039218 13 238919 darin 2014-10-03 09:02:26 -0700 Comment on attachment 238919 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=238919&action=review I’m going to say review+ although it’s not good to have a bug fix here (case sensitivity on true and false) with no test coverage. > LayoutTests/mathml/presentation/mo-stretch-update.html:14 > + if (window.testRunner) { > + testRunner.waitUntilDone(); > + } No need for braces here. > LayoutTests/mathml/presentation/mo-stretch-update.html:19 > + window.setTimeout(function() No need for "window." here. > LayoutTests/mathml/presentation/mo-stretch-update.html:26 > + window.addEventListener('load', updatePageAfterRendering, false); No need for "window." here. > Source/WebCore/mathml/MathMLTextElement.cpp:70 > + if (name == stretchyAttr && renderer() && renderer()->isRenderMathMLOperator()) > + toRenderMathMLOperator(renderer())->setOperatorFlagAndScheduleLayoutIfNeeded(MathMLOperatorDictionary::Stretchy, value); Given our conversation about not calling through, this could also be: if (name == stretchyAttr) { if (renderer() && renderer()->isRenderMathMLOperator()) toRenderMathMLOperator(renderer())->setOperatorFlagAndScheduleLayoutIfNeeded(MathMLOperatorDictionary::Stretchy, value); return; } But it’s also fine the way you have it. > Source/WebCore/mathml/MathMLTextElement.h:49 > + virtual void parseAttribute(const QualifiedName&, const AtomicString&) final; This needs to be marked override. This *class* should be marked final. Then we would not bother marking this particular function final, since all functions would be final. > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1179 > + if (equalIgnoringCase(attributeValue, "true")) Good bug fix. But no test coverage for this! > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1181 > + else if (equalIgnoringCase(attributeValue, "false")) Good bug fix. But no test coverage for this! > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:83 > protected: Almost everything below this point should be private rather than protected. Things can be protected if they need to be used in RenderMathMLRadicalOperator, but as much as possible should be private instead for better understanding of the class and easier refactoring later. > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:188 > void setOperatorFlagFromAttribute(MathMLOperatorDictionary::Flag, const QualifiedName&); As with most everything above, this should be private rather than protected. Also, function members should typically appear before data members in the class definition, which typically are listed all at the end. It’s peculiar to have this paragraph of four functions at the bottom after the data members. Not caused by the new patch, but could be better. > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:189 > + void setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Flag, const AtomicString& attributeValue); This new function should be private rather than protected. > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:191 > virtual void SetOperatorProperties(); Incorrect capitalization. Not related to this patch, but not right either. 1039223 14 fred.wang 2014-10-03 09:10:07 -0700 > > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1179 > > + if (equalIgnoringCase(attributeValue, "true")) > > Good bug fix. But no test coverage for this! > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1181 > > + else if (equalIgnoringCase(attributeValue, "false")) > > Good bug fix. But no test coverage for this! > mmmh, AFAIK the attributes in MathML are case-sensitive. From http://www.w3.org/TR/MathML3/chapter2.html, "Note that the color name keywords are not case-sensitive, unlike most keywords in MathML attribute values, for compatibility with CSS and HTML.". Check the RelaxNG schema to be sure. 1039237 15 alex 2014-10-03 09:47:18 -0700 Thanks for the review, I'll review and commit with the changes pointed out. Regarding the case sensitiveness I'll check Fred comments with the RelaxNG file, and change accordingly. I'll create a the test case in a different bug to check that for the future. 1039240 16 alex 2014-10-03 09:53:08 -0700 (In reply to comment #14) > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1179 > > > + if (equalIgnoringCase(attributeValue, "true")) > > > > Good bug fix. But no test coverage for this! > > > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.cpp:1181 > > > + else if (equalIgnoringCase(attributeValue, "false")) > > > > Good bug fix. But no test coverage for this! > > > > mmmh, AFAIK the attributes in MathML are case-sensitive. From http://www.w3.org/TR/MathML3/chapter2.html, "Note that the color name keywords are not case-sensitive, unlike most keywords in MathML attribute values, for compatibility with CSS and HTML.". Check the RelaxNG schema to be sure. You are right, thanks for the comments Fred. The case of the stretchy for instance is: http://www.w3.org/Math/RelaxNG/mathml3/mathml3-presentation.rng ... <attribute name="stretchy"> <choice> <value>true</value> <value>false</value> </choice> </attribute> ... I'll remove that part of the patch and upload a test case for that in a different bug to avoid future problems. 1040909 17 alex 2014-10-10 07:46:03 -0700 (In reply to comment #13) > (From update of attachment 238919 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=238919&action=review > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:83 > > protected: > > Almost everything below this point should be private rather than protected. Things can be protected if they need to be used in RenderMathMLRadicalOperator, but as much as possible should be private instead for better understanding of the class and easier refactoring later. > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:188 > > void setOperatorFlagFromAttribute(MathMLOperatorDictionary::Flag, const QualifiedName&); > > As with most everything above, this should be private rather than protected. > > Also, function members should typically appear before data members in the class definition, which typically are listed all at the end. It’s peculiar to have this paragraph of four functions at the bottom after the data members. Not caused by the new patch, but could be better. > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:189 > > + void setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Flag, const AtomicString& attributeValue); > > This new function should be private rather than protected. > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:191 > > virtual void SetOperatorProperties(); > > Incorrect capitalization. Not related to this patch, but not right either. I've uploaded a followed-up patch fixing these style problems to the bug #137611. 1040910 18 alex 2014-10-10 07:48:16 -0700 (In reply to comment #16) > > The case of the stretchy for instance is: > > http://www.w3.org/Math/RelaxNG/mathml3/mathml3-presentation.rng > > ... > <attribute name="stretchy"> > <choice> > <value>true</value> > <value>false</value> > </choice> > </attribute> > ... > > I'll remove that part of the patch and upload a test case for that in a different bug to avoid future problems. I've uploaded a test to a followed-up bug #137602. 1040911 19 239625 alex 2014-10-10 07:56:40 -0700 Created attachment 239625 Patch Updated the patch with the suggestions and replacing the toRender* with the new dowcast. Too many changes so I'd rather ask for a final rubberstamp. 1040931 20 239625 darin 2014-10-10 09:36:54 -0700 Comment on attachment 239625 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=239625&action=review > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:190 > + void setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Flag, const AtomicString& attributeValue); Should be private rather than protected. 1041515 21 alex 2014-10-14 02:48:49 -0700 (In reply to comment #20) > (From update of attachment 239625 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=239625&action=review > > > Source/WebCore/rendering/mathml/RenderMathMLOperator.h:190 > > + void setOperatorFlagFromAttributeValue(MathMLOperatorDictionary::Flag, const AtomicString& attributeValue); > > Should be private rather than protected. Yep, when splitting the patch I added this change to the patch in bug #137611, because there is no private section now. 1041517 22 alex 2014-10-14 02:55:20 -0700 Landed http://trac.webkit.org/changeset/174677 Thanks for the help. 238242 2014-09-17 01:58:58 -0700 2014-09-17 01:58:58 -0700 Test showing the problem mo-stretch-update.html text/html 676 alex PCFET0NUWVBFIGh0bWw+CjxodG1sPgo8Ym9keT4KICAgIDxtYXRoPgogICAgICAgIDxtcm93Pgog ICAgICAgICAgICA8bW8gaWQ9InRlc3QxIiBzdHJldGNoeT0iZmFsc2UiPiZJbnRlZ3JhbDs8L21v PgogICAgICAgICAgICA8bXNwYWNlIGhlaWdodD0iNzVweCIgZGVwdGg9IjFweCIvPgogICAgICAg IDwvbXJvdz4KICAgIDwvbWF0aD4KCiAgICA8c2NyaXB0PgogICAgICAgIGlmICh3aW5kb3cudGVz dFJ1bm5lcikgewogICAgICAgICAgICB0ZXN0UnVubmVyLndhaXRVbnRpbERvbmUoKTsKICAgICAg ICB9CgoKICAgICAgICBmdW5jdGlvbiB1cGRhdGVQYWdlQWZ0ZXJSZW5kZXJpbmcoKQogICAgICAg IHsKICAgICAgICAgICAgd2luZG93LnNldFRpbWVvdXQoZnVuY3Rpb24oKQogICAgICAgICAgICAg ICAgewogICAgICAgICAgICAgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJ0ZXN0MSIp LnNldEF0dHJpYnV0ZSgic3RyZXRjaHkiLCAidHJ1ZSIpOwogICAgICAgICAgICAgICAgICAgIHRl c3RSdW5uZXIubm90aWZ5RG9uZSgpOwogICAgICAgICAgICAgICAgfSwgNTApOwogICAgICAgIH0K CiAgICAgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ2xvYWQnLCB1cGRhdGVQYWdlQWZ0ZXJS ZW5kZXJpbmcsIGZhbHNlKTsKCiAgICA8L3NjcmlwdD4KPC9ib2R5Pgo8L2h0bWw+Cg== 238244 2014-09-17 02:05:33 -0700 2014-09-29 02:15:22 -0700 Patch bug-136883-20140917110529.patch text/plain 4017 alex U3VidmVyc2lvbiBSZXZpc2lvbjogMTczNTEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTZjYzUxNjI3YzZmZTky MzMyN2E1NTAxYWM4Nzc3N2JlM2YxYjlkNC4uNDQwYTdhYWFhOGZkMDc4MTVhYjc5YWE0NWRiMzNi YzM4ZGU4MmIxZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDE0LTA5LTE2ICBBbGVq YW5kcm8gRy4gQ2FzdHJvICA8YWxleEBpZ2FsaWEuY29tPgorCisgICAgICAgIENoYW5nZXMgaW4g dGhlIHN0cmV0Y2h5IGF0dHJpYnV0ZSBkbyBub3QgdXBkYXRlIHJlbmRlcmluZworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM2ODgzCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogbWF0aG1sL3ByZXNl bnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sCisKKyAgICAgICAgV2UgbmVlZCB0byByZWxh eW91dCB3aGVuIGEgY2hhbmdlIGluIHRoZSBzdHJldGNoeSBhdHRyaWJ1dGUKKyAgICAgICAgaGFw cGVucy4KKworICAgICAgICAqIG1hdGhtbC9NYXRoTUxFbGVtZW50LmNwcDoKKyAgICAgICAgKFdl YkNvcmU6Ok1hdGhNTEVsZW1lbnQ6OmF0dHJpYnV0ZUNoYW5nZWQpOgorCiAyMDE0LTA5LTExICBD YXJsb3MgR2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBbR1RL XSBNZXJnZSBXZWJLaXRBdXRoZW50aWNhdGlvbldpZGdldCBpbnRvIFdlYktpdEF1dGhlbnRpY2F0 aW9uRGlhbG9nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MRWxlbWVu dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MRWxlbWVudC5jcHAKaW5kZXggMTgz MDk5NDYyM2M4MjA0YzI1MWQ3OTM1ZjU4YWQ4MTJhZTFhZjdhZS4uYmE0ZjBhMjMyZWEwNjY0YTY0 NDhlZDJhNjM2ZGQ3NDA4ZjEyOGE4OCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbWF0aG1s L01hdGhNTEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxFbGVt ZW50LmNwcApAQCAtMjk3LDYgKzI5NywxMCBAQCB2b2lkIE1hdGhNTEVsZW1lbnQ6OmF0dHJpYnV0 ZUNoYW5nZWQoY29uc3QgUXVhbGlmaWVkTmFtZSYgbmFtZSwgY29uc3QgQXRvbWljU3RyaQogICAg ICAgICBpZiAocGFyZW50ICYmIHBhcmVudC0+aXNNYXRoTUxFbGVtZW50KCkgJiYgcGFyZW50LT5o YXNUYWdOYW1lKHNlbWFudGljc1RhZykpCiAgICAgICAgICAgICB0b01hdGhNTEVsZW1lbnQocGFy ZW50KS0+dXBkYXRlU2VsZWN0ZWRDaGlsZCgpOwogICAgIH0KKworICAgIGlmIChyZW5kZXJlcigp ICYmIChuYW1lID09IE1hdGhNTE5hbWVzOjpzdHJldGNoeUF0dHIpICYmICFlcXVhbElnbm9yaW5n Q2FzZShvbGRWYWx1ZSwgbmV3VmFsdWUpKQorICAgICAgICByZW5kZXJlcigpLT5zZXROZWVkc0xh eW91dEFuZFByZWZXaWR0aHNSZWNhbGMoKTsKKwogICAgIFN0eWxlZEVsZW1lbnQ6OmF0dHJpYnV0 ZUNoYW5nZWQobmFtZSwgb2xkVmFsdWUsIG5ld1ZhbHVlLCByZWFzb24pOwogfQogCmRpZmYgLS1n aXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXgg ZTlmMmQwZjcxNGJkNzUwZWJlM2UyNDZlMmUzZTNhYWE0MWJlNTE2MS4uYzE5YmMyN2IwNDFmMTgy ODg4YjAyNWExZmU0MmE1MTg1NTgzODkyMSAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDE0LTA5 LTE2ICBBbGVqYW5kcm8gRy4gQ2FzdHJvICA8YWxleEBpZ2FsaWEuY29tPgorCisgICAgICAgIENo YW5nZXMgaW4gdGhlIHN0cmV0Y2h5IGF0dHJpYnV0ZSBkbyBub3QgdXBkYXRlIHJlbmRlcmluZwor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM2ODgzCisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGhlIHRlc3Qg dXBkYXRlcyB0aGUgc3RyZXRjaHkgdmFsdWUgaW4gYSB0aW1lb3V0LgorCisgICAgICAgICogbWF0 aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS1leHBlY3RlZC5odG1sOiBBZGRlZC4K KyAgICAgICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLmh0bWw6IEFk ZGVkLgorCiAyMDE0LTA5LTEwICBKZXIgTm9ibGUgIDxqZXIubm9ibGVAYXBwbGUuY29tPgogCiAg ICAgICAgIFVucmV2aWV3ZWQgZ2FyZGVuaW5nLiBSZWJhc2VsaW5lIGZhaWxpbmcgbWVkaWEvdmlk ZW8tIHRlc3RzIGJyb2tlbiBieSByMTU2NTQ2LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbWF0 aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS1leHBlY3RlZC5odG1sIGIvTGF5b3V0 VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS1leHBlY3RlZC5odG1s Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAuLjQ2YmQwNzRjYWU4M2RjZmM1ZGY2YTYwNGNkYTVlOGNiNGQ0MTgxYzMKLS0t IC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9tYXRobWwvcHJlc2VudGF0aW9uL21vLXN0cmV0 Y2gtdXBkYXRlLWV4cGVjdGVkLmh0bWwKQEAgLTAsMCArMSwxMSBAQAorPCFET0NUWVBFIGh0bWw+ Cis8aHRtbD4KKzxib2R5PgorICAgIDxtYXRoPgorICAgICAgICA8bXJvdz4KKyAgICAgICAgICAg IDxtbyBzdHJldGNoeT0idHJ1ZSI+JkludGVncmFsOzwvbW8+CisgICAgICAgICAgICA8bXNwYWNl IGhlaWdodD0iNzVweCIgZGVwdGg9IjFweCIvPgorICAgICAgICA8L21yb3c+CisgICAgPC9tYXRo PgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvbWF0aG1sL3ByZXNl bnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sIGIvTGF5b3V0VGVzdHMvbWF0aG1sL3ByZXNl bnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjQ2NzQ0YzQ1Y2M3M2M1 YmZkMGQxZmE2ZjQzMWI1ZGU2ZjU2NWM3ZGEKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9tYXRobWwvcHJlc2VudGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLmh0bWwKQEAgLTAsMCArMSwz MCBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5PgorICAgIDxtYXRoPgorICAgICAg ICA8bXJvdz4KKyAgICAgICAgICAgIDxtbyBpZD0idGVzdDEiIHN0cmV0Y2h5PSJmYWxzZSI+Jklu dGVncmFsOzwvbW8+CisgICAgICAgICAgICA8bXNwYWNlIGhlaWdodD0iNzVweCIgZGVwdGg9IjFw eCIvPgorICAgICAgICA8L21yb3c+CisgICAgPC9tYXRoPgorCisgICAgPHNjcmlwdD4KKyAgICAg ICAgaWYgKHdpbmRvdy50ZXN0UnVubmVyKSB7CisgICAgICAgICAgICB0ZXN0UnVubmVyLndhaXRV bnRpbERvbmUoKTsKKyAgICAgICAgfQorCisKKyAgICAgICAgZnVuY3Rpb24gdXBkYXRlUGFnZUFm dGVyUmVuZGVyaW5nKCkKKyAgICAgICAgeworICAgICAgICAgICAgd2luZG93LnNldFRpbWVvdXQo ZnVuY3Rpb24oKQorICAgICAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudEJ5SWQoInRlc3QxIikuc2V0QXR0cmlidXRlKCJzdHJldGNoeSIsICJ0cnVl Iik7CisgICAgICAgICAgICAgICAgICAgIHRlc3RSdW5uZXIubm90aWZ5RG9uZSgpOworICAgICAg ICAgICAgICAgIH0sIDUwKTsKKyAgICAgICAgfQorCisgICAgICAgIHdpbmRvdy5hZGRFdmVudExp c3RlbmVyKCdsb2FkJywgdXBkYXRlUGFnZUFmdGVyUmVuZGVyaW5nLCBmYWxzZSk7CisKKyAgICA8 L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4K 238845 2014-09-29 02:15:29 -0700 2014-09-30 03:17:49 -0700 Patch bug-136883-20140929111528.patch text/plain 7780 alex U3VidmVyc2lvbiBSZXZpc2lvbjogMTczNTEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTZjYzUxNjI3YzZmZTky MzMyN2E1NTAxYWM4Nzc3N2JlM2YxYjlkNC4uZDBlOGIzYmI1YjUwZDI3ZTdjYTk2NzRiYmY4YmNl NTg3NmE3ZmRhNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI2IEBACisyMDE0LTA5LTI5ICBBbGVq YW5kcm8gRy4gQ2FzdHJvICA8YWxleEBpZ2FsaWEuY29tPgorCisgICAgICAgIENoYW5nZXMgaW4g dGhlIHN0cmV0Y2h5IGF0dHJpYnV0ZSBkbyBub3QgdXBkYXRlIHJlbmRlcmluZworICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM2ODgzCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgVGVzdDogbWF0aG1sL3ByZXNl bnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sCisKKyAgICAgICAgV2UgbmVlZCB0byByZWxh eW91dCB3aGVuIGEgY2hhbmdlIGluIHRoZSBzdHJldGNoeSBhdHRyaWJ1dGUKKyAgICAgICAgaGFw cGVucy4KKworICAgICAgICAqIG1hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpNYXRoTUxUZXh0RWxlbWVudDo6cGFyc2VBdHRyaWJ1dGUpOiBwYXJzZSB0aGUK KyAgICAgICAgbW9kaWZpY2F0aW9ucyBvZiB0aGUgc3RyZXRjaHkgYXR0cmlidXRlLgorICAgICAg ICAqIG1hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5oOgorICAgICAgICAqIHJlbmRlcmluZy9tYXRo bWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTWF0 aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGVWYWx1ZSk6CisgICAgICAg IEFkZCBmdW5jdGlvbiB0aGF0IHJlY2VpdmVzIHRoZSB2YWx1ZSBpbnN0ZWFkIG9mIGxvb2tpbmcg Zm9yIGl0IGFuZAorICAgICAgICBjaGVjayBpZiB0aGUgY2hhbmdlIGNhbiBjYXVzZSBhIGxheW91 dC4KKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlck1hdGhNTE9wZXJhdG9yOjpzZXRPcGVyYXRvckZs YWdGcm9tQXR0cmlidXRlKToKKyAgICAgICAgKiByZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhN TE9wZXJhdG9yLmg6CisKIDIwMTQtMDktMTEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNp YUBpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIE1lcmdlIFdlYktpdEF1dGhlbnRpY2F0aW9u V2lkZ2V0IGludG8gV2ViS2l0QXV0aGVudGljYXRpb25EaWFsb2cKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9t YXRobWwvTWF0aE1MVGV4dEVsZW1lbnQuY3BwCmluZGV4IDIyMzgzYzAzNzY2OWI1YjI0YjMzZDc1 ZjljMDA0MjM0YTY5NzQ3NzQuLjFiYzIwNGQxNzdiZDNjNzliOWFhYmQ0ODUxNTJhNjQzMTY0MmNj ZDAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvbWF0aG1sL01hdGhNTFRleHRFbGVtZW50LmNwcApAQCAt NjQsNiArNjQsMTQgQEAgdm9pZCBNYXRoTUxUZXh0RWxlbWVudDo6Y2hpbGRyZW5DaGFuZ2VkKGNv bnN0IENoaWxkQ2hhbmdlJiBjaGFuZ2UpCiAgICAgICAgIHRvUmVuZGVyTWF0aE1MVG9rZW4ocmVu ZGVyZXIoKSktPnVwZGF0ZVRva2VuQ29udGVudCgpOwogfQogCit2b2lkIE1hdGhNTFRleHRFbGVt ZW50OjpwYXJzZUF0dHJpYnV0ZShjb25zdCBRdWFsaWZpZWROYW1lJiBuYW1lLCBjb25zdCBBdG9t aWNTdHJpbmcmIHZhbHVlKQoreworICAgIGlmICgobmFtZSA9PSBzdHJldGNoeUF0dHIpICYmIHJl bmRlcmVyKCkpCisgICAgICAgIHRvUmVuZGVyTWF0aE1MT3BlcmF0b3IocmVuZGVyZXIoKSktPnNl dE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGVWYWx1ZShNYXRoTUxPcGVyYXRvckRpY3Rpb25hcnk6 OlN0cmV0Y2h5LCB2YWx1ZSwgdHJ1ZSk7CisgICAgZWxzZQorICAgICAgICBNYXRoTUxFbGVtZW50 OjpwYXJzZUF0dHJpYnV0ZShuYW1lLCB2YWx1ZSk7Cit9CisKIFJlbmRlclB0cjxSZW5kZXJFbGVt ZW50PiBNYXRoTUxUZXh0RWxlbWVudDo6Y3JlYXRlRWxlbWVudFJlbmRlcmVyKFBhc3NSZWY8UmVu ZGVyU3R5bGU+IHN0eWxlKQogewogICAgIGlmIChoYXNUYWdOYW1lKE1hdGhNTE5hbWVzOjptb1Rh ZykpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQu aCBiL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5oCmluZGV4IDQxMzUx NTVkNmIyYWU1NWM0NzJmNjcyZGJiZWEwMmFmYWE1YjRhYjkuLjZhZGM3NDc2MDgxNmFhNzNkMzg5 ZjE1Mjg4OGI2ZTVhNGYzNDRmYjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9N YXRoTUxUZXh0RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0 RWxlbWVudC5oCkBAIC0zOSw2ICszOSw5IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgYm9vbCBp c1ByZXNlbnRhdGlvbk1hdGhNTCgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIHRydWU7IH0KIAor cHJvdGVjdGVkOgorICAgIHZpcnR1YWwgdm9pZCBwYXJzZUF0dHJpYnV0ZShjb25zdCBRdWFsaWZp ZWROYW1lJiwgY29uc3QgQXRvbWljU3RyaW5nJikgb3ZlcnJpZGU7CisKIHByaXZhdGU6CiAgICAg TWF0aE1MVGV4dEVsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYgdGFnTmFtZSwgRG9jdW1lbnQm KTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJN YXRoTUxPcGVyYXRvci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRl ck1hdGhNTE9wZXJhdG9yLmNwcAppbmRleCBjZTMyMzBhZTQyYmY5NGU2YjlhODYxNjEwNTE4NTEx MDZjYmE3ZDJlLi5iNzNlNWZkZmU1ZjFiMTZmZjUwY2M3OTFmNTc5OTM0MWUxMWUzNzlmIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhNTE9wZXJh dG9yLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhN TE9wZXJhdG9yLmNwcApAQCAtMTE1NywxNSArMTE1NywyOCBAQCBSZW5kZXJNYXRoTUxPcGVyYXRv cjo6UmVuZGVyTWF0aE1MT3BlcmF0b3IoRG9jdW1lbnQmIGRvY3VtZW50LCBQYXNzUmVmPFJlbmRl clN0eQogICAgIHVwZGF0ZVRva2VuQ29udGVudChvcGVyYXRvclN0cmluZyk7CiB9CiAKLXZvaWQg UmVuZGVyTWF0aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGUoTWF0aE1M T3BlcmF0b3JEaWN0aW9uYXJ5OjpGbGFnIGZsYWcsIGNvbnN0IFF1YWxpZmllZE5hbWUmIG5hbWUp Cit2b2lkIFJlbmRlck1hdGhNTE9wZXJhdG9yOjpzZXRPcGVyYXRvckZsYWdGcm9tQXR0cmlidXRl VmFsdWUoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5OjpGbGFnIGZsYWcsIGNvbnN0IEF0b21pY1N0 cmluZyYgdmFsdWUsIGJvb2wgZG9MYXlvdXRJZk5lZWRlZCkKIHsKICAgICBBU1NFUlQoIWlzQW5v bnltb3VzKCkpOwotICAgIGNvbnN0IEF0b21pY1N0cmluZyYgYXR0cmlidXRlVmFsdWUgPSBlbGVt ZW50KCkuZmFzdEdldEF0dHJpYnV0ZShuYW1lKTsKLSAgICBpZiAoYXR0cmlidXRlVmFsdWUgPT0g InRydWUiKQorCisgICAgdW5zaWduZWQgc2hvcnQgb2xkT3BlcmF0b3JGbGFncyA9IG1fb3BlcmF0 b3JGbGFnczsKKworICAgIGlmIChlcXVhbElnbm9yaW5nQ2FzZSh2YWx1ZSwgInRydWUiKSkKICAg ICAgICAgbV9vcGVyYXRvckZsYWdzIHw9IGZsYWc7Ci0gICAgZWxzZSBpZiAoYXR0cmlidXRlVmFs dWUgPT0gImZhbHNlIikKKyAgICBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2FzZSh2YWx1ZSwgImZh bHNlIikpCiAgICAgICAgIG1fb3BlcmF0b3JGbGFncyAmPSB+ZmxhZzsKICAgICAvLyBXZSBpZ25v cmUgYWJzZW50IG9yIGludmFsaWQgYXR0cmlidXRlcy4KKworICAgIGlmIChkb0xheW91dElmTmVl ZGVkICYmIChvbGRPcGVyYXRvckZsYWdzICE9IG1fb3BlcmF0b3JGbGFncykpCisgICAgICAgIHNl dE5lZWRzTGF5b3V0QW5kUHJlZldpZHRoc1JlY2FsYygpOworfQorCit2b2lkIFJlbmRlck1hdGhN TE9wZXJhdG9yOjpzZXRPcGVyYXRvckZsYWdGcm9tQXR0cmlidXRlKE1hdGhNTE9wZXJhdG9yRGlj dGlvbmFyeTo6RmxhZyBmbGFnLCBjb25zdCBRdWFsaWZpZWROYW1lJiBuYW1lKQoreworICAgIEFT U0VSVCghaXNBbm9ueW1vdXMoKSk7CisgICAgY29uc3QgQXRvbWljU3RyaW5nJiBhdHRyaWJ1dGVW YWx1ZSA9IGVsZW1lbnQoKS5mYXN0R2V0QXR0cmlidXRlKG5hbWUpOworCisgICAgc2V0T3BlcmF0 b3JGbGFnRnJvbUF0dHJpYnV0ZVZhbHVlKGZsYWcsIGF0dHJpYnV0ZVZhbHVlKTsKIH0KIAogdm9p ZCBSZW5kZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0b3JQcm9wZXJ0aWVzRnJvbU9wRGljdEVu dHJ5KGNvbnN0IE1hdGhNTE9wZXJhdG9yRGljdGlvbmFyeTo6RW50cnkqIGVudHJ5KQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRv ci5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRv ci5oCmluZGV4IGMyMDk4Nzg3NzRmODA4Nzc4Zjc0NDZlZGFkM2I0YTJhM2Q0Y2RiNzEuLjk4MTA0 YWE0ZjQ2MWEyZDIyZjIwZTc0NjA4YmM4ZmJiYzhkMjJhYjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuaAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhNTE9wZXJhdG9yLmgKQEAgLTc4 LDYgKzc4LDcgQEAgcHVibGljOgogICAgIHZvaWQgdXBkYXRlVG9rZW5Db250ZW50KGNvbnN0IFN0 cmluZyYgb3BlcmF0b3JTdHJpbmcpOwogICAgIHZvaWQgdXBkYXRlVG9rZW5Db250ZW50KCkgb3Zl cnJpZGUgZmluYWw7CiAgICAgdm9pZCB1cGRhdGVPcGVyYXRvclByb3BlcnRpZXMoKTsKKyAgICB2 b2lkIHNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGVWYWx1ZShNYXRoTUxPcGVyYXRvckRpY3Rp b25hcnk6OkZsYWcsIGNvbnN0IEF0b21pY1N0cmluZyYsIGJvb2wgZG9MYXlvdXRJZk5lZWRlZCA9 IGZhbHNlKTsKIAogcHJvdGVjdGVkOgogICAgIHZpcnR1YWwgY29uc3QgY2hhciogcmVuZGVyTmFt ZSgpIGNvbnN0IG92ZXJyaWRlIHsgcmV0dXJuIGlzQW5vbnltb3VzKCkgPyAiUmVuZGVyTWF0aE1M T3BlcmF0b3IgKGFub255bW91cykiIDogIlJlbmRlck1hdGhNTE9wZXJhdG9yIjsgfQpkaWZmIC0t Z2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4 IGU5ZjJkMGY3MTRiZDc1MGViZTNlMjQ2ZTJlM2UzYWFhNDFiZTUxNjEuLjdiNmMxMTcxOGE1Yjc1 MjJiY2RiZmZjYzI1YWVmYmFjZjM0N2JkYWYgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5n ZUxvZworKysgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAxNC0w OS0yOSAgQWxlamFuZHJvIEcuIENhc3RybyAgPGFsZXhAaWdhbGlhLmNvbT4KKworICAgICAgICBD aGFuZ2VzIGluIHRoZSBzdHJldGNoeSBhdHRyaWJ1dGUgZG8gbm90IHVwZGF0ZSByZW5kZXJpbmcK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNjg4Mwor CisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoZSB0ZXN0 IHVwZGF0ZXMgdGhlIHN0cmV0Y2h5IHZhbHVlIGluIGEgdGltZW91dC4KKworICAgICAgICAqIG1h dGhtbC9wcmVzZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUtZXhwZWN0ZWQuaHRtbDogQWRkZWQu CisgICAgICAgICogbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sOiBB ZGRlZC4KKwogMjAxNC0wOS0xMCAgSmVyIE5vYmxlICA8amVyLm5vYmxlQGFwcGxlLmNvbT4KIAog ICAgICAgICBVbnJldmlld2VkIGdhcmRlbmluZy4gUmViYXNlbGluZSBmYWlsaW5nIG1lZGlhL3Zp ZGVvLSB0ZXN0cyBicm9rZW4gYnkgcjE1NjU0Ni4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL21h dGhtbC9wcmVzZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUtZXhwZWN0ZWQuaHRtbCBiL0xheW91 dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUtZXhwZWN0ZWQuaHRt bApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwLi40NmJkMDc0Y2FlODNkY2ZjNWRmNmE2MDRjZGE1ZThjYjRkNDE4MWMzCi0t LSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJl dGNoLXVwZGF0ZS1leHBlY3RlZC5odG1sCkBAIC0wLDAgKzEsMTEgQEAKKzwhRE9DVFlQRSBodG1s PgorPGh0bWw+Cis8Ym9keT4KKyAgICA8bWF0aD4KKyAgICAgICAgPG1yb3c+CisgICAgICAgICAg ICA8bW8gc3RyZXRjaHk9InRydWUiPiZJbnRlZ3JhbDs8L21vPgorICAgICAgICAgICAgPG1zcGFj ZSBoZWlnaHQ9Ijc1cHgiIGRlcHRoPSIxcHgiLz4KKyAgICAgICAgPC9tcm93PgorICAgIDwvbWF0 aD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL21hdGhtbC9wcmVz ZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUuaHRtbCBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVz ZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRl eCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi40Njc0NGM0NWNjNzNj NWJmZDBkMWZhNmY0MzFiNWRlNmY1NjVjN2RhCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVz dHMvbWF0aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sCkBAIC0wLDAgKzEs MzAgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKyAgICA8bWF0aD4KKyAgICAg ICAgPG1yb3c+CisgICAgICAgICAgICA8bW8gaWQ9InRlc3QxIiBzdHJldGNoeT0iZmFsc2UiPiZJ bnRlZ3JhbDs8L21vPgorICAgICAgICAgICAgPG1zcGFjZSBoZWlnaHQ9Ijc1cHgiIGRlcHRoPSIx cHgiLz4KKyAgICAgICAgPC9tcm93PgorICAgIDwvbWF0aD4KKworICAgIDxzY3JpcHQ+CisgICAg ICAgIGlmICh3aW5kb3cudGVzdFJ1bm5lcikgeworICAgICAgICAgICAgdGVzdFJ1bm5lci53YWl0 VW50aWxEb25lKCk7CisgICAgICAgIH0KKworCisgICAgICAgIGZ1bmN0aW9uIHVwZGF0ZVBhZ2VB ZnRlclJlbmRlcmluZygpCisgICAgICAgIHsKKyAgICAgICAgICAgIHdpbmRvdy5zZXRUaW1lb3V0 KGZ1bmN0aW9uKCkKKyAgICAgICAgICAgICAgICB7CisgICAgICAgICAgICAgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJ0ZXN0MSIpLnNldEF0dHJpYnV0ZSgic3RyZXRjaHkiLCAidHJ1 ZSIpOworICAgICAgICAgICAgICAgICAgICB0ZXN0UnVubmVyLm5vdGlmeURvbmUoKTsKKyAgICAg ICAgICAgICAgICB9LCA1MCk7CisgICAgICAgIH0KKworICAgICAgICB3aW5kb3cuYWRkRXZlbnRM aXN0ZW5lcignbG9hZCcsIHVwZGF0ZVBhZ2VBZnRlclJlbmRlcmluZywgZmFsc2UpOworCisgICAg PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 238919 2014-09-30 03:17:49 -0700 2014-10-10 07:56:40 -0700 Patch stretchy_update.patch text/plain 7662 alex ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBlOWYyZDBmLi5iMjkzN2FiIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTQtMDkt MzAgIEFsZWphbmRybyBHLiBDYXN0cm8gIDxhbGV4QGlnYWxpYS5jb20+CisKKyAgICAgICAgQ2hh bmdlcyBpbiB0aGUgc3RyZXRjaHkgYXR0cmlidXRlIGRvIG5vdCB1cGRhdGUgcmVuZGVyaW5nCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzY4ODMKKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBUaGUgdGVzdCB1 cGRhdGVzIHRoZSBzdHJldGNoeSB2YWx1ZSBpbiBhIHRpbWVvdXQuCisKKyAgICAgICAgKiBtYXRo bWwvcHJlc2VudGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLWV4cGVjdGVkLmh0bWw6IEFkZGVkLgor ICAgICAgICAqIG1hdGhtbC9wcmVzZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUuaHRtbDogQWRk ZWQuCisKIDIwMTQtMDktMTAgIEplciBOb2JsZSAgPGplci5ub2JsZUBhcHBsZS5jb20+CiAKICAg ICAgICAgVW5yZXZpZXdlZCBnYXJkZW5pbmcuIFJlYmFzZWxpbmUgZmFpbGluZyBtZWRpYS92aWRl by0gdGVzdHMgYnJva2VuIGJ5IHIxNTY1NDYuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9tYXRo bWwvcHJlc2VudGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLWV4cGVjdGVkLmh0bWwgYi9MYXlvdXRU ZXN0cy9tYXRobWwvcHJlc2VudGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLWV4cGVjdGVkLmh0bWwK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDZiZDA3NAotLS0gL2Rldi9udWxs CisrKyBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUt ZXhwZWN0ZWQuaHRtbApAQCAtMCwwICsxLDExIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgor PGJvZHk+CisgICAgPG1hdGg+CisgICAgICAgIDxtcm93PgorICAgICAgICAgICAgPG1vIHN0cmV0 Y2h5PSJ0cnVlIj4mSW50ZWdyYWw7PC9tbz4KKyAgICAgICAgICAgIDxtc3BhY2UgaGVpZ2h0PSI3 NXB4IiBkZXB0aD0iMXB4Ii8+CisgICAgICAgIDwvbXJvdz4KKyAgICA8L21hdGg+Cis8L2JvZHk+ Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9tYXRobWwvcHJlc2VudGF0aW9uL21v LXN0cmV0Y2gtdXBkYXRlLmh0bWwgYi9MYXlvdXRUZXN0cy9tYXRobWwvcHJlc2VudGF0aW9uL21v LXN0cmV0Y2gtdXBkYXRlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u NDY3NDRjNAotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL21hdGhtbC9wcmVzZW50YXRp b24vbW8tc3RyZXRjaC11cGRhdGUuaHRtbApAQCAtMCwwICsxLDMwIEBACis8IURPQ1RZUEUgaHRt bD4KKzxodG1sPgorPGJvZHk+CisgICAgPG1hdGg+CisgICAgICAgIDxtcm93PgorICAgICAgICAg ICAgPG1vIGlkPSJ0ZXN0MSIgc3RyZXRjaHk9ImZhbHNlIj4mSW50ZWdyYWw7PC9tbz4KKyAgICAg ICAgICAgIDxtc3BhY2UgaGVpZ2h0PSI3NXB4IiBkZXB0aD0iMXB4Ii8+CisgICAgICAgIDwvbXJv dz4KKyAgICA8L21hdGg+CisKKyAgICA8c2NyaXB0PgorICAgICAgICBpZiAod2luZG93LnRlc3RS dW5uZXIpIHsKKyAgICAgICAgICAgIHRlc3RSdW5uZXIud2FpdFVudGlsRG9uZSgpOworICAgICAg ICB9CisKKworICAgICAgICBmdW5jdGlvbiB1cGRhdGVQYWdlQWZ0ZXJSZW5kZXJpbmcoKQorICAg ICAgICB7CisgICAgICAgICAgICB3aW5kb3cuc2V0VGltZW91dChmdW5jdGlvbigpCisgICAgICAg ICAgICAgICAgeworICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgi dGVzdDEiKS5zZXRBdHRyaWJ1dGUoInN0cmV0Y2h5IiwgInRydWUiKTsKKyAgICAgICAgICAgICAg ICAgICAgdGVzdFJ1bm5lci5ub3RpZnlEb25lKCk7CisgICAgICAgICAgICAgICAgfSwgNTApOwor ICAgICAgICB9CisKKyAgICAgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ2xvYWQnLCB1cGRh dGVQYWdlQWZ0ZXJSZW5kZXJpbmcsIGZhbHNlKTsKKworICAgIDwvc2NyaXB0PgorPC9ib2R5Pgor PC9odG1sPgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIvU291cmNlL1dl YkNvcmUvQ2hhbmdlTG9nCmluZGV4IGU2Y2M1MTYyLi5jZjBkNmI4IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMjggQEAKKzIwMTQtMDktMzAgIEFsZWphbmRybyBHLiBDYXN0cm8gIDxhbGV4QGlnYWxp YS5jb20+CisKKyAgICAgICAgQ2hhbmdlcyBpbiB0aGUgc3RyZXRjaHkgYXR0cmlidXRlIGRvIG5v dCB1cGRhdGUgcmVuZGVyaW5nCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0xMzY4ODMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICBUZXN0OiBtYXRobWwvcHJlc2VudGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLmh0 bWwKKworICAgICAgICBXZSBuZWVkIHRvIHJlbGF5b3V0IHdoZW4gYSBjaGFuZ2UgaW4gdGhlIHN0 cmV0Y2h5IGF0dHJpYnV0ZQorICAgICAgICBoYXBwZW5zLgorCisgICAgICAgICogbWF0aG1sL01h dGhNTFRleHRFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hdGhNTFRleHRFbGVtZW50 OjpwYXJzZUF0dHJpYnV0ZSk6IFBhcnNlIHRoZQorICAgICAgICBtb2RpZmljYXRpb25zIG9mIHRo ZSBzdHJldGNoeSBhdHRyaWJ1dGUuCisgICAgICAgICogbWF0aG1sL01hdGhNTFRleHRFbGVtZW50 Lmg6CisgICAgICAgICogcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRvci5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0b3JGbGFn QW5kU2NoZWR1bGVMYXlvdXRJZk5lZWRlZCk6CisgICAgICAgIEFkZCBmdW5jdGlvbiB0aGF0IHJl Y2VpdmVzIHRoZSB2YWx1ZSBpbnN0ZWFkIG9mIGxvb2tpbmcgZm9yIGl0IGFuZAorICAgICAgICBj aGVja3MgaWYgdGhlIGNoYW5nZSBzaG91bGQgc2NoZWR1bGUgYSBsYXlvdXQuCisgICAgICAgIChX ZWJDb3JlOjpSZW5kZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0b3JGbGFnRnJvbUF0dHJpYnV0 ZSk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0b3JG bGFnRnJvbUF0dHJpYnV0ZVZhbHVlKToKKyAgICAgICAgQWRkIGZ1bmN0aW9uIHRoYXQgcmVjZWl2 ZXMgdGhlIHZhbHVlIGluc3RlYWQgb2YgbG9va2luZyBmb3IgaXQuCisgICAgICAgICogcmVuZGVy aW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRvci5oOgorCiAyMDE0LTA5LTExICBDYXJsb3Mg R2FyY2lhIENhbXBvcyAgPGNnYXJjaWFAaWdhbGlhLmNvbT4KIAogICAgICAgICBbR1RLXSBNZXJn ZSBXZWJLaXRBdXRoZW50aWNhdGlvbldpZGdldCBpbnRvIFdlYktpdEF1dGhlbnRpY2F0aW9uRGlh bG9nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQu Y3BwIGIvU291cmNlL1dlYkNvcmUvbWF0aG1sL01hdGhNTFRleHRFbGVtZW50LmNwcAppbmRleCAy MjM4M2MwLi4yNmZhZjk5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1M VGV4dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0RWxl bWVudC5jcHAKQEAgLTY0LDYgKzY0LDE0IEBAIHZvaWQgTWF0aE1MVGV4dEVsZW1lbnQ6OmNoaWxk cmVuQ2hhbmdlZChjb25zdCBDaGlsZENoYW5nZSYgY2hhbmdlKQogICAgICAgICB0b1JlbmRlck1h dGhNTFRva2VuKHJlbmRlcmVyKCkpLT51cGRhdGVUb2tlbkNvbnRlbnQoKTsKIH0KIAordm9pZCBN YXRoTUxUZXh0RWxlbWVudDo6cGFyc2VBdHRyaWJ1dGUoY29uc3QgUXVhbGlmaWVkTmFtZSYgbmFt ZSwgY29uc3QgQXRvbWljU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBpZiAobmFtZSA9PSBzdHJldGNo eUF0dHIgJiYgcmVuZGVyZXIoKSAmJiByZW5kZXJlcigpLT5pc1JlbmRlck1hdGhNTE9wZXJhdG9y KCkpCisgICAgICAgIHRvUmVuZGVyTWF0aE1MT3BlcmF0b3IocmVuZGVyZXIoKSktPnNldE9wZXJh dG9yRmxhZ0FuZFNjaGVkdWxlTGF5b3V0SWZOZWVkZWQoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5 OjpTdHJldGNoeSwgdmFsdWUpOworCisgICAgTWF0aE1MRWxlbWVudDo6cGFyc2VBdHRyaWJ1dGUo bmFtZSwgdmFsdWUpOworfQorCiBSZW5kZXJQdHI8UmVuZGVyRWxlbWVudD4gTWF0aE1MVGV4dEVs ZW1lbnQ6OmNyZWF0ZUVsZW1lbnRSZW5kZXJlcihQYXNzUmVmPFJlbmRlclN0eWxlPiBzdHlsZSkK IHsKICAgICBpZiAoaGFzVGFnTmFtZShNYXRoTUxOYW1lczo6bW9UYWcpKQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvbWF0aG1sL01hdGhNTFRleHRFbGVtZW50LmggYi9Tb3VyY2UvV2ViQ29y ZS9tYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQuaAppbmRleCA0MTM1MTU1Li5hYzAzZmNhIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQuaApAQCAtNDYsNiArNDYsNyBA QCBwcml2YXRlOgogICAgIHZpcnR1YWwgYm9vbCBjaGlsZFNob3VsZENyZWF0ZVJlbmRlcmVyKGNv bnN0IE5vZGUmKSBjb25zdCBvdmVycmlkZTsKIAogICAgIHZpcnR1YWwgdm9pZCBjaGlsZHJlbkNo YW5nZWQoY29uc3QgQ2hpbGRDaGFuZ2UmKSBvdmVycmlkZTsKKyAgICB2aXJ0dWFsIHZvaWQgcGFy c2VBdHRyaWJ1dGUoY29uc3QgUXVhbGlmaWVkTmFtZSYsIGNvbnN0IEF0b21pY1N0cmluZyYpIGZp bmFsOwogfTsKICAgICAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9t YXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRvci5jcHAKaW5kZXggY2UzMjMwYS4uMDE2YWY2YyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxP cGVyYXRvci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJN YXRoTUxPcGVyYXRvci5jcHAKQEAgLTExNTcsMTMgKzExNTcsMjggQEAgUmVuZGVyTWF0aE1MT3Bl cmF0b3I6OlJlbmRlck1hdGhNTE9wZXJhdG9yKERvY3VtZW50JiBkb2N1bWVudCwgUGFzc1JlZjxS ZW5kZXJTdHkKICAgICB1cGRhdGVUb2tlbkNvbnRlbnQob3BlcmF0b3JTdHJpbmcpOwogfQogCit2 b2lkIFJlbmRlck1hdGhNTE9wZXJhdG9yOjpzZXRPcGVyYXRvckZsYWdBbmRTY2hlZHVsZUxheW91 dElmTmVlZGVkKE1hdGhNTE9wZXJhdG9yRGljdGlvbmFyeTo6RmxhZyBmbGFnLCBjb25zdCBBdG9t aWNTdHJpbmcmIGF0dHJpYnV0ZVZhbHVlKQoreworICAgIHVuc2lnbmVkIHNob3J0IG9sZE9wZXJh dG9yRmxhZ3MgPSBtX29wZXJhdG9yRmxhZ3M7CisKKyAgICBzZXRPcGVyYXRvckZsYWdGcm9tQXR0 cmlidXRlVmFsdWUoZmxhZywgYXR0cmlidXRlVmFsdWUpOworCisgICAgaWYgKG9sZE9wZXJhdG9y RmxhZ3MgIT0gbV9vcGVyYXRvckZsYWdzKQorICAgICAgICBzZXROZWVkc0xheW91dEFuZFByZWZX aWR0aHNSZWNhbGMoKTsKK30KKwogdm9pZCBSZW5kZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0 b3JGbGFnRnJvbUF0dHJpYnV0ZShNYXRoTUxPcGVyYXRvckRpY3Rpb25hcnk6OkZsYWcgZmxhZywg Y29uc3QgUXVhbGlmaWVkTmFtZSYgbmFtZSkKIHsKKyAgICBzZXRPcGVyYXRvckZsYWdGcm9tQXR0 cmlidXRlVmFsdWUoZmxhZywgZWxlbWVudCgpLmZhc3RHZXRBdHRyaWJ1dGUobmFtZSkpOworfQor Cit2b2lkIFJlbmRlck1hdGhNTE9wZXJhdG9yOjpzZXRPcGVyYXRvckZsYWdGcm9tQXR0cmlidXRl VmFsdWUoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5OjpGbGFnIGZsYWcsIGNvbnN0IEF0b21pY1N0 cmluZyYgYXR0cmlidXRlVmFsdWUpCit7CiAgICAgQVNTRVJUKCFpc0Fub255bW91cygpKTsKLSAg ICBjb25zdCBBdG9taWNTdHJpbmcmIGF0dHJpYnV0ZVZhbHVlID0gZWxlbWVudCgpLmZhc3RHZXRB dHRyaWJ1dGUobmFtZSk7Ci0gICAgaWYgKGF0dHJpYnV0ZVZhbHVlID09ICJ0cnVlIikKKworICAg IGlmIChlcXVhbElnbm9yaW5nQ2FzZShhdHRyaWJ1dGVWYWx1ZSwgInRydWUiKSkKICAgICAgICAg bV9vcGVyYXRvckZsYWdzIHw9IGZsYWc7Ci0gICAgZWxzZSBpZiAoYXR0cmlidXRlVmFsdWUgPT0g ImZhbHNlIikKKyAgICBlbHNlIGlmIChlcXVhbElnbm9yaW5nQ2FzZShhdHRyaWJ1dGVWYWx1ZSwg ImZhbHNlIikpCiAgICAgICAgIG1fb3BlcmF0b3JGbGFncyAmPSB+ZmxhZzsKICAgICAvLyBXZSBp Z25vcmUgYWJzZW50IG9yIGludmFsaWQgYXR0cmlidXRlcy4KIH0KZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuaCBiL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuaAppbmRleCBj MjA5ODc4Li4xYjg5ZDE4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0 aG1sL1JlbmRlck1hdGhNTE9wZXJhdG9yLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRvci5oCkBAIC03OCw2ICs3OCw3IEBAIHB1YmxpYzoK ICAgICB2b2lkIHVwZGF0ZVRva2VuQ29udGVudChjb25zdCBTdHJpbmcmIG9wZXJhdG9yU3RyaW5n KTsKICAgICB2b2lkIHVwZGF0ZVRva2VuQ29udGVudCgpIG92ZXJyaWRlIGZpbmFsOwogICAgIHZv aWQgdXBkYXRlT3BlcmF0b3JQcm9wZXJ0aWVzKCk7CisgICAgdm9pZCBzZXRPcGVyYXRvckZsYWdB bmRTY2hlZHVsZUxheW91dElmTmVlZGVkKE1hdGhNTE9wZXJhdG9yRGljdGlvbmFyeTo6RmxhZywg Y29uc3QgQXRvbWljU3RyaW5nJiBhdHRyaWJ1dGVWYWx1ZSk7CiAKIHByb3RlY3RlZDoKICAgICB2 aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUoKSBjb25zdCBvdmVycmlkZSB7IHJldHVybiBp c0Fub255bW91cygpID8gIlJlbmRlck1hdGhNTE9wZXJhdG9yIChhbm9ueW1vdXMpIiA6ICJSZW5k ZXJNYXRoTUxPcGVyYXRvciI7IH0KQEAgLTE4NSw2ICsxODYsNyBAQCBwcm90ZWN0ZWQ6CiAgICAg TGF5b3V0VW5pdCBtX21heFNpemU7CiAKICAgICB2b2lkIHNldE9wZXJhdG9yRmxhZ0Zyb21BdHRy aWJ1dGUoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5OjpGbGFnLCBjb25zdCBRdWFsaWZpZWROYW1l Jik7CisgICAgdm9pZCBzZXRPcGVyYXRvckZsYWdGcm9tQXR0cmlidXRlVmFsdWUoTWF0aE1MT3Bl cmF0b3JEaWN0aW9uYXJ5OjpGbGFnLCBjb25zdCBBdG9taWNTdHJpbmcmIGF0dHJpYnV0ZVZhbHVl KTsKICAgICB2b2lkIHNldE9wZXJhdG9yUHJvcGVydGllc0Zyb21PcERpY3RFbnRyeShjb25zdCBN YXRoTUxPcGVyYXRvckRpY3Rpb25hcnk6OkVudHJ5Kik7CiAgICAgdmlydHVhbCB2b2lkIFNldE9w ZXJhdG9yUHJvcGVydGllcygpOwogfTsK 239625 2014-10-10 07:56:40 -0700 2014-10-14 02:55:46 -0700 Patch stretchy-update.patch text/plain 7629 alex Y29tbWl0IDFkYjU4YjZjMTdhNDg2MDQxZDliZDlhZDI2NmYxMmRjMDE4MzE2NzAKQXV0aG9yOiBB bGVqYW5kcm8gRy4gQ2FzdHJvIDxhLmdhcmNpYS5jYXN0cm9AZ21haWwuY29tPgpEYXRlOiAgIEZy aSBPY3QgMTAgMTY6NTI6NDAgMjAxNCArMDIwMAoKICAgIENoYW5nZXMgaW4gdGhlIHN0cmV0Y2h5 IGF0dHJpYnV0ZSBkbyBub3QgdXBkYXRlIHJlbmRlcmluZwogICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTEzNjg4MwogICAgCiAgICBSZXZpZXdlZCBieSBEYXJpbiBB ZGxlci4KICAgIAogICAgU291cmNlL1dlYkNvcmU6CiAgICAKICAgIFRlc3Q6IG1hdGhtbC9wcmVz ZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUuaHRtbAogICAgCiAgICBXZSBuZWVkIHRvIHJlbGF5 b3V0IHdoZW4gYSBjaGFuZ2UgaW4gdGhlIHN0cmV0Y2h5IGF0dHJpYnV0ZQogICAgaGFwcGVucy4K ICAgIAogICAgKiBtYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQuY3BwOgogICAgKFdlYkNvcmU6Ok1h dGhNTFRleHRFbGVtZW50OjpwYXJzZUF0dHJpYnV0ZSk6IFBhcnNlIHRoZQogICAgbW9kaWZpY2F0 aW9ucyBvZiB0aGUgc3RyZXRjaHkgYXR0cmlidXRlLgogICAgKiBtYXRobWwvTWF0aE1MVGV4dEVs ZW1lbnQuaDoKICAgICogcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRvci5jcHA6 CiAgICAoV2ViQ29yZTo6UmVuZGVyTWF0aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0FuZFNj aGVkdWxlTGF5b3V0SWZOZWVkZWQpOgogICAgQWRkIGZ1bmN0aW9uIHRoYXQgcmVjZWl2ZXMgdGhl IHZhbHVlIGluc3RlYWQgb2YgbG9va2luZyBmb3IgaXQgYW5kCiAgICBjaGVja3MgaWYgdGhlIGNo YW5nZSBzaG91bGQgc2NoZWR1bGUgYSBsYXlvdXQuCiAgICAoV2ViQ29yZTo6UmVuZGVyTWF0aE1M T3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGUpOgogICAgKFdlYkNvcmU6OlJl bmRlck1hdGhNTE9wZXJhdG9yOjpzZXRPcGVyYXRvckZsYWdGcm9tQXR0cmlidXRlVmFsdWUpOgog ICAgQWRkIGZ1bmN0aW9uIHRoYXQgcmVjZWl2ZXMgdGhlIHZhbHVlIGluc3RlYWQgb2YgbG9va2lu ZyBmb3IgaXQuCiAgICAqIHJlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuaDoK ICAgIAogICAgTGF5b3V0VGVzdHM6CiAgICAKICAgIFRoZSB0ZXN0IHVwZGF0ZXMgdGhlIHN0cmV0 Y2h5IHZhbHVlIGluIGEgdGltZW91dC4KICAgIAogICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21v LXN0cmV0Y2gtdXBkYXRlLWV4cGVjdGVkLmh0bWw6IEFkZGVkLgogICAgKiBtYXRobWwvcHJlc2Vu dGF0aW9uL21vLXN0cmV0Y2gtdXBkYXRlLmh0bWw6IEFkZGVkLgoKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA5N2QxZGZmLi44 ZGE4YzE5IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTUgQEAKKzIwMTQtMTAtMTAgIEFsZWphbmRybyBHLiBD YXN0cm8gIDxhbGV4QGlnYWxpYS5jb20+CisKKyAgICAgICAgQ2hhbmdlcyBpbiB0aGUgc3RyZXRj aHkgYXR0cmlidXRlIGRvIG5vdCB1cGRhdGUgcmVuZGVyaW5nCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMzY4ODMKKworICAgICAgICBSZXZpZXdlZCBi eSBEYXJpbiBBZGxlci4KKworICAgICAgICBUaGUgdGVzdCB1cGRhdGVzIHRoZSBzdHJldGNoeSB2 YWx1ZSBpbiBhIHRpbWVvdXQuCisKKyAgICAgICAgKiBtYXRobWwvcHJlc2VudGF0aW9uL21vLXN0 cmV0Y2gtdXBkYXRlLWV4cGVjdGVkLmh0bWw6IEFkZGVkLgorICAgICAgICAqIG1hdGhtbC9wcmVz ZW50YXRpb24vbW8tc3RyZXRjaC11cGRhdGUuaHRtbDogQWRkZWQuCisKIDIwMTQtMTAtMTAgIEFu ZHkgRXN0ZXMgIDxhZXN0ZXNAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZGVkIFlvc2VtaXRlIGV4 cGVjdGVkIHJlc3VsdHMgYW5kIFRlc3RFeHBlY3Rpb25zIHRvIHBsYXRmb3JtL21hYy8uCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VM b2cKaW5kZXggMWFlZGVhNy4uZWZlY2FhZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hh bmdlTG9nCisrKyBiL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI4IEBACisy MDE0LTEwLTEwICBBbGVqYW5kcm8gRy4gQ2FzdHJvICA8YWxleEBpZ2FsaWEuY29tPgorCisgICAg ICAgIENoYW5nZXMgaW4gdGhlIHN0cmV0Y2h5IGF0dHJpYnV0ZSBkbyBub3QgdXBkYXRlIHJlbmRl cmluZworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTM2 ODgzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAgICAgICAgVGVzdDog bWF0aG1sL3ByZXNlbnRhdGlvbi9tby1zdHJldGNoLXVwZGF0ZS5odG1sCisKKyAgICAgICAgV2Ug bmVlZCB0byByZWxheW91dCB3aGVuIGEgY2hhbmdlIGluIHRoZSBzdHJldGNoeSBhdHRyaWJ1dGUK KyAgICAgICAgaGFwcGVucy4KKworICAgICAgICAqIG1hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5j cHA6CisgICAgICAgIChXZWJDb3JlOjpNYXRoTUxUZXh0RWxlbWVudDo6cGFyc2VBdHRyaWJ1dGUp OiBQYXJzZSB0aGUKKyAgICAgICAgbW9kaWZpY2F0aW9ucyBvZiB0aGUgc3RyZXRjaHkgYXR0cmli dXRlLgorICAgICAgICAqIG1hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5oOgorICAgICAgICAqIHJl bmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3IuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyTWF0aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0FuZFNjaGVkdWxlTGF5b3V0 SWZOZWVkZWQpOgorICAgICAgICBBZGQgZnVuY3Rpb24gdGhhdCByZWNlaXZlcyB0aGUgdmFsdWUg aW5zdGVhZCBvZiBsb29raW5nIGZvciBpdCBhbmQKKyAgICAgICAgY2hlY2tzIGlmIHRoZSBjaGFu Z2Ugc2hvdWxkIHNjaGVkdWxlIGEgbGF5b3V0LgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyTWF0 aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGUpOgorICAgICAgICAoV2Vi Q29yZTo6UmVuZGVyTWF0aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGVW YWx1ZSk6CisgICAgICAgIEFkZCBmdW5jdGlvbiB0aGF0IHJlY2VpdmVzIHRoZSB2YWx1ZSBpbnN0 ZWFkIG9mIGxvb2tpbmcgZm9yIGl0LgorICAgICAgICAqIHJlbmRlcmluZy9tYXRobWwvUmVuZGVy TWF0aE1MT3BlcmF0b3IuaDoKKwogMjAxNC0xMC0xMCAgWmFuIERvYmVyc2VrICA8emRvYmVyc2Vr QGlnYWxpYS5jb20+CiAKICAgICAgICAgUmVtb3ZlIENyb3NzVGhyZWFkVGFzawpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvbWF0aG1sL01hdGhNTFRleHRFbGVtZW50LmNwcCBiL1NvdXJjZS9X ZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5jcHAKaW5kZXggMDhlNWVkZC4uNTAzMTJi MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvbWF0aG1sL01hdGhNTFRleHRFbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1MVGV4dEVsZW1lbnQuY3BwCkBAIC02 NCw2ICs2NCwxNyBAQCB2b2lkIE1hdGhNTFRleHRFbGVtZW50OjpjaGlsZHJlbkNoYW5nZWQoY29u c3QgQ2hpbGRDaGFuZ2UmIGNoYW5nZSkKICAgICAgICAgZG93bmNhc3Q8UmVuZGVyTWF0aE1MVG9r ZW4+KCpyZW5kZXJlcigpKS51cGRhdGVUb2tlbkNvbnRlbnQoKTsKIH0KIAordm9pZCBNYXRoTUxU ZXh0RWxlbWVudDo6cGFyc2VBdHRyaWJ1dGUoY29uc3QgUXVhbGlmaWVkTmFtZSYgbmFtZSwgY29u c3QgQXRvbWljU3RyaW5nJiB2YWx1ZSkKK3sKKyAgICBpZiAobmFtZSA9PSBzdHJldGNoeUF0dHIp IHsKKyAgICAgICAgaWYgKGlzPFJlbmRlck1hdGhNTE9wZXJhdG9yPihyZW5kZXJlcigpKSkKKyAg ICAgICAgICAgIGRvd25jYXN0PFJlbmRlck1hdGhNTE9wZXJhdG9yPigqcmVuZGVyZXIoKSkuc2V0 T3BlcmF0b3JGbGFnQW5kU2NoZWR1bGVMYXlvdXRJZk5lZWRlZChNYXRoTUxPcGVyYXRvckRpY3Rp b25hcnk6OlN0cmV0Y2h5LCB2YWx1ZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBN YXRoTUxFbGVtZW50OjpwYXJzZUF0dHJpYnV0ZShuYW1lLCB2YWx1ZSk7Cit9CisKIFJlbmRlclB0 cjxSZW5kZXJFbGVtZW50PiBNYXRoTUxUZXh0RWxlbWVudDo6Y3JlYXRlRWxlbWVudFJlbmRlcmVy KFBhc3NSZWY8UmVuZGVyU3R5bGU+IHN0eWxlKQogewogICAgIGlmIChoYXNUYWdOYW1lKE1hdGhN TE5hbWVzOjptb1RhZykpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9tYXRobWwvTWF0aE1M VGV4dEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxUZXh0RWxlbWVudC5o CmluZGV4IDQxMzUxNTUuLmJlZDc1OTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL21hdGht bC9NYXRoTUxUZXh0RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL21hdGhtbC9NYXRoTUxU ZXh0RWxlbWVudC5oCkBAIC0zMiw3ICszMiw3IEBACiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKICAg ICAKLWNsYXNzIE1hdGhNTFRleHRFbGVtZW50IDogcHVibGljIE1hdGhNTEVsZW1lbnQgeworY2xh c3MgTWF0aE1MVGV4dEVsZW1lbnQgZmluYWwgOiBwdWJsaWMgTWF0aE1MRWxlbWVudCB7CiBwdWJs aWM6CiAgICAgc3RhdGljIFBhc3NSZWZQdHI8TWF0aE1MVGV4dEVsZW1lbnQ+IGNyZWF0ZShjb25z dCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCYpOwogICAgIHZpcnR1YWwgdm9pZCBk aWRBdHRhY2hSZW5kZXJlcnMoKSBvdmVycmlkZTsKQEAgLTQ2LDYgKzQ2LDcgQEAgcHJpdmF0ZToK ICAgICB2aXJ0dWFsIGJvb2wgY2hpbGRTaG91bGRDcmVhdGVSZW5kZXJlcihjb25zdCBOb2RlJikg Y29uc3Qgb3ZlcnJpZGU7CiAKICAgICB2aXJ0dWFsIHZvaWQgY2hpbGRyZW5DaGFuZ2VkKGNvbnN0 IENoaWxkQ2hhbmdlJikgb3ZlcnJpZGU7CisgICAgdmlydHVhbCB2b2lkIHBhcnNlQXR0cmlidXRl KGNvbnN0IFF1YWxpZmllZE5hbWUmLCBjb25zdCBBdG9taWNTdHJpbmcmKSBvdmVycmlkZTsKIH07 CiAgICAgCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1Jl bmRlck1hdGhNTE9wZXJhdG9yLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwv UmVuZGVyTWF0aE1MT3BlcmF0b3IuY3BwCmluZGV4IGNjYWUyYjkuLmI2YzUzNGEgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3BlcmF0b3Iu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVyTWF0aE1MT3Bl cmF0b3IuY3BwCkBAIC0xMTU3LDEwICsxMTU3LDI1IEBAIFJlbmRlck1hdGhNTE9wZXJhdG9yOjpS ZW5kZXJNYXRoTUxPcGVyYXRvcihEb2N1bWVudCYgZG9jdW1lbnQsIFBhc3NSZWY8UmVuZGVyU3R5 CiAgICAgdXBkYXRlVG9rZW5Db250ZW50KG9wZXJhdG9yU3RyaW5nKTsKIH0KIAordm9pZCBSZW5k ZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0b3JGbGFnQW5kU2NoZWR1bGVMYXlvdXRJZk5lZWRl ZChNYXRoTUxPcGVyYXRvckRpY3Rpb25hcnk6OkZsYWcgZmxhZywgY29uc3QgQXRvbWljU3RyaW5n JiBhdHRyaWJ1dGVWYWx1ZSkKK3sKKyAgICB1bnNpZ25lZCBzaG9ydCBvbGRPcGVyYXRvckZsYWdz ID0gbV9vcGVyYXRvckZsYWdzOworCisgICAgc2V0T3BlcmF0b3JGbGFnRnJvbUF0dHJpYnV0ZVZh bHVlKGZsYWcsIGF0dHJpYnV0ZVZhbHVlKTsKKworICAgIGlmIChvbGRPcGVyYXRvckZsYWdzICE9 IG1fb3BlcmF0b3JGbGFncykKKyAgICAgICAgc2V0TmVlZHNMYXlvdXRBbmRQcmVmV2lkdGhzUmVj YWxjKCk7Cit9CisKIHZvaWQgUmVuZGVyTWF0aE1MT3BlcmF0b3I6OnNldE9wZXJhdG9yRmxhZ0Zy b21BdHRyaWJ1dGUoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5OjpGbGFnIGZsYWcsIGNvbnN0IFF1 YWxpZmllZE5hbWUmIG5hbWUpCiB7CisgICAgc2V0T3BlcmF0b3JGbGFnRnJvbUF0dHJpYnV0ZVZh bHVlKGZsYWcsIGVsZW1lbnQoKS5mYXN0R2V0QXR0cmlidXRlKG5hbWUpKTsKK30KKwordm9pZCBS ZW5kZXJNYXRoTUxPcGVyYXRvcjo6c2V0T3BlcmF0b3JGbGFnRnJvbUF0dHJpYnV0ZVZhbHVlKE1h dGhNTE9wZXJhdG9yRGljdGlvbmFyeTo6RmxhZyBmbGFnLCBjb25zdCBBdG9taWNTdHJpbmcmIGF0 dHJpYnV0ZVZhbHVlKQorewogICAgIEFTU0VSVCghaXNBbm9ueW1vdXMoKSk7Ci0gICAgY29uc3Qg QXRvbWljU3RyaW5nJiBhdHRyaWJ1dGVWYWx1ZSA9IGVsZW1lbnQoKS5mYXN0R2V0QXR0cmlidXRl KG5hbWUpOworCiAgICAgaWYgKGF0dHJpYnV0ZVZhbHVlID09ICJ0cnVlIikKICAgICAgICAgbV9v cGVyYXRvckZsYWdzIHw9IGZsYWc7CiAgICAgZWxzZSBpZiAoYXR0cmlidXRlVmFsdWUgPT0gImZh bHNlIikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVy TWF0aE1MT3BlcmF0b3IuaCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9tYXRobWwvUmVuZGVy TWF0aE1MT3BlcmF0b3IuaAppbmRleCAwYzAwMTI4Li5lNjYwNDI0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvbWF0aG1sL1JlbmRlck1hdGhNTE9wZXJhdG9yLmgKKysrIGIv U291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL21hdGhtbC9SZW5kZXJNYXRoTUxPcGVyYXRvci5oCkBA IC03OSw2ICs3OSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHVwZGF0ZVRva2VuQ29udGVudChjb25z dCBTdHJpbmcmIG9wZXJhdG9yU3RyaW5nKTsKICAgICB2b2lkIHVwZGF0ZVRva2VuQ29udGVudCgp IG92ZXJyaWRlIGZpbmFsOwogICAgIHZvaWQgdXBkYXRlT3BlcmF0b3JQcm9wZXJ0aWVzKCk7Cisg ICAgdm9pZCBzZXRPcGVyYXRvckZsYWdBbmRTY2hlZHVsZUxheW91dElmTmVlZGVkKE1hdGhNTE9w ZXJhdG9yRGljdGlvbmFyeTo6RmxhZywgY29uc3QgQXRvbWljU3RyaW5nJiBhdHRyaWJ1dGVWYWx1 ZSk7CiAKIHByb3RlY3RlZDoKICAgICB2aXJ0dWFsIGNvbnN0IGNoYXIqIHJlbmRlck5hbWUoKSBj b25zdCBvdmVycmlkZSB7IHJldHVybiBpc0Fub255bW91cygpID8gIlJlbmRlck1hdGhNTE9wZXJh dG9yIChhbm9ueW1vdXMpIiA6ICJSZW5kZXJNYXRoTUxPcGVyYXRvciI7IH0KQEAgLTE4Niw2ICsx ODcsNyBAQCBwcm90ZWN0ZWQ6CiAgICAgTGF5b3V0VW5pdCBtX21heFNpemU7CiAKICAgICB2b2lk IHNldE9wZXJhdG9yRmxhZ0Zyb21BdHRyaWJ1dGUoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5OjpG bGFnLCBjb25zdCBRdWFsaWZpZWROYW1lJik7CisgICAgdm9pZCBzZXRPcGVyYXRvckZsYWdGcm9t QXR0cmlidXRlVmFsdWUoTWF0aE1MT3BlcmF0b3JEaWN0aW9uYXJ5OjpGbGFnLCBjb25zdCBBdG9t aWNTdHJpbmcmIGF0dHJpYnV0ZVZhbHVlKTsKICAgICB2b2lkIHNldE9wZXJhdG9yUHJvcGVydGll c0Zyb21PcERpY3RFbnRyeShjb25zdCBNYXRoTUxPcGVyYXRvckRpY3Rpb25hcnk6OkVudHJ5Kik7 CiAgICAgdmlydHVhbCB2b2lkIFNldE9wZXJhdG9yUHJvcGVydGllcygpOwogfTsK