38231 2010-04-27 17:06:40 -0700 crash in WebCore::CompositeEditCommand::splitTreeToNode when indenting pre 2010-07-09 21:21:07 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) PC OS X 10.5 RESOLVED FIXED P2 Normal --- 1 ojan webkit-unassigned adele commit-queue enrica rniwa tony oldest_to_newest 218060 0 ojan 2010-04-27 17:06:40 -0700 Happens as far back as r31256 (oldest chromium archive). The attached test case demonstrates the crash. See http://crbug.com/42667 for more details (was hit in gmail). 218164 1 tony 2010-04-27 19:55:35 -0700 Can you try attaching the test case again? Thanks. 218198 2 ojan 2010-04-27 22:16:39 -0700 Sorry, don't know how that didn't attach. Anyways, it's attached in the crbug.com link. 218222 3 54526 tony 2010-04-27 23:37:45 -0700 Created attachment 54526 test case 218241 4 54532 tony 2010-04-28 00:45:06 -0700 Created attachment 54532 Patch 218247 5 tony 2010-04-28 00:49:49 -0700 Here's a test case with a closed pre. I've also posted a patch, but it's wrong. It's just showing some of the things I tried. There are two problems. First is that CompositeEditCommand::cloneParagraphUnderNewElement expects paragraphs to map to nodes. However, with <pre>, paragraphs can be strings of text. For example, in the test case, we have: <pre>a b </pre> a and b are both separate paragraphs. However, when we try to clone the paragraphs, we clone the whole pre node. I tried modifying cloneParagraphUnderNewElement to handle the case where we're only cloning part of a node (see patch). The second problem is in IndentOutdentCommand::indentRegion. It has similar logic that keeps track of the next paragraph to indent. Unfortunately, after the first indent, |endOfNextParagraph| is pointing to the wrong place since we just removed text from the <pre> node causing the node offset to be wrong. I tried to fix that in the patch as well, but it doesn't properly update |endAfterSelection|. This seems very fragile, so maybe someone has some better ideas. For example, maybe rather than trying to indent each paragraph, we would try to do a single indent if everything is in a single node. Or maybe we can split the pre into multiple pre tags before we start moving paragraphs. Thoughts? 218391 6 54532 ojan 2010-04-28 07:40:39 -0700 Comment on attachment 54532 Patch > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index a91efb68da9a3f83287d760013e02df18a64a864..4a0842fed9d643c7183cb1aaa31b179f52965110 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > + No new tests. (OOPS!) Add test? > +++ b/WebCore/editing/CompositeEditCommand.cpp > @@ -754,7 +754,15 @@ void CompositeEditCommand::cloneParagraphUnderNewElement(Position& start, Positi > Vector<RefPtr<Node> > ancestors; > > // Insert each node from innerNode to outerNode (excluded) in a list. > - for (Node* n = start.node(); n && n != outerNode; n = n->parentNode()) > + Node* n = start.node(); > + if (start.node() == end.node()) { > + ASSERT(start.node()->isTextNode()); > + String text = plainText(Range::create(document(), start, end).get()); > + ancestors.append(document()->createTextNode(text)); > + n = n->parentNode(); > + } I don't really get this. What does creating a new text node fix? Maybe this deserves a comment? > +++ b/WebCore/editing/IndentOutdentCommand.cpp > @@ -154,11 +154,17 @@ void IndentOutdentCommand::indentRegion(const VisiblePosition& startOfSelection, Maybe this deserves a comment about why this case needs to recompute positions? > + if (recomputePositions) > + endOfNextParagraph = endOfParagraph(startOfCurrentParagraph); Does startOfCurrentParagraph exist? 218397 7 ojan 2010-04-28 07:53:31 -0700 (In reply to comment #6) > I don't really get this. What does creating a new text node fix? Maybe this > deserves a comment? nm. I hadn't seen comment #5 before looking at the code. I get it now. 218456 8 rniwa 2010-04-28 10:18:34 -0700 (In reply to comment #5) > This seems very fragile, so maybe someone has some better ideas. For example, > maybe rather than trying to indent each paragraph, we would try to do a single > indent if everything is in a single node. Or maybe we can split the pre into > multiple pre tags before we start moving paragraphs. Thoughts? In my broken fix for indentation, I did that. In particular extendRangeToWrappingNodes in htmlediting.cpp extends the range as much as possible. See http://trac.webkit.org/changeset/46142 for usage. > - for (Node* n = start.node(); n && n != outerNode; n = n->parentNode()) > + Node* n = start.node(); > + if (start.node() == end.node()) { > + ASSERT(start.node()->isTextNode()); > + String text = plainText(Range::create(document(), start, end).get()); > + ancestors.append(document()->createTextNode(text)); > + n = n->parentNode(); > + } > + > + for (; n && n != outerNode; n = n->parentNode()) I'm not fully convinced that when start.node() == end.node(), it should be a text node. And also I'm not a fun to making cloneParagraphUnderNewElement smarter unless cloneParagraph is doing something unexpected. 224453 9 55814 tony 2010-05-12 00:35:38 -0700 Created attachment 55814 Patch 224454 10 tony 2010-05-12 00:37:59 -0700 (In reply to comment #9) > Created an attachment (id=55814) [details] > Patch Here's another attempt at fixing the crash. The patch splits text nodes along paragraph boundaries before trying to indent. This prevents the crash, although there are a few cases (e.g., when tables are involved) that we do the wrong thing. 224455 11 tony 2010-05-12 00:40:08 -0700 (In reply to comment #8) > In my broken fix for indentation, I did that. In particular extendRangeToWrappingNodes in htmlediting.cpp extends the range as much as possible. See http://trac.webkit.org/changeset/46142 for usage. Oh, so I tried this, but I wasn't able to use extendRangeToWrappingNodes because there are cases where we would still be within a single text node. For example: <pre> one two three </pre> If you want to indent only "two", extendRangeToWrappingNodes would end up including "one" and "three" as well. 241072 12 55814 abarth 2010-06-21 19:42:58 -0700 Comment on attachment 55814 Patch @Ojan: This patch is calling out for your review! 241307 13 55814 enrica 2010-06-22 10:02:23 -0700 Comment on attachment 55814 Patch > diff --git a/LayoutTests/ChangeLog b/LayoutTests/ChangeLog > index 4dc9e8e05791fadb3e720b13f0e8e89db4975aa3..00771643fc6e56ee7c894d53a5a71e543806c352 100644 > --- a/LayoutTests/ChangeLog > +++ b/LayoutTests/ChangeLog > @@ -1,3 +1,13 @@ > +2010-05-12 Tony Chang <tony@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + crash in WebCore::CompositeEditCommand::splitTreeToNode when indenting pre > + https://bugs.webkit.org/show_bug.cgi?id=38231 > + > + * editing/execCommand/indent-pre-expected.txt: Added. > + * editing/execCommand/indent-pre.html: Added. > + > 2010-05-11 Tony Chang <tony@chromium.org> > > Reviewed by Darin Fisher. > diff --git a/LayoutTests/editing/execCommand/indent-pre-expected.txt b/LayoutTests/editing/execCommand/indent-pre-expected.txt > new file mode 100644 > index 0000000000000000000000000000000000000000..883a704e8bd4e99bba9300fe30813c566363a586 > --- /dev/null > +++ b/LayoutTests/editing/execCommand/indent-pre-expected.txt > @@ -0,0 +1,179 @@ > + > +<HTML> > +<HEAD> > +</HEAD> > +<BODY> > +<DIV contentEditable=""> > +<#text> > +</#text> > +<BLOCKQUOTE style="margin: 0 0 0 40px; border: none; padding: 0px;" class="webkit-indent-blockquote"> > +<PRE id="pre-basic"> > +<#text>line one > +</#text> > +</PRE> > +</BLOCKQUOTE> > +<PRE id="pre-basic"> > +<#text>line two > +</#text> > +</PRE> > +<BLOCKQUOTE style="margin: 0 0 0 40px; border: none; padding: 0px;" class="webkit-indent-blockquote"> > +<PRE id="pre-basic"> > +<#text>line three > +</#text> > +</PRE> > +<PRE id="pre-basic"> > +<#text>line four</#text> > +</PRE> > +</BLOCKQUOTE> > +<#text> > + > +</#text> > +<UL> > +<LI> > +<PRE id="pre-list"> > +<#text>list one > +</#text> > +<BLOCKQUOTE style="margin: 0 0 0 40px; border: none; padding: 0px;" class="webkit-indent-blockquote"> > +<#text>list two > +</#text> > +<#text>list three > +</#text> > +</BLOCKQUOTE> > +<#text>list four > +</#text> > +</PRE> > +</LI> > +</UL> > +<#text> > + > +</#text> > +<BLOCKQUOTE style="margin: 0 0 0 40px; border: none; padding: 0px;" class="webkit-indent-blockquote"> > +<TABLE> > +<#text> > +</#text> > +<TBODY> > +<TR> > +<TD> > +<PRE id="pre-table"> > +<#text>table one > +</#text> > +<#text><selection-anchor>table two > +</#text> > +</PRE> > +<BLOCKQUOTE style="margin: 0 0 0 40px; border: none; padding: 0px;" class="webkit-indent-blockquote"> > +<PRE id="pre-table"> > +<#text>table three<selection-focus></#text> > +</PRE> > +<PRE id="pre-table"> > +<#text>table three</#text> > +</PRE> > +</BLOCKQUOTE> > +</TD> > +<TD> > +<BLOCKQUOTE style="margin: 0 0 0 40px; border: none; padding: 0px;" class="webkit-indent-blockquote"> > +<#text>right cell</#text> > +</BLOCKQUOTE> > +</TD> > +</TR> > +</TBODY> > +</TABLE> > +<DIV id="results"> > +<#text>PASSED</#text> > +</DIV> > +</BLOCKQUOTE> > +<#text> > + > +</#text> > +<#text> > +</#text> > +</DIV> > +<#text> > + > +</#text> > +<A href="javascript:document.execCommand('indent')"> > +<#text>indent</#text> > +</A> > +<#text> > +</#text> > +<A href="javascript:document.execCommand('outdent')"> > +<#text>outdent</#text> > +</A> > +<#text> > +</#text> > +<SCRIPT src="../../resources/dump-as-markup.js"></SCRIPT> > +<#text> > +</#text> > +<SCRIPT src="../editing.js"></SCRIPT> > +<#text> > +</#text> > +<SCRIPT> > +function setSelection(node, startOffset, endOffset) > +{ > +var textNode = node.firstChild; > +if (textNode.nodeType != Node.TEXT_NODE) > +throw "Wrong node type: " + textNode; > +execSetSelectionCommand(textNode, startOffset, endOffset); > +} > + > +function verifyTextSelection(startNode, startOffset, endNode, endOffset) > +{ > +if (startNode.nodeType != Node.TEXT_NODE) > +console.log("Wrong start node type: " + startNode); > +if (endNode.nodeType != Node.TEXT_NODE) > +console.log("Wrong end node type: " + endNode); > +var sel = window.getSelection(); > +if (sel.anchorNode != startNode || sel.focusNode != endNode) > +console.log("Wrong node selected."); > +if (sel.anchorOffset != startOffset) > +console.log("Wrong anchor offset: " + sel.anchorOffset + " instead of " + startOffset); > +if (sel.focusOffset != endOffset) > +console.log("Wrong focus offset: " + sel.focusOffset + " instead of " + endOffset); > +} > + > +// Indent a single line in a pre and make sure the selection is correctly preserved. > +var pre = document.getElementById("pre-basic"); > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByCharacterCommand(); > +execExtendSelectionForwardByWordCommand(); > +document.execCommand("indent"); > +verifyTextSelection(document.getElementsByTagName("pre")[0].firstChild, 1, > +document.getElementsByTagName("pre")[0].firstChild, 4); > + > +// Indent 2 lines. > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +execExtendSelectionForwardByWordCommand(); > +document.execCommand("indent"); > +if (document.getElementsByTagName("pre").length > 3) { > +// FIXME: The selection for the anchorNode is wrong. It should be (pre[2], 0). > +verifyTextSelection(document.getElementsByTagName("pre")[1].firstChild, 8, > +document.getElementsByTagName("pre")[3].firstChild, 4); > +} else { > +console.log("Wrong number of pre nodes."); > +} > +// Indent <pre> lines in a list. > +pre = document.getElementById("pre-list"); > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +document.execCommand("indent"); > +verifyTextSelection(document.getElementsByTagName("blockquote")[2].firstChild, 0, > +document.getElementsByTagName("blockquote")[2].firstChild.nextSibling, 10); > + > +// Indenting <pre> lines in a table. > +pre = document.getElementById("pre-table"); > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +// FIXME: This is wrong. > +document.execCommand("indent"); > + > +document.getElementById("results").innerText = "PASSED"; > +</SCRIPT> > +<#text> > +</#text> > +</BODY> > +</HTML> > diff --git a/LayoutTests/editing/execCommand/indent-pre.html b/LayoutTests/editing/execCommand/indent-pre.html > new file mode 100644 > index 0000000000000000000000000000000000000000..0641c844de9fdd8538d60461b5c1525798ae1f90 > --- /dev/null > +++ b/LayoutTests/editing/execCommand/indent-pre.html > @@ -0,0 +1,91 @@ > +<div contentEditable> > +<pre id="pre-basic">line one > +line two > +line three > +line four</pre> > + > +<ul><li><pre id="pre-list">list one > +list two > +list three > +list four > +</pre></li></ul> > + > +<table> > +<tr><td><pre id="pre-table">table one > +table two > +table three</pre></td><td>right cell</td></tr></table> > + > +<div id="results">FAILED</div> > +</div> > + > +<a href="javascript:document.execCommand('indent')">indent</a> > +<a href="javascript:document.execCommand('outdent')">outdent</a> > +<script src="../../resources/dump-as-markup.js"></script> > +<script src="../editing.js"></script> > +<script> > +function setSelection(node, startOffset, endOffset) > +{ > + var textNode = node.firstChild; > + if (textNode.nodeType != Node.TEXT_NODE) > + throw "Wrong node type: " + textNode; > + execSetSelectionCommand(textNode, startOffset, endOffset); > +} > + > +function verifyTextSelection(startNode, startOffset, endNode, endOffset) > +{ > + if (startNode.nodeType != Node.TEXT_NODE) > + console.log("Wrong start node type: " + startNode); > + if (endNode.nodeType != Node.TEXT_NODE) > + console.log("Wrong end node type: " + endNode); > + var sel = window.getSelection(); > + if (sel.anchorNode != startNode || sel.focusNode != endNode) > + console.log("Wrong node selected."); > + if (sel.anchorOffset != startOffset) > + console.log("Wrong anchor offset: " + sel.anchorOffset + " instead of " + startOffset); > + if (sel.focusOffset != endOffset) > + console.log("Wrong focus offset: " + sel.focusOffset + " instead of " + endOffset); > +} > + > +// Indent a single line in a pre and make sure the selection is correctly preserved. > +var pre = document.getElementById("pre-basic"); > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByCharacterCommand(); > +execExtendSelectionForwardByWordCommand(); > +document.execCommand("indent"); > +verifyTextSelection(document.getElementsByTagName("pre")[0].firstChild, 1, > + document.getElementsByTagName("pre")[0].firstChild, 4); > + > +// Indent 2 lines. > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +execExtendSelectionForwardByWordCommand(); > +document.execCommand("indent"); > +if (document.getElementsByTagName("pre").length > 3) { > + // FIXME: The selection for the anchorNode is wrong. It should be (pre[2], 0). > + verifyTextSelection(document.getElementsByTagName("pre")[1].firstChild, 8, > + document.getElementsByTagName("pre")[3].firstChild, 4); > +} else { > + console.log("Wrong number of pre nodes."); > +} > +// Indent <pre> lines in a list. > +pre = document.getElementById("pre-list"); > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +document.execCommand("indent"); > +verifyTextSelection(document.getElementsByTagName("blockquote")[2].firstChild, 0, > + document.getElementsByTagName("blockquote")[2].firstChild.nextSibling, 10); > + > +// Indenting <pre> lines in a table. > +pre = document.getElementById("pre-table"); > +setSelection(pre, 0, 0); > +execMoveSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +execExtendSelectionForwardByLineCommand(); > +// FIXME: This is wrong. > +document.execCommand("indent"); > + > +document.getElementById("results").innerText = "PASSED"; > +</script> > diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog > index 482ee438dd8109f3a9b4b4105770931a21c640fc..266ea14b48c21c1f7d97320797651fc5f3f033bf 100644 > --- a/WebCore/ChangeLog > +++ b/WebCore/ChangeLog > @@ -1,3 +1,19 @@ > +2010-05-12 Tony Chang <tony@chromium.org> > + > + Reviewed by NOBODY (OOPS!). > + > + crash in WebCore::CompositeEditCommand::splitTreeToNode when indenting pre > + https://bugs.webkit.org/show_bug.cgi?id=38231 > + > + Test: editing/execCommand/indent-pre.html > + > + * editing/IndentOutdentCommand.cpp: > + (WebCore::countParagraphs): > + (WebCore::IndentOutdentCommand::indentRegion): Split text nodes into one node per paragraph > + so moveParagraph doesn't get confused. > + (WebCore::IndentOutdentCommand::splitTextNodes): > + * editing/IndentOutdentCommand.h: > + > 2010-05-11 David Hyatt <hyatt@apple.com> > > Reviewed by Maciej Stachowiak. > diff --git a/WebCore/editing/IndentOutdentCommand.cpp b/WebCore/editing/IndentOutdentCommand.cpp > index 0f3975b0c13f6e8e93e32e8c659ab3b77b463f39..b68527d044ee3af7d12d7d6f2b605fba4f912290 100644 > --- a/WebCore/editing/IndentOutdentCommand.cpp > +++ b/WebCore/editing/IndentOutdentCommand.cpp > @@ -34,6 +34,7 @@ > #include "InsertListCommand.h" > #include "Range.h" > #include "SplitElementCommand.h" > +#include "Text.h" > #include "TextIterator.h" > #include "htmlediting.h" > #include "visible_units.h" > @@ -62,6 +63,22 @@ static bool isListOrIndentBlockquote(const Node* node) > return node && (node->hasTagName(ulTag) || node->hasTagName(olTag) || node->hasTagName(blockquoteTag)); > } > > +// This function can return -1 if we are unable to count the paragraphs between |start| and |end|. > +static int countParagraphs(const VisiblePosition& start, const VisiblePosition& end) > +{ > + int count = 0; > + VisiblePosition cur = start; > + while (cur != end) { > + ++count; > + cur = endOfParagraph(cur.next()); > + // If start is before a table and end is inside a table, we will never hit end because the > + // whole table is considered a single paragraph. > + if (cur.isNull()) > + return -1; > + } > + return count; > +} > + > IndentOutdentCommand::IndentOutdentCommand(Document* document, EIndentType typeOfAction, int marginInPixels) > : CompositeEditCommand(document), m_typeOfAction(typeOfAction), m_marginInPixels(marginInPixels) > { > @@ -151,6 +168,18 @@ void IndentOutdentCommand::indentRegion(const VisiblePosition& startOfSelection, > RefPtr<Element> blockquoteForNextIndent; > VisiblePosition endOfCurrentParagraph = endOfParagraph(startOfSelection); > VisiblePosition endAfterSelection = endOfParagraph(endOfParagraph(endOfSelection).next()); > + int endOfCurrentParagraphIndex = indexForVisiblePosition(endOfCurrentParagraph); > + int endAfterSelectionIndex = indexForVisiblePosition(endAfterSelection); > + > + // When indenting within a <pre> tag, we need to split each paragraph into a separate node for moveParagraphWithClones to work. > + // However, splitting text nodes can cause endOfCurrentParagraph and endAfterSelection to point to an invalid position if we > + // changed the text node it was pointing at. So we have to reset these positions. > + int numParagraphs = countParagraphs(endOfCurrentParagraph, endAfterSelection); > + if (splitTextNodes(startOfParagraph(startOfSelection), numParagraphs + 1)) { > + endOfCurrentParagraph = VisiblePosition(TextIterator::rangeFromLocationAndLength(document()->documentElement(), endOfCurrentParagraphIndex, 0)->startPosition(), UPSTREAM); > + endAfterSelection = VisiblePosition(TextIterator::rangeFromLocationAndLength(document()->documentElement(), endAfterSelectionIndex, 0)->startPosition(), UPSTREAM); > + } > + > while (endOfCurrentParagraph != endAfterSelection) { > // Iterate across the selected paragraphs... > VisiblePosition endOfNextParagraph = endOfParagraph(endOfCurrentParagraph.next()); > @@ -174,6 +203,28 @@ void IndentOutdentCommand::indentRegion(const VisiblePosition& startOfSelection, > } > } > > +// Returns true if at least one text node was split. > +bool IndentOutdentCommand::splitTextNodes(const VisiblePosition& start, int numParagraphs) > +{ > + VisiblePosition currentParagraphStart = start; > + bool hasSplit = false; > + int paragraphCount; > + for (paragraphCount = 0; paragraphCount < numParagraphs; ++paragraphCount) { > + if (currentParagraphStart.deepEquivalent().node()->isTextNode() && currentParagraphStart.deepEquivalent().node() == startOfParagraph(currentParagraphStart.previous()).deepEquivalent().node()) { > + Text* textNode = static_cast<Text *>(currentParagraphStart.deepEquivalent().node()); > + int offset = currentParagraphStart.deepEquivalent().offsetInContainerNode(); > + splitTextNode(textNode, offset); > + currentParagraphStart = VisiblePosition(textNode, 0, VP_DEFAULT_AFFINITY); > + hasSplit = true; > + } > + VisiblePosition nextParagraph = startOfParagraph(endOfParagraph(currentParagraphStart).next()); > + if (nextParagraph.isNull()) > + break; > + currentParagraphStart = nextParagraph; > + } > + return hasSplit; > +} > + > void IndentOutdentCommand::outdentParagraph() > { > VisiblePosition visibleStartOfParagraph = startOfParagraph(endingSelection().visibleStart()); > diff --git a/WebCore/editing/IndentOutdentCommand.h b/WebCore/editing/IndentOutdentCommand.h > index 8705bf103c22122298d1e8495dc007e9c2580911..8644cc56aa82083052e52e7a654a460fef3db964 100644 > --- a/WebCore/editing/IndentOutdentCommand.h > +++ b/WebCore/editing/IndentOutdentCommand.h > @@ -51,6 +51,7 @@ private: > void outdentParagraph(); > bool tryIndentingAsListItem(const VisiblePosition&); > void indentIntoBlockquote(const VisiblePosition&, const VisiblePosition&, RefPtr<Element>&); > + bool splitTextNodes(const VisiblePosition& start, int numParagraphs); > > EIndentType m_typeOfAction; > int m_marginInPixels; The patch looks good to me. 247641 14 55814 ojan 2010-07-07 11:03:42 -0700 Comment on attachment 55814 Patch Please do the non-nits before committing. --------------------------------- http://wkrietveld.appspot.com/38231/diff/1/4 File LayoutTests/editing/execCommand/indent-pre.html (right): http://wkrietveld.appspot.com/38231/diff/1/4#newcode51 LayoutTests/editing/execCommand/indent-pre.html:51: setSelection(pre, 0, 0); Nit: You always set the selection to the start of the node. May as well make a setSelection function that takes only the element to set the selection in. http://wkrietveld.appspot.com/38231/diff/1/4#newcode66 LayoutTests/editing/execCommand/indent-pre.html:66: verifyTextSelection(document.getElementsByTagName("pre")[1].firstChild, 8, I'd rather see this have the value is supposed to have and just have the test output output a failure for this line. That way, if someone accidentally fixes this, it'll be more clear looking at just the test output that they've improved it. It's good to leave a FIXME in as well. Also, is there a bug for this you can link to? http://wkrietveld.appspot.com/38231/diff/1/4#newcode87 LayoutTests/editing/execCommand/indent-pre.html:87: // FIXME: This is wrong. Can you do the same as I suggested above? Call verifyTextSelection with what the correct output should be? It's fine to have failures in the test output for cases where we have bugs to fix. http://wkrietveld.appspot.com/38231/diff/1/6 File WebCore/editing/IndentOutdentCommand.cpp (right): http://wkrietveld.appspot.com/38231/diff/1/6#newcode67 WebCore/editing/IndentOutdentCommand.cpp:67: static int countParagraphs(const VisiblePosition& start, const VisiblePosition& end) This variable names should be changed to show that they are VisiblePositions that are at the end of paragraphs. Otherwise, the condition in the while loop below makes no sense. http://wkrietveld.appspot.com/38231/diff/1/6#newcode209 WebCore/editing/IndentOutdentCommand.cpp:209: if (currentParagraphStart.deepEquivalent().node()->isTextNode() && currentParagraphStart.deepEquivalent().node() == startOfParagraph(currentParagraphStart.previous()).deepEquivalent().node()) { Nit: It took me a while to figure out that this is restricting to cases where we have multiple paragraphs across a single text node. A short comment explaining that might be good. 249383 15 61121 tony 2010-07-09 17:38:06 -0700 Created attachment 61121 Patch for landing 249465 16 61121 commit-queue 2010-07-09 21:21:02 -0700 Comment on attachment 61121 Patch for landing Clearing flags on attachment: 61121 Committed r63039: <http://trac.webkit.org/changeset/63039> 249466 17 commit-queue 2010-07-09 21:21:07 -0700 All reviewed patches have been landed. Closing bug. 54526 2010-04-27 23:37:45 -0700 2010-04-27 23:37:45 -0700 test case scratch.html text/html 171 tony PGRpdiBjb250ZW50RWRpdGFibGU+PHByZSBpZD1mb28+YQpiCgo8L3ByZT48L2Rpdj4KPHNjcmlw dD4Kd2luZG93LmdldFNlbGVjdGlvbigpLnNldEJhc2VBbmRFeHRlbnQoZm9vLCAwLCBmb28sIDIp Owpkb2N1bWVudC5leGVjQ29tbWFuZCgnaW5kZW50JywgZmFsc2UsIG51bGwpOwo8L3NjcmlwdD4K 54532 2010-04-28 00:45:06 -0700 2010-05-12 00:35:32 -0700 Patch bug-38231-20100428164504.patch text/plain 3264 tony ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YTkxZWZiNjhkYTlhM2Y4MzI4N2Q3NjAwMTNlMDJkZjE4YTY0YTg2NC4uNGEwODQyZmVkOWQ2NDNj NzE4M2NiMWFhYTMxYjE3OWY1Mjk2NTExMCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNyBAQAorMjAxMC0wNC0yOCAgVG9u eSBDaGFuZyAgPHRvbnlAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIGNyYXNoIGluIFdlYkNvcmU6OkNvbXBvc2l0ZUVkaXRDb21t YW5kOjpzcGxpdFRyZWVUb05vZGUgd2hlbiBpbmRlbnRpbmcgaW4gYW4gdW5jbG9zZWQgcHJlCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODIzMQorCisg ICAgICAgIE5vIG5ldyB0ZXN0cy4gKE9PUFMhKQorCisgICAgICAgICogZWRpdGluZy9Db21wb3Np dGVFZGl0Q29tbWFuZC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29tbWFu ZDo6Y2xvbmVQYXJhZ3JhcGhVbmRlck5ld0VsZW1lbnQpOgorICAgICAgICAqIGVkaXRpbmcvSW5k ZW50T3V0ZGVudENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6SW5kZW50T3V0ZGVudENv bW1hbmQ6OmluZGVudFJlZ2lvbik6CisKIDIwMTAtMDQtMjcgIFNoaW5pY2hpcm8gSGFtYWppICA8 aGFtYWppQGNocm9taXVtLm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlciBh bmQgRXJpYyBTZWlkZWwuCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRp dENvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcApp bmRleCA5ZGM5MThkMWVjYWU1MDRhNTEyMTg3MTlkYmRlMmRmMWYzNGM4YTM5Li5jYzBkNDNhMzNi NGE2YmViYTJlMWM3YWQwNzBmOWE3MGU2N2MzMjgyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRp bmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9Db21wb3Np dGVFZGl0Q29tbWFuZC5jcHAKQEAgLTc1NCw3ICs3NTQsMTUgQEAgdm9pZCBDb21wb3NpdGVFZGl0 Q29tbWFuZDo6Y2xvbmVQYXJhZ3JhcGhVbmRlck5ld0VsZW1lbnQoUG9zaXRpb24mIHN0YXJ0LCBQ b3NpdGkKICAgICAgICAgVmVjdG9yPFJlZlB0cjxOb2RlPiA+IGFuY2VzdG9yczsKICAgICAgICAg CiAgICAgICAgIC8vIEluc2VydCBlYWNoIG5vZGUgZnJvbSBpbm5lck5vZGUgdG8gb3V0ZXJOb2Rl IChleGNsdWRlZCkgaW4gYSBsaXN0LgotICAgICAgICBmb3IgKE5vZGUqIG4gPSBzdGFydC5ub2Rl KCk7IG4gJiYgbiAhPSBvdXRlck5vZGU7IG4gPSBuLT5wYXJlbnROb2RlKCkpCisgICAgICAgIE5v ZGUqIG4gPSBzdGFydC5ub2RlKCk7CisgICAgICAgIGlmIChzdGFydC5ub2RlKCkgPT0gZW5kLm5v ZGUoKSkgeworICAgICAgICAgICAgQVNTRVJUKHN0YXJ0Lm5vZGUoKS0+aXNUZXh0Tm9kZSgpKTsK KyAgICAgICAgICAgIFN0cmluZyB0ZXh0ID0gcGxhaW5UZXh0KFJhbmdlOjpjcmVhdGUoZG9jdW1l bnQoKSwgc3RhcnQsIGVuZCkuZ2V0KCkpOworICAgICAgICAgICAgYW5jZXN0b3JzLmFwcGVuZChk b2N1bWVudCgpLT5jcmVhdGVUZXh0Tm9kZSh0ZXh0KSk7CisgICAgICAgICAgICBuID0gbi0+cGFy ZW50Tm9kZSgpOworICAgICAgICB9CisKKyAgICAgICAgZm9yICg7IG4gJiYgbiAhPSBvdXRlck5v ZGU7IG4gPSBuLT5wYXJlbnROb2RlKCkpCiAgICAgICAgICAgICBhbmNlc3RvcnMuYXBwZW5kKG4p OwogCiAgICAgICAgIC8vIENsb25lIGV2ZXJ5IG5vZGUgYmV0d2VlbiBzdGFydC5ub2RlKCkgYW5k IG91dGVyQmxvY2suCmRpZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENv bW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNwcAppbmRl eCAwZjM5NzViMGMxM2Y2ZThlOTNlMzJlOGM2NTlhYjNiNzdiNDYzZjM5Li42NTFiMjJhZDdhMDVk ZTNhMDg5OTMyZDVmMDQ1MTI4MTNiMTBkZjY1IDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcv SW5kZW50T3V0ZGVudENvbW1hbmQuY3BwCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRk ZW50Q29tbWFuZC5jcHAKQEAgLTE1NCwxMSArMTU0LDE3IEBAIHZvaWQgSW5kZW50T3V0ZGVudENv bW1hbmQ6OmluZGVudFJlZ2lvbihjb25zdCBWaXNpYmxlUG9zaXRpb24mIHN0YXJ0T2ZTZWxlY3Rp b24sCiAgICAgd2hpbGUgKGVuZE9mQ3VycmVudFBhcmFncmFwaCAhPSBlbmRBZnRlclNlbGVjdGlv bikgewogICAgICAgICAvLyBJdGVyYXRlIGFjcm9zcyB0aGUgc2VsZWN0ZWQgcGFyYWdyYXBocy4u LgogICAgICAgICBWaXNpYmxlUG9zaXRpb24gZW5kT2ZOZXh0UGFyYWdyYXBoID0gZW5kT2ZQYXJh Z3JhcGgoZW5kT2ZDdXJyZW50UGFyYWdyYXBoLm5leHQoKSk7CisgICAgICAgIGJvb2wgcmVjb21w dXRlUG9zaXRpb25zID0gZW5kT2ZOZXh0UGFyYWdyYXBoLmRlZXBFcXVpdmFsZW50KCkubm9kZSgp ID09IGVuZE9mQ3VycmVudFBhcmFncmFwaC5kZWVwRXF1aXZhbGVudCgpLm5vZGUoKTsKKyAgICAg ICAgVmlzaWJsZVBvc2l0aW9uIHN0YXJ0T2ZDdXJyZW50UGFyYWdyYXBoID0gc3RhcnRPZlBhcmFn cmFwaChlbmRPZkN1cnJlbnRQYXJhZ3JhcGgpOworCiAgICAgICAgIGlmICh0cnlJbmRlbnRpbmdB c0xpc3RJdGVtKGVuZE9mQ3VycmVudFBhcmFncmFwaCkpCiAgICAgICAgICAgICBibG9ja3F1b3Rl Rm9yTmV4dEluZGVudCA9IDA7CiAgICAgICAgIGVsc2UKICAgICAgICAgICAgIGluZGVudEludG9C bG9ja3F1b3RlKGVuZE9mQ3VycmVudFBhcmFncmFwaCwgZW5kT2ZOZXh0UGFyYWdyYXBoLCBibG9j a3F1b3RlRm9yTmV4dEluZGVudCk7CiAKKyAgICAgICAgaWYgKHJlY29tcHV0ZVBvc2l0aW9ucykK KyAgICAgICAgICAgIGVuZE9mTmV4dFBhcmFncmFwaCA9IGVuZE9mUGFyYWdyYXBoKHN0YXJ0T2ZD dXJyZW50UGFyYWdyYXBoKTsKKwogICAgICAgICAvLyBpbmRlbnRJbnRvQmxvY2txdW90ZSBjb3Vs ZCBtb3ZlIG1vcmUgdGhhbiBvbmUgcGFyYWdyYXBoIGlmIHRoZSBwYXJhZ3JhcGgKICAgICAgICAg Ly8gaXMgaW4gYSBsaXN0IGl0ZW0gb3IgYSB0YWJsZS4gQXMgYSByZXN1bHQsIGVuZEFmdGVyU2Vs ZWN0aW9uIGNvdWxkIHJlZmVyIHRvIGEgcG9zaXRpb24KICAgICAgICAgLy8gbm8gbG9uZ2VyIGlu IHRoZSBkb2N1bWVudC4K 55814 2010-05-12 00:35:38 -0700 2010-07-09 17:37:59 -0700 Patch bug-38231-20100512163536.patch text/plain 15441 tony ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCA0ZGM5ZThlMDU3OTFmYWRiM2U3MjBiMTNmMGU4ZTg5ZGI0OTc1YWEzLi4wMDc3MTY0 M2ZjNmU1NmVlN2M4OTRkNTNhNWE3MWU1NDM4MDZjMzUyIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMTAtMDUtMTIgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBjcmFzaCBpbiBXZWJDb3JlOjpD b21wb3NpdGVFZGl0Q29tbWFuZDo6c3BsaXRUcmVlVG9Ob2RlIHdoZW4gaW5kZW50aW5nIHByZQor ICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MzgyMzEKKwor ICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvaW5kZW50LXByZS1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIGVkaXRpbmcvZXhlY0NvbW1hbmQvaW5kZW50LXByZS5odG1sOiBBZGRl ZC4KKwogMjAxMC0wNS0xMSAgVG9ueSBDaGFuZyAgPHRvbnlAY2hyb21pdW0ub3JnPgogCiAgICAg ICAgIFJldmlld2VkIGJ5IERhcmluIEZpc2hlci4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Vk aXRpbmcvZXhlY0NvbW1hbmQvaW5kZW50LXByZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL2V4ZWNDb21tYW5kL2luZGVudC1wcmUtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjg4 M2E3MDRlOGJkNGU5OWJiYTkzMDBmZTMwODEzYzU2NjM2M2E1ODYKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kL2luZGVudC1wcmUtZXhwZWN0ZWQudHh0 CkBAIC0wLDAgKzEsMTc5IEBACisKKzxIVE1MPgorPEhFQUQ+Cis8L0hFQUQ+Cis8Qk9EWT4KKzxE SVYgY29udGVudEVkaXRhYmxlPSIiPgorPCN0ZXh0PgorPC8jdGV4dD4KKzxCTE9DS1FVT1RFIHN0 eWxlPSJtYXJnaW46IDAgMCAwIDQwcHg7IGJvcmRlcjogbm9uZTsgcGFkZGluZzogMHB4OyIgY2xh c3M9IndlYmtpdC1pbmRlbnQtYmxvY2txdW90ZSI+Cis8UFJFIGlkPSJwcmUtYmFzaWMiPgorPCN0 ZXh0PmxpbmUgb25lCis8LyN0ZXh0PgorPC9QUkU+Cis8L0JMT0NLUVVPVEU+Cis8UFJFIGlkPSJw cmUtYmFzaWMiPgorPCN0ZXh0PmxpbmUgdHdvCis8LyN0ZXh0PgorPC9QUkU+Cis8QkxPQ0tRVU9U RSBzdHlsZT0ibWFyZ2luOiAwIDAgMCA0MHB4OyBib3JkZXI6IG5vbmU7IHBhZGRpbmc6IDBweDsi IGNsYXNzPSJ3ZWJraXQtaW5kZW50LWJsb2NrcXVvdGUiPgorPFBSRSBpZD0icHJlLWJhc2ljIj4K KzwjdGV4dD5saW5lIHRocmVlCis8LyN0ZXh0PgorPC9QUkU+Cis8UFJFIGlkPSJwcmUtYmFzaWMi PgorPCN0ZXh0PmxpbmUgZm91cjwvI3RleHQ+Cis8L1BSRT4KKzwvQkxPQ0tRVU9URT4KKzwjdGV4 dD4KKworPC8jdGV4dD4KKzxVTD4KKzxMST4KKzxQUkUgaWQ9InByZS1saXN0Ij4KKzwjdGV4dD5s aXN0IG9uZQorPC8jdGV4dD4KKzxCTE9DS1FVT1RFIHN0eWxlPSJtYXJnaW46IDAgMCAwIDQwcHg7 IGJvcmRlcjogbm9uZTsgcGFkZGluZzogMHB4OyIgY2xhc3M9IndlYmtpdC1pbmRlbnQtYmxvY2tx dW90ZSI+Cis8I3RleHQ+bGlzdCB0d28KKzwvI3RleHQ+Cis8I3RleHQ+bGlzdCB0aHJlZQorPC8j dGV4dD4KKzwvQkxPQ0tRVU9URT4KKzwjdGV4dD5saXN0IGZvdXIKKzwvI3RleHQ+Cis8L1BSRT4K KzwvTEk+Cis8L1VMPgorPCN0ZXh0PgorCis8LyN0ZXh0PgorPEJMT0NLUVVPVEUgc3R5bGU9Im1h cmdpbjogMCAwIDAgNDBweDsgYm9yZGVyOiBub25lOyBwYWRkaW5nOiAwcHg7IiBjbGFzcz0id2Vi a2l0LWluZGVudC1ibG9ja3F1b3RlIj4KKzxUQUJMRT4KKzwjdGV4dD4KKzwvI3RleHQ+Cis8VEJP RFk+Cis8VFI+Cis8VEQ+Cis8UFJFIGlkPSJwcmUtdGFibGUiPgorPCN0ZXh0PnRhYmxlIG9uZQor PC8jdGV4dD4KKzwjdGV4dD48c2VsZWN0aW9uLWFuY2hvcj50YWJsZSB0d28KKzwvI3RleHQ+Cis8 L1BSRT4KKzxCTE9DS1FVT1RFIHN0eWxlPSJtYXJnaW46IDAgMCAwIDQwcHg7IGJvcmRlcjogbm9u ZTsgcGFkZGluZzogMHB4OyIgY2xhc3M9IndlYmtpdC1pbmRlbnQtYmxvY2txdW90ZSI+Cis8UFJF IGlkPSJwcmUtdGFibGUiPgorPCN0ZXh0PnRhYmxlIHRocmVlPHNlbGVjdGlvbi1mb2N1cz48LyN0 ZXh0PgorPC9QUkU+Cis8UFJFIGlkPSJwcmUtdGFibGUiPgorPCN0ZXh0PnRhYmxlIHRocmVlPC8j dGV4dD4KKzwvUFJFPgorPC9CTE9DS1FVT1RFPgorPC9URD4KKzxURD4KKzxCTE9DS1FVT1RFIHN0 eWxlPSJtYXJnaW46IDAgMCAwIDQwcHg7IGJvcmRlcjogbm9uZTsgcGFkZGluZzogMHB4OyIgY2xh c3M9IndlYmtpdC1pbmRlbnQtYmxvY2txdW90ZSI+Cis8I3RleHQ+cmlnaHQgY2VsbDwvI3RleHQ+ Cis8L0JMT0NLUVVPVEU+Cis8L1REPgorPC9UUj4KKzwvVEJPRFk+Cis8L1RBQkxFPgorPERJViBp ZD0icmVzdWx0cyI+Cis8I3RleHQ+UEFTU0VEPC8jdGV4dD4KKzwvRElWPgorPC9CTE9DS1FVT1RF PgorPCN0ZXh0PgorCis8LyN0ZXh0PgorPCN0ZXh0PgorPC8jdGV4dD4KKzwvRElWPgorPCN0ZXh0 PgorCis8LyN0ZXh0PgorPEEgaHJlZj0iamF2YXNjcmlwdDpkb2N1bWVudC5leGVjQ29tbWFuZCgn aW5kZW50JykiPgorPCN0ZXh0PmluZGVudDwvI3RleHQ+Cis8L0E+Cis8I3RleHQ+Cis8LyN0ZXh0 PgorPEEgaHJlZj0iamF2YXNjcmlwdDpkb2N1bWVudC5leGVjQ29tbWFuZCgnb3V0ZGVudCcpIj4K KzwjdGV4dD5vdXRkZW50PC8jdGV4dD4KKzwvQT4KKzwjdGV4dD4KKzwvI3RleHQ+Cis8U0NSSVBU IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpzIj48L1NDUklQVD4KKzwjdGV4 dD4KKzwvI3RleHQ+Cis8U0NSSVBUIHNyYz0iLi4vZWRpdGluZy5qcyI+PC9TQ1JJUFQ+Cis8I3Rl eHQ+Cis8LyN0ZXh0PgorPFNDUklQVD4KK2Z1bmN0aW9uIHNldFNlbGVjdGlvbihub2RlLCBzdGFy dE9mZnNldCwgZW5kT2Zmc2V0KQorewordmFyIHRleHROb2RlID0gbm9kZS5maXJzdENoaWxkOwor aWYgKHRleHROb2RlLm5vZGVUeXBlICE9IE5vZGUuVEVYVF9OT0RFKQordGhyb3cgIldyb25nIG5v ZGUgdHlwZTogIiArIHRleHROb2RlOworZXhlY1NldFNlbGVjdGlvbkNvbW1hbmQodGV4dE5vZGUs IHN0YXJ0T2Zmc2V0LCBlbmRPZmZzZXQpOworfQorCitmdW5jdGlvbiB2ZXJpZnlUZXh0U2VsZWN0 aW9uKHN0YXJ0Tm9kZSwgc3RhcnRPZmZzZXQsIGVuZE5vZGUsIGVuZE9mZnNldCkKK3sKK2lmIChz dGFydE5vZGUubm9kZVR5cGUgIT0gTm9kZS5URVhUX05PREUpCitjb25zb2xlLmxvZygiV3Jvbmcg c3RhcnQgbm9kZSB0eXBlOiAiICsgc3RhcnROb2RlKTsKK2lmIChlbmROb2RlLm5vZGVUeXBlICE9 IE5vZGUuVEVYVF9OT0RFKQorY29uc29sZS5sb2coIldyb25nIGVuZCBub2RlIHR5cGU6ICIgKyBl bmROb2RlKTsKK3ZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CitpZiAoc2VsLmFuY2hv ck5vZGUgIT0gc3RhcnROb2RlIHx8IHNlbC5mb2N1c05vZGUgIT0gZW5kTm9kZSkKK2NvbnNvbGUu bG9nKCJXcm9uZyBub2RlIHNlbGVjdGVkLiIpOworaWYgKHNlbC5hbmNob3JPZmZzZXQgIT0gc3Rh cnRPZmZzZXQpCitjb25zb2xlLmxvZygiV3JvbmcgYW5jaG9yIG9mZnNldDogIiArIHNlbC5hbmNo b3JPZmZzZXQgKyAiIGluc3RlYWQgb2YgIiArIHN0YXJ0T2Zmc2V0KTsKK2lmIChzZWwuZm9jdXNP ZmZzZXQgIT0gZW5kT2Zmc2V0KQorY29uc29sZS5sb2coIldyb25nIGZvY3VzIG9mZnNldDogIiAr IHNlbC5mb2N1c09mZnNldCArICIgaW5zdGVhZCBvZiAiICsgZW5kT2Zmc2V0KTsKK30KKworLy8g SW5kZW50IGEgc2luZ2xlIGxpbmUgaW4gYSBwcmUgYW5kIG1ha2Ugc3VyZSB0aGUgc2VsZWN0aW9u IGlzIGNvcnJlY3RseSBwcmVzZXJ2ZWQuCit2YXIgcHJlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 SWQoInByZS1iYXNpYyIpOworc2V0U2VsZWN0aW9uKHByZSwgMCwgMCk7CitleGVjTW92ZVNlbGVj dGlvbkZvcndhcmRCeUNoYXJhY3RlckNvbW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxlY3Rpb25Gb3J3 YXJkQnlXb3JkQ29tbWFuZCgpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoImluZGVudCIpOwordmVy aWZ5VGV4dFNlbGVjdGlvbihkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJlIilbMF0u Zmlyc3RDaGlsZCwgMSwKK2RvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwcmUiKVswXS5m aXJzdENoaWxkLCA0KTsKKworLy8gSW5kZW50IDIgbGluZXMuCitzZXRTZWxlY3Rpb24ocHJlLCAw LCAwKTsKK2V4ZWNNb3ZlU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2V4ZWNFeHRl bmRTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlvbkZv cndhcmRCeVdvcmRDb21tYW5kKCk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgiaW5kZW50Iik7Citp ZiAoZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInByZSIpLmxlbmd0aCA+IDMpIHsKKy8v IEZJWE1FOiBUaGUgc2VsZWN0aW9uIGZvciB0aGUgYW5jaG9yTm9kZSBpcyB3cm9uZy4gSXQgc2hv dWxkIGJlIChwcmVbMl0sIDApLgordmVyaWZ5VGV4dFNlbGVjdGlvbihkb2N1bWVudC5nZXRFbGVt ZW50c0J5VGFnTmFtZSgicHJlIilbMV0uZmlyc3RDaGlsZCwgOCwKK2RvY3VtZW50LmdldEVsZW1l bnRzQnlUYWdOYW1lKCJwcmUiKVszXS5maXJzdENoaWxkLCA0KTsKK30gZWxzZSB7Citjb25zb2xl LmxvZygiV3JvbmcgbnVtYmVyIG9mIHByZSBub2Rlcy4iKTsKK30KKy8vIEluZGVudCA8cHJlPiBs aW5lcyBpbiBhIGxpc3QuCitwcmUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicHJlLWxpc3Qi KTsKK3NldFNlbGVjdGlvbihwcmUsIDAsIDApOworZXhlY01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlM aW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7 CitleGVjRXh0ZW5kU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2RvY3VtZW50LmV4 ZWNDb21tYW5kKCJpbmRlbnQiKTsKK3ZlcmlmeVRleHRTZWxlY3Rpb24oZG9jdW1lbnQuZ2V0RWxl bWVudHNCeVRhZ05hbWUoImJsb2NrcXVvdGUiKVsyXS5maXJzdENoaWxkLCAwLAorZG9jdW1lbnQu Z2V0RWxlbWVudHNCeVRhZ05hbWUoImJsb2NrcXVvdGUiKVsyXS5maXJzdENoaWxkLm5leHRTaWJs aW5nLCAxMCk7CisKKy8vIEluZGVudGluZyA8cHJlPiBsaW5lcyBpbiBhIHRhYmxlLgorcHJlID0g ZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInByZS10YWJsZSIpOworc2V0U2VsZWN0aW9uKHByZSwg MCwgMCk7CitleGVjTW92ZVNlbGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7CitleGVjRXh0 ZW5kU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxlY3Rpb25G b3J3YXJkQnlMaW5lQ29tbWFuZCgpOworLy8gRklYTUU6IFRoaXMgaXMgd3JvbmcuCitkb2N1bWVu dC5leGVjQ29tbWFuZCgiaW5kZW50Iik7CisKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1 bHRzIikuaW5uZXJUZXh0ID0gIlBBU1NFRCI7Cis8L1NDUklQVD4KKzwjdGV4dD4KKzwvI3RleHQ+ Cis8L0JPRFk+Cis8L0hUTUw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWND b21tYW5kL2luZGVudC1wcmUuaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQv aW5kZW50LXByZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA2NDFjODQ0ZGU5ZmRkODUzOGQ2MDQ2MWI1YzE1 MjU3OThhZTFmOTAKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWND b21tYW5kL2luZGVudC1wcmUuaHRtbApAQCAtMCwwICsxLDkxIEBACis8ZGl2IGNvbnRlbnRFZGl0 YWJsZT4KKzxwcmUgaWQ9InByZS1iYXNpYyI+bGluZSBvbmUKK2xpbmUgdHdvCitsaW5lIHRocmVl CitsaW5lIGZvdXI8L3ByZT4KKworPHVsPjxsaT48cHJlIGlkPSJwcmUtbGlzdCI+bGlzdCBvbmUK K2xpc3QgdHdvCitsaXN0IHRocmVlCitsaXN0IGZvdXIKKzwvcHJlPjwvbGk+PC91bD4KKworPHRh YmxlPgorPHRyPjx0ZD48cHJlIGlkPSJwcmUtdGFibGUiPnRhYmxlIG9uZQordGFibGUgdHdvCit0 YWJsZSB0aHJlZTwvcHJlPjwvdGQ+PHRkPnJpZ2h0IGNlbGw8L3RkPjwvdHI+PC90YWJsZT4KKwor PGRpdiBpZD0icmVzdWx0cyI+RkFJTEVEPC9kaXY+Cis8L2Rpdj4KKworPGEgaHJlZj0iamF2YXNj cmlwdDpkb2N1bWVudC5leGVjQ29tbWFuZCgnaW5kZW50JykiPmluZGVudDwvYT4KKzxhIGhyZWY9 ImphdmFzY3JpcHQ6ZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ291dGRlbnQnKSI+b3V0ZGVudDwvYT4K KzxzY3JpcHQgc3JjPSIuLi8uLi9yZXNvdXJjZXMvZHVtcC1hcy1tYXJrdXAuanMiPjwvc2NyaXB0 PgorPHNjcmlwdCBzcmM9Ii4uL2VkaXRpbmcuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2Z1bmN0 aW9uIHNldFNlbGVjdGlvbihub2RlLCBzdGFydE9mZnNldCwgZW5kT2Zmc2V0KQoreworICAgIHZh ciB0ZXh0Tm9kZSA9IG5vZGUuZmlyc3RDaGlsZDsKKyAgICBpZiAodGV4dE5vZGUubm9kZVR5cGUg IT0gTm9kZS5URVhUX05PREUpCisgICAgICAgIHRocm93ICJXcm9uZyBub2RlIHR5cGU6ICIgKyB0 ZXh0Tm9kZTsKKyAgICBleGVjU2V0U2VsZWN0aW9uQ29tbWFuZCh0ZXh0Tm9kZSwgc3RhcnRPZmZz ZXQsIGVuZE9mZnNldCk7Cit9CisKK2Z1bmN0aW9uIHZlcmlmeVRleHRTZWxlY3Rpb24oc3RhcnRO b2RlLCBzdGFydE9mZnNldCwgZW5kTm9kZSwgZW5kT2Zmc2V0KQoreworICAgIGlmIChzdGFydE5v ZGUubm9kZVR5cGUgIT0gTm9kZS5URVhUX05PREUpCisgICAgICAgIGNvbnNvbGUubG9nKCJXcm9u ZyBzdGFydCBub2RlIHR5cGU6ICIgKyBzdGFydE5vZGUpOworICAgIGlmIChlbmROb2RlLm5vZGVU eXBlICE9IE5vZGUuVEVYVF9OT0RFKQorICAgICAgICBjb25zb2xlLmxvZygiV3JvbmcgZW5kIG5v ZGUgdHlwZTogIiArIGVuZE5vZGUpOworICAgIHZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9u KCk7CisgICAgaWYgKHNlbC5hbmNob3JOb2RlICE9IHN0YXJ0Tm9kZSB8fCBzZWwuZm9jdXNOb2Rl ICE9IGVuZE5vZGUpCisgICAgICAgIGNvbnNvbGUubG9nKCJXcm9uZyBub2RlIHNlbGVjdGVkLiIp OworICAgIGlmIChzZWwuYW5jaG9yT2Zmc2V0ICE9IHN0YXJ0T2Zmc2V0KQorICAgICAgICBjb25z b2xlLmxvZygiV3JvbmcgYW5jaG9yIG9mZnNldDogIiArIHNlbC5hbmNob3JPZmZzZXQgKyAiIGlu c3RlYWQgb2YgIiArIHN0YXJ0T2Zmc2V0KTsKKyAgICBpZiAoc2VsLmZvY3VzT2Zmc2V0ICE9IGVu ZE9mZnNldCkKKyAgICAgICAgY29uc29sZS5sb2coIldyb25nIGZvY3VzIG9mZnNldDogIiArIHNl bC5mb2N1c09mZnNldCArICIgaW5zdGVhZCBvZiAiICsgZW5kT2Zmc2V0KTsKK30KKworLy8gSW5k ZW50IGEgc2luZ2xlIGxpbmUgaW4gYSBwcmUgYW5kIG1ha2Ugc3VyZSB0aGUgc2VsZWN0aW9uIGlz IGNvcnJlY3RseSBwcmVzZXJ2ZWQuCit2YXIgcHJlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQo InByZS1iYXNpYyIpOworc2V0U2VsZWN0aW9uKHByZSwgMCwgMCk7CitleGVjTW92ZVNlbGVjdGlv bkZvcndhcmRCeUNoYXJhY3RlckNvbW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxlY3Rpb25Gb3J3YXJk QnlXb3JkQ29tbWFuZCgpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoImluZGVudCIpOwordmVyaWZ5 VGV4dFNlbGVjdGlvbihkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJlIilbMF0uZmly c3RDaGlsZCwgMSwKKyAgICAgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRh Z05hbWUoInByZSIpWzBdLmZpcnN0Q2hpbGQsIDQpOworCisvLyBJbmRlbnQgMiBsaW5lcy4KK3Nl dFNlbGVjdGlvbihwcmUsIDAsIDApOworZXhlY01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29t bWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7CitleGVj RXh0ZW5kU2VsZWN0aW9uRm9yd2FyZEJ5V29yZENvbW1hbmQoKTsKK2RvY3VtZW50LmV4ZWNDb21t YW5kKCJpbmRlbnQiKTsKK2lmIChkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJlIiku bGVuZ3RoID4gMykgeworICAgIC8vIEZJWE1FOiBUaGUgc2VsZWN0aW9uIGZvciB0aGUgYW5jaG9y Tm9kZSBpcyB3cm9uZy4gIEl0IHNob3VsZCBiZSAocHJlWzJdLCAwKS4KKyAgICB2ZXJpZnlUZXh0 U2VsZWN0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwcmUiKVsxXS5maXJzdENo aWxkLCA4LAorICAgICAgICAgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRh Z05hbWUoInByZSIpWzNdLmZpcnN0Q2hpbGQsIDQpOworfSBlbHNlIHsKKyAgICBjb25zb2xlLmxv ZygiV3JvbmcgbnVtYmVyIG9mIHByZSBub2Rlcy4iKTsKK30KKy8vIEluZGVudCA8cHJlPiBsaW5l cyBpbiBhIGxpc3QuCitwcmUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicHJlLWxpc3QiKTsK K3NldFNlbGVjdGlvbihwcmUsIDAsIDApOworZXhlY01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlMaW5l Q29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7Citl eGVjRXh0ZW5kU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2RvY3VtZW50LmV4ZWND b21tYW5kKCJpbmRlbnQiKTsKK3ZlcmlmeVRleHRTZWxlY3Rpb24oZG9jdW1lbnQuZ2V0RWxlbWVu dHNCeVRhZ05hbWUoImJsb2NrcXVvdGUiKVsyXS5maXJzdENoaWxkLCAwLAorICAgICAgICAgICAg ICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgiYmxvY2txdW90ZSIpWzJdLmZp cnN0Q2hpbGQubmV4dFNpYmxpbmcsIDEwKTsKKworLy8gSW5kZW50aW5nIDxwcmU+IGxpbmVzIGlu IGEgdGFibGUuCitwcmUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicHJlLXRhYmxlIik7Citz ZXRTZWxlY3Rpb24ocHJlLCAwLCAwKTsKK2V4ZWNNb3ZlU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNv bW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhl Y0V4dGVuZFNlbGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7CisvLyBGSVhNRTogVGhpcyBp cyB3cm9uZy4KK2RvY3VtZW50LmV4ZWNDb21tYW5kKCJpbmRlbnQiKTsKKworZG9jdW1lbnQuZ2V0 RWxlbWVudEJ5SWQoInJlc3VsdHMiKS5pbm5lclRleHQgPSAiUEFTU0VEIjsKKzwvc2NyaXB0Pgpk aWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA0 ODJlZTQzOGRkODEwOWYzYTliNGI0MTA1NzcwOTMxYTIxYzY0MGZjLi4yNjZlYTE0YjQ4YzIxYzFm N2Q5NzMyMDc5NzY1MWZjNWYzZjAzM2JmIDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEwLTA1LTEyICBUb255 IENoYW5nICA8dG9ueUBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgY3Jhc2ggaW4gV2ViQ29yZTo6Q29tcG9zaXRlRWRpdENvbW1h bmQ6OnNwbGl0VHJlZVRvTm9kZSB3aGVuIGluZGVudGluZyBwcmUKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTM4MjMxCisKKyAgICAgICAgVGVzdDogZWRp dGluZy9leGVjQ29tbWFuZC9pbmRlbnQtcHJlLmh0bWwKKworICAgICAgICAqIGVkaXRpbmcvSW5k ZW50T3V0ZGVudENvbW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6Y291bnRQYXJhZ3JhcGhz KToKKyAgICAgICAgKFdlYkNvcmU6OkluZGVudE91dGRlbnRDb21tYW5kOjppbmRlbnRSZWdpb24p OiBTcGxpdCB0ZXh0IG5vZGVzIGludG8gb25lIG5vZGUgcGVyIHBhcmFncmFwaAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNvIG1vdmVQYXJh Z3JhcGggZG9lc24ndCBnZXQgY29uZnVzZWQuCisgICAgICAgIChXZWJDb3JlOjpJbmRlbnRPdXRk ZW50Q29tbWFuZDo6c3BsaXRUZXh0Tm9kZXMpOgorICAgICAgICAqIGVkaXRpbmcvSW5kZW50T3V0 ZGVudENvbW1hbmQuaDoKKwogMjAxMC0wNS0xMSAgRGF2aWQgSHlhdHQgIDxoeWF0dEBhcHBsZS5j b20+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgTWFjaWVqIFN0YWNob3dpYWsuCmRpZmYgLS1naXQg YS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwIGIvV2ViQ29yZS9lZGl0 aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNwcAppbmRleCAwZjM5NzViMGMxM2Y2ZThlOTNlMzJl OGM2NTlhYjNiNzdiNDYzZjM5Li5iNjg1MjdkMDQ0ZWUzYWY3ZDEyZDdkNmYyYjYwNWZiYTRmOTEy MjkwIDEwMDY0NAotLS0gYS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3Bw CisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAKQEAgLTM0LDYg KzM0LDcgQEAKICNpbmNsdWRlICJJbnNlcnRMaXN0Q29tbWFuZC5oIgogI2luY2x1ZGUgIlJhbmdl LmgiCiAjaW5jbHVkZSAiU3BsaXRFbGVtZW50Q29tbWFuZC5oIgorI2luY2x1ZGUgIlRleHQuaCIK ICNpbmNsdWRlICJUZXh0SXRlcmF0b3IuaCIKICNpbmNsdWRlICJodG1sZWRpdGluZy5oIgogI2lu Y2x1ZGUgInZpc2libGVfdW5pdHMuaCIKQEAgLTYyLDYgKzYzLDIyIEBAIHN0YXRpYyBib29sIGlz TGlzdE9ySW5kZW50QmxvY2txdW90ZShjb25zdCBOb2RlKiBub2RlKQogICAgIHJldHVybiBub2Rl ICYmIChub2RlLT5oYXNUYWdOYW1lKHVsVGFnKSB8fCBub2RlLT5oYXNUYWdOYW1lKG9sVGFnKSB8 fCBub2RlLT5oYXNUYWdOYW1lKGJsb2NrcXVvdGVUYWcpKTsKIH0KIAorLy8gVGhpcyBmdW5jdGlv biBjYW4gcmV0dXJuIC0xIGlmIHdlIGFyZSB1bmFibGUgdG8gY291bnQgdGhlIHBhcmFncmFwaHMg YmV0d2VlbiB8c3RhcnR8IGFuZCB8ZW5kfC4KK3N0YXRpYyBpbnQgY291bnRQYXJhZ3JhcGhzKGNv bnN0IFZpc2libGVQb3NpdGlvbiYgc3RhcnQsIGNvbnN0IFZpc2libGVQb3NpdGlvbiYgZW5kKQor eworICAgIGludCBjb3VudCA9IDA7CisgICAgVmlzaWJsZVBvc2l0aW9uIGN1ciA9IHN0YXJ0Owor ICAgIHdoaWxlIChjdXIgIT0gZW5kKSB7CisgICAgICAgICsrY291bnQ7CisgICAgICAgIGN1ciA9 IGVuZE9mUGFyYWdyYXBoKGN1ci5uZXh0KCkpOworICAgICAgICAvLyBJZiBzdGFydCBpcyBiZWZv cmUgYSB0YWJsZSBhbmQgZW5kIGlzIGluc2lkZSBhIHRhYmxlLCB3ZSB3aWxsIG5ldmVyIGhpdCBl bmQgYmVjYXVzZSB0aGUKKyAgICAgICAgLy8gd2hvbGUgdGFibGUgaXMgY29uc2lkZXJlZCBhIHNp bmdsZSBwYXJhZ3JhcGguCisgICAgICAgIGlmIChjdXIuaXNOdWxsKCkpCisgICAgICAgICAgICBy ZXR1cm4gLTE7CisgICAgfQorICAgIHJldHVybiBjb3VudDsKK30KKwogSW5kZW50T3V0ZGVudENv bW1hbmQ6OkluZGVudE91dGRlbnRDb21tYW5kKERvY3VtZW50KiBkb2N1bWVudCwgRUluZGVudFR5 cGUgdHlwZU9mQWN0aW9uLCBpbnQgbWFyZ2luSW5QaXhlbHMpCiAgICAgOiBDb21wb3NpdGVFZGl0 Q29tbWFuZChkb2N1bWVudCksIG1fdHlwZU9mQWN0aW9uKHR5cGVPZkFjdGlvbiksIG1fbWFyZ2lu SW5QaXhlbHMobWFyZ2luSW5QaXhlbHMpCiB7CkBAIC0xNTEsNiArMTY4LDE4IEBAIHZvaWQgSW5k ZW50T3V0ZGVudENvbW1hbmQ6OmluZGVudFJlZ2lvbihjb25zdCBWaXNpYmxlUG9zaXRpb24mIHN0 YXJ0T2ZTZWxlY3Rpb24sCiAgICAgUmVmUHRyPEVsZW1lbnQ+IGJsb2NrcXVvdGVGb3JOZXh0SW5k ZW50OwogICAgIFZpc2libGVQb3NpdGlvbiBlbmRPZkN1cnJlbnRQYXJhZ3JhcGggPSBlbmRPZlBh cmFncmFwaChzdGFydE9mU2VsZWN0aW9uKTsKICAgICBWaXNpYmxlUG9zaXRpb24gZW5kQWZ0ZXJT ZWxlY3Rpb24gPSBlbmRPZlBhcmFncmFwaChlbmRPZlBhcmFncmFwaChlbmRPZlNlbGVjdGlvbiku bmV4dCgpKTsKKyAgICBpbnQgZW5kT2ZDdXJyZW50UGFyYWdyYXBoSW5kZXggPSBpbmRleEZvclZp c2libGVQb3NpdGlvbihlbmRPZkN1cnJlbnRQYXJhZ3JhcGgpOworICAgIGludCBlbmRBZnRlclNl bGVjdGlvbkluZGV4ID0gaW5kZXhGb3JWaXNpYmxlUG9zaXRpb24oZW5kQWZ0ZXJTZWxlY3Rpb24p OworCisgICAgLy8gV2hlbiBpbmRlbnRpbmcgd2l0aGluIGEgPHByZT4gdGFnLCB3ZSBuZWVkIHRv IHNwbGl0IGVhY2ggcGFyYWdyYXBoIGludG8gYSBzZXBhcmF0ZSBub2RlIGZvciBtb3ZlUGFyYWdy YXBoV2l0aENsb25lcyB0byB3b3JrLgorICAgIC8vIEhvd2V2ZXIsIHNwbGl0dGluZyB0ZXh0IG5v ZGVzIGNhbiBjYXVzZSBlbmRPZkN1cnJlbnRQYXJhZ3JhcGggYW5kIGVuZEFmdGVyU2VsZWN0aW9u IHRvIHBvaW50IHRvIGFuIGludmFsaWQgcG9zaXRpb24gaWYgd2UKKyAgICAvLyBjaGFuZ2VkIHRo ZSB0ZXh0IG5vZGUgaXQgd2FzIHBvaW50aW5nIGF0LiAgU28gd2UgaGF2ZSB0byByZXNldCB0aGVz ZSBwb3NpdGlvbnMuCisgICAgaW50IG51bVBhcmFncmFwaHMgPSBjb3VudFBhcmFncmFwaHMoZW5k T2ZDdXJyZW50UGFyYWdyYXBoLCBlbmRBZnRlclNlbGVjdGlvbik7CisgICAgaWYgKHNwbGl0VGV4 dE5vZGVzKHN0YXJ0T2ZQYXJhZ3JhcGgoc3RhcnRPZlNlbGVjdGlvbiksIG51bVBhcmFncmFwaHMg KyAxKSkgeworICAgICAgICBlbmRPZkN1cnJlbnRQYXJhZ3JhcGggPSBWaXNpYmxlUG9zaXRpb24o VGV4dEl0ZXJhdG9yOjpyYW5nZUZyb21Mb2NhdGlvbkFuZExlbmd0aChkb2N1bWVudCgpLT5kb2N1 bWVudEVsZW1lbnQoKSwgZW5kT2ZDdXJyZW50UGFyYWdyYXBoSW5kZXgsIDApLT5zdGFydFBvc2l0 aW9uKCksIFVQU1RSRUFNKTsKKyAgICAgICAgZW5kQWZ0ZXJTZWxlY3Rpb24gPSBWaXNpYmxlUG9z aXRpb24oVGV4dEl0ZXJhdG9yOjpyYW5nZUZyb21Mb2NhdGlvbkFuZExlbmd0aChkb2N1bWVudCgp LT5kb2N1bWVudEVsZW1lbnQoKSwgZW5kQWZ0ZXJTZWxlY3Rpb25JbmRleCwgMCktPnN0YXJ0UG9z aXRpb24oKSwgVVBTVFJFQU0pOworICAgIH0KKwogICAgIHdoaWxlIChlbmRPZkN1cnJlbnRQYXJh Z3JhcGggIT0gZW5kQWZ0ZXJTZWxlY3Rpb24pIHsKICAgICAgICAgLy8gSXRlcmF0ZSBhY3Jvc3Mg dGhlIHNlbGVjdGVkIHBhcmFncmFwaHMuLi4KICAgICAgICAgVmlzaWJsZVBvc2l0aW9uIGVuZE9m TmV4dFBhcmFncmFwaCA9IGVuZE9mUGFyYWdyYXBoKGVuZE9mQ3VycmVudFBhcmFncmFwaC5uZXh0 KCkpOwpAQCAtMTc0LDYgKzIwMywyOCBAQCB2b2lkIEluZGVudE91dGRlbnRDb21tYW5kOjppbmRl bnRSZWdpb24oY29uc3QgVmlzaWJsZVBvc2l0aW9uJiBzdGFydE9mU2VsZWN0aW9uLAogICAgIH0g ICAKIH0KIAorLy8gUmV0dXJucyB0cnVlIGlmIGF0IGxlYXN0IG9uZSB0ZXh0IG5vZGUgd2FzIHNw bGl0LgorYm9vbCBJbmRlbnRPdXRkZW50Q29tbWFuZDo6c3BsaXRUZXh0Tm9kZXMoY29uc3QgVmlz aWJsZVBvc2l0aW9uJiBzdGFydCwgaW50IG51bVBhcmFncmFwaHMpCit7CisgICAgVmlzaWJsZVBv c2l0aW9uIGN1cnJlbnRQYXJhZ3JhcGhTdGFydCA9IHN0YXJ0OworICAgIGJvb2wgaGFzU3BsaXQg PSBmYWxzZTsKKyAgICBpbnQgcGFyYWdyYXBoQ291bnQ7CisgICAgZm9yIChwYXJhZ3JhcGhDb3Vu dCA9IDA7IHBhcmFncmFwaENvdW50IDwgbnVtUGFyYWdyYXBoczsgKytwYXJhZ3JhcGhDb3VudCkg eworICAgICAgICBpZiAoY3VycmVudFBhcmFncmFwaFN0YXJ0LmRlZXBFcXVpdmFsZW50KCkubm9k ZSgpLT5pc1RleHROb2RlKCkgJiYgY3VycmVudFBhcmFncmFwaFN0YXJ0LmRlZXBFcXVpdmFsZW50 KCkubm9kZSgpID09IHN0YXJ0T2ZQYXJhZ3JhcGgoY3VycmVudFBhcmFncmFwaFN0YXJ0LnByZXZp b3VzKCkpLmRlZXBFcXVpdmFsZW50KCkubm9kZSgpKSB7CisgICAgICAgICAgICBUZXh0KiB0ZXh0 Tm9kZSA9IHN0YXRpY19jYXN0PFRleHQgKj4oY3VycmVudFBhcmFncmFwaFN0YXJ0LmRlZXBFcXVp dmFsZW50KCkubm9kZSgpKTsKKyAgICAgICAgICAgIGludCBvZmZzZXQgPSBjdXJyZW50UGFyYWdy YXBoU3RhcnQuZGVlcEVxdWl2YWxlbnQoKS5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKTsKKyAgICAg ICAgICAgIHNwbGl0VGV4dE5vZGUodGV4dE5vZGUsIG9mZnNldCk7CisgICAgICAgICAgICBjdXJy ZW50UGFyYWdyYXBoU3RhcnQgPSBWaXNpYmxlUG9zaXRpb24odGV4dE5vZGUsIDAsIFZQX0RFRkFV TFRfQUZGSU5JVFkpOworICAgICAgICAgICAgaGFzU3BsaXQgPSB0cnVlOworICAgICAgICB9Cisg ICAgICAgIFZpc2libGVQb3NpdGlvbiBuZXh0UGFyYWdyYXBoID0gc3RhcnRPZlBhcmFncmFwaChl bmRPZlBhcmFncmFwaChjdXJyZW50UGFyYWdyYXBoU3RhcnQpLm5leHQoKSk7CisgICAgICAgIGlm IChuZXh0UGFyYWdyYXBoLmlzTnVsbCgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGN1 cnJlbnRQYXJhZ3JhcGhTdGFydCA9IG5leHRQYXJhZ3JhcGg7CisgICAgfQorICAgIHJldHVybiBo YXNTcGxpdDsKK30KKwogdm9pZCBJbmRlbnRPdXRkZW50Q29tbWFuZDo6b3V0ZGVudFBhcmFncmFw aCgpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVTdGFydE9mUGFyYWdyYXBoID0gc3Rh cnRPZlBhcmFncmFwaChlbmRpbmdTZWxlY3Rpb24oKS52aXNpYmxlU3RhcnQoKSk7CmRpZmYgLS1n aXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuaCBiL1dlYkNvcmUvZWRp dGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oCmluZGV4IDg3MDViZjEwM2MyMjEyMjI5OGQxZTg0 OTVkYzAwN2U5YzI1ODA5MTEuLjg2NDRjYzU2YWE4MjA4MzA1MmU1MmU3YTY1NGE0NjBmZWYzZGI5 NjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oCisr KyBiL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oCkBAIC01MSw2ICs1MSw3 IEBAIHByaXZhdGU6CiAgICAgdm9pZCBvdXRkZW50UGFyYWdyYXBoKCk7CiAgICAgYm9vbCB0cnlJ bmRlbnRpbmdBc0xpc3RJdGVtKGNvbnN0IFZpc2libGVQb3NpdGlvbiYpOwogICAgIHZvaWQgaW5k ZW50SW50b0Jsb2NrcXVvdGUoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgVmlzaWJsZVBv c2l0aW9uJiwgUmVmUHRyPEVsZW1lbnQ+Jik7CisgICAgYm9vbCBzcGxpdFRleHROb2Rlcyhjb25z dCBWaXNpYmxlUG9zaXRpb24mIHN0YXJ0LCBpbnQgbnVtUGFyYWdyYXBocyk7CiAKICAgICBFSW5k ZW50VHlwZSBtX3R5cGVPZkFjdGlvbjsKICAgICBpbnQgbV9tYXJnaW5JblBpeGVsczsK 61121 2010-07-09 17:38:06 -0700 2010-07-09 21:21:02 -0700 Patch for landing bug-38231-20100709173804.patch text/plain 16302 tony ZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxv ZwppbmRleCBkN2U4Y2E0NzZhNmY4ODkwNWFkMjBmZmE1NWUwYzg0ZmM4ZWZjMzM0Li5iZGMzNDc3 ZjVjZTYyYmQ0ZDE1NWM1MDg0ZGQ1MTEwNzM0NDc0YTQwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMTAtMDctMDkgIFRvbnkgQ2hhbmcgIDx0b255QGNocm9taXVtLm9yZz4KKworICAgICAgICBS ZXZpZXdlZCBieSBPamFuIFZhZmFpLgorCisgICAgICAgIGNyYXNoIGluIFdlYkNvcmU6OkNvbXBv c2l0ZUVkaXRDb21tYW5kOjpzcGxpdFRyZWVUb05vZGUgd2hlbiBpbmRlbnRpbmcgcHJlCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0zODIzMQorCisgICAg ICAgICogZWRpdGluZy9leGVjQ29tbWFuZC9pbmRlbnQtcHJlLWV4cGVjdGVkLnR4dDogQWRkZWQu CisgICAgICAgICogZWRpdGluZy9leGVjQ29tbWFuZC9pbmRlbnQtcHJlLmh0bWw6IEFkZGVkLgor CiAyMDEwLTA3LTA5ICBFcmljIFNlaWRlbCAgPGVyaWNAd2Via2l0Lm9yZz4KIAogICAgICAgICBS ZXZpZXdlZCBieSBBZGFtIEJhcnRoLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9l eGVjQ29tbWFuZC9pbmRlbnQtcHJlLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcv ZXhlY0NvbW1hbmQvaW5kZW50LXByZS1leHBlY3RlZC50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTgwNTI4OTlj MmNmMDA3NTBkMzhhMGY2NzU2YmZhZDhlNGY4YzU0OQotLS0gL2Rldi9udWxsCisrKyBiL0xheW91 dFRlc3RzL2VkaXRpbmcvZXhlY0NvbW1hbmQvaW5kZW50LXByZS1leHBlY3RlZC50eHQKQEAgLTAs MCArMSwxODMgQEAKK0NPTlNPTEUgTUVTU0FHRTogbGluZSA0NDogV3Jvbmcgbm9kZSBzZWxlY3Rl ZC4KK0NPTlNPTEUgTUVTU0FHRTogbGluZSA0NjogV3JvbmcgYW5jaG9yIG9mZnNldDogOCBpbnN0 ZWFkIG9mIDAKKworPEhUTUw+Cis8SEVBRD4KKzwvSEVBRD4KKzxCT0RZPgorPFA+Cis8I3RleHQ+ VGhpcyB0ZXN0IHRyaWVzIHRvIGluZGVudCBsaW5lcyB3aXRoaW4gcHJlIHRhZ3MuIFRoaXMgdGVz dCBwYXNzZXMgaWYgaXQKK2RvZXMgbm90IGNyYXNoLjwvI3RleHQ+Cis8L1A+Cis8I3RleHQ+Cis8 LyN0ZXh0PgorPERJViBjb250ZW50RWRpdGFibGU9IiI+Cis8I3RleHQ+Cis8LyN0ZXh0PgorPEJM T0NLUVVPVEUgc3R5bGU9Im1hcmdpbjogMCAwIDAgNDBweDsgYm9yZGVyOiBub25lOyBwYWRkaW5n OiAwcHg7IiBjbGFzcz0id2Via2l0LWluZGVudC1ibG9ja3F1b3RlIj4KKzxQUkUgaWQ9InByZS1i YXNpYyI+Cis8I3RleHQ+bGluZSBvbmUKKzwvI3RleHQ+Cis8L1BSRT4KKzwvQkxPQ0tRVU9URT4K KzxQUkUgaWQ9InByZS1iYXNpYyI+Cis8I3RleHQ+bGluZSB0d28KKzwvI3RleHQ+Cis8L1BSRT4K KzxCTE9DS1FVT1RFIHN0eWxlPSJtYXJnaW46IDAgMCAwIDQwcHg7IGJvcmRlcjogbm9uZTsgcGFk ZGluZzogMHB4OyIgY2xhc3M9IndlYmtpdC1pbmRlbnQtYmxvY2txdW90ZSI+Cis8UFJFIGlkPSJw cmUtYmFzaWMiPgorPCN0ZXh0PmxpbmUgdGhyZWUKKzwvI3RleHQ+Cis8L1BSRT4KKzxQUkUgaWQ9 InByZS1iYXNpYyI+Cis8I3RleHQ+bGluZSBmb3VyPC8jdGV4dD4KKzwvUFJFPgorPC9CTE9DS1FV T1RFPgorPCN0ZXh0PgorCis8LyN0ZXh0PgorPFVMPgorPExJPgorPFBSRSBpZD0icHJlLWxpc3Qi PgorPCN0ZXh0Pmxpc3Qgb25lCis8LyN0ZXh0PgorPEJMT0NLUVVPVEUgc3R5bGU9Im1hcmdpbjog MCAwIDAgNDBweDsgYm9yZGVyOiBub25lOyBwYWRkaW5nOiAwcHg7IiBjbGFzcz0id2Via2l0LWlu ZGVudC1ibG9ja3F1b3RlIj4KKzwjdGV4dD5saXN0IHR3bworPC8jdGV4dD4KKzwjdGV4dD5saXN0 IHRocmVlCis8LyN0ZXh0PgorPC9CTE9DS1FVT1RFPgorPCN0ZXh0Pmxpc3QgZm91cgorPC8jdGV4 dD4KKzwvUFJFPgorPC9MST4KKzwvVUw+Cis8I3RleHQ+CisKKzwvI3RleHQ+Cis8VEFCTEU+Cis8 I3RleHQ+Cis8LyN0ZXh0PgorPFRCT0RZPgorPFRSPgorPFREPgorPFBSRSBpZD0icHJlLXRhYmxl Ij4KKzwjdGV4dD50YWJsZSBvbmU8c2VsZWN0aW9uLWFuY2hvcj4KKzwvI3RleHQ+Cis8L1BSRT4K KzxCTE9DS1FVT1RFIHN0eWxlPSJtYXJnaW46IDAgMCAwIDQwcHg7IGJvcmRlcjogbm9uZTsgcGFk ZGluZzogMHB4OyIgY2xhc3M9IndlYmtpdC1pbmRlbnQtYmxvY2txdW90ZSI+Cis8UFJFIGlkPSJw cmUtdGFibGUiPgorPCN0ZXh0PnRhYmxlIHR3bworPC8jdGV4dD4KKzwvUFJFPgorPFBSRSBpZD0i cHJlLXRhYmxlIj4KKzwjdGV4dD50YWJsZSB0aHJlZTxzZWxlY3Rpb24tZm9jdXM+PC8jdGV4dD4K KzwvUFJFPgorPC9CTE9DS1FVT1RFPgorPC9URD4KKzxURD4KKzwjdGV4dD5yaWdodCBjZWxsPC8j dGV4dD4KKzwvVEQ+Cis8L1RSPgorPC9UQk9EWT4KKzwvVEFCTEU+Cis8I3RleHQ+CisKKzwvI3Rl eHQ+Cis8RElWIGlkPSJyZXN1bHRzIj4KKzwjdGV4dD5QQVNTRUQgKGRpZCBub3QgY3Jhc2gpPC8j dGV4dD4KKzwvRElWPgorPCN0ZXh0PgorPC8jdGV4dD4KKzwvRElWPgorPCN0ZXh0PgorCis8LyN0 ZXh0PgorPEEgaHJlZj0iamF2YXNjcmlwdDpkb2N1bWVudC5leGVjQ29tbWFuZCgnaW5kZW50Jyki PgorPCN0ZXh0PmluZGVudDwvI3RleHQ+Cis8L0E+Cis8I3RleHQ+Cis8LyN0ZXh0PgorPEEgaHJl Zj0iamF2YXNjcmlwdDpkb2N1bWVudC5leGVjQ29tbWFuZCgnb3V0ZGVudCcpIj4KKzwjdGV4dD5v dXRkZW50PC8jdGV4dD4KKzwvQT4KKzwjdGV4dD4KKzwvI3RleHQ+Cis8U0NSSVBUIHNyYz0iLi4v Li4vcmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpzIj48L1NDUklQVD4KKzwjdGV4dD4KKzwvI3Rl eHQ+Cis8U0NSSVBUIHNyYz0iLi4vZWRpdGluZy5qcyI+PC9TQ1JJUFQ+Cis8I3RleHQ+Cis8LyN0 ZXh0PgorPFNDUklQVD4KK2Z1bmN0aW9uIHNldFNlbGVjdGlvbihub2RlKQorewordmFyIHRleHRO b2RlID0gbm9kZS5maXJzdENoaWxkOworaWYgKHRleHROb2RlLm5vZGVUeXBlICE9IE5vZGUuVEVY VF9OT0RFKQordGhyb3cgIldyb25nIG5vZGUgdHlwZTogIiArIHRleHROb2RlOworZXhlY1NldFNl bGVjdGlvbkNvbW1hbmQodGV4dE5vZGUsIDAsIDApOworfQorCitmdW5jdGlvbiB2ZXJpZnlUZXh0 U2VsZWN0aW9uKHN0YXJ0Tm9kZSwgc3RhcnRPZmZzZXQsIGVuZE5vZGUsIGVuZE9mZnNldCkKK3sK K2lmIChzdGFydE5vZGUubm9kZVR5cGUgIT0gTm9kZS5URVhUX05PREUpCitjb25zb2xlLmxvZygi V3Jvbmcgc3RhcnQgbm9kZSB0eXBlOiAiICsgc3RhcnROb2RlKTsKK2lmIChlbmROb2RlLm5vZGVU eXBlICE9IE5vZGUuVEVYVF9OT0RFKQorY29uc29sZS5sb2coIldyb25nIGVuZCBub2RlIHR5cGU6 ICIgKyBlbmROb2RlKTsKK3ZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CitpZiAoc2Vs LmFuY2hvck5vZGUgIT0gc3RhcnROb2RlIHx8IHNlbC5mb2N1c05vZGUgIT0gZW5kTm9kZSkKK2Nv bnNvbGUubG9nKCJXcm9uZyBub2RlIHNlbGVjdGVkLiIpOworaWYgKHNlbC5hbmNob3JPZmZzZXQg IT0gc3RhcnRPZmZzZXQpCitjb25zb2xlLmxvZygiV3JvbmcgYW5jaG9yIG9mZnNldDogIiArIHNl bC5hbmNob3JPZmZzZXQgKyAiIGluc3RlYWQgb2YgIiArIHN0YXJ0T2Zmc2V0KTsKK2lmIChzZWwu Zm9jdXNPZmZzZXQgIT0gZW5kT2Zmc2V0KQorY29uc29sZS5sb2coIldyb25nIGZvY3VzIG9mZnNl dDogIiArIHNlbC5mb2N1c09mZnNldCArICIgaW5zdGVhZCBvZiAiICsgZW5kT2Zmc2V0KTsKK30K KworLy8gSW5kZW50IGEgc2luZ2xlIGxpbmUgaW4gYSBwcmUgYW5kIG1ha2Ugc3VyZSB0aGUgc2Vs ZWN0aW9uIGlzIGNvcnJlY3RseSBwcmVzZXJ2ZWQuCit2YXIgcHJlID0gZG9jdW1lbnQuZ2V0RWxl bWVudEJ5SWQoInByZS1iYXNpYyIpOworc2V0U2VsZWN0aW9uKHByZSk7CitleGVjTW92ZVNlbGVj dGlvbkZvcndhcmRCeUNoYXJhY3RlckNvbW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxlY3Rpb25Gb3J3 YXJkQnlXb3JkQ29tbWFuZCgpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoImluZGVudCIpOwordmVy aWZ5VGV4dFNlbGVjdGlvbihkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJlIilbMF0u Zmlyc3RDaGlsZCwgMSwKK2RvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJwcmUiKVswXS5m aXJzdENoaWxkLCA0KTsKKworLy8gSW5kZW50IDIgbGluZXMuCitzZXRTZWxlY3Rpb24ocHJlKTsK K2V4ZWNNb3ZlU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxl Y3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlvbkZvcndhcmRC eVdvcmRDb21tYW5kKCk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgiaW5kZW50Iik7CitpZiAoZG9j dW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInByZSIpLmxlbmd0aCA+IDMpIHsKKy8vIEZJWE1F OiBUaGUgc2VsZWN0aW9uIGZvciB0aGUgYW5jaG9yTm9kZSBpcyB3cm9uZy4gSXQgc2hvdWxkIHN0 YXkgYXQKKy8vIHRoZSBiZWdpbm5pbmcgb2YgImxpbmUgdGhyZWUiLCBidXQgaXQgbW92ZXMgdG8g dGhlIGVuZCBvZiAibGluZSAyIi4KK3ZlcmlmeVRleHRTZWxlY3Rpb24oZG9jdW1lbnQuZ2V0RWxl bWVudHNCeVRhZ05hbWUoInByZSIpWzJdLmZpcnN0Q2hpbGQsIDAsCitkb2N1bWVudC5nZXRFbGVt ZW50c0J5VGFnTmFtZSgicHJlIilbM10uZmlyc3RDaGlsZCwgNCk7Cit9IGVsc2UgeworY29uc29s ZS5sb2coIldyb25nIG51bWJlciBvZiBwcmUgbm9kZXMuIik7Cit9CisKKy8vIEluZGVudCA8cHJl PiBsaW5lcyBpbiBhIGxpc3QuCitwcmUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicHJlLWxp c3QiKTsKK3NldFNlbGVjdGlvbihwcmUpOworZXhlY01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlMaW5l Q29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7Citl eGVjRXh0ZW5kU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2RvY3VtZW50LmV4ZWND b21tYW5kKCJpbmRlbnQiKTsKK3ZlcmlmeVRleHRTZWxlY3Rpb24oZG9jdW1lbnQuZ2V0RWxlbWVu dHNCeVRhZ05hbWUoImJsb2NrcXVvdGUiKVsyXS5maXJzdENoaWxkLCAwLAorZG9jdW1lbnQuZ2V0 RWxlbWVudHNCeVRhZ05hbWUoImJsb2NrcXVvdGUiKVsyXS5maXJzdENoaWxkLm5leHRTaWJsaW5n LCAxMCk7CisvLyBJbmRlbnRpbmcgPHByZT4gbGluZXMgaW4gYSB0YWJsZS4KK3ByZSA9IGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJwcmUtdGFibGUiKTsKK3NldFNlbGVjdGlvbihwcmUpOworZXhl Y01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVjdGlv bkZvcndhcmRCeUxpbmVDb21tYW5kKCk7CitleGVjRXh0ZW5kU2VsZWN0aW9uRm9yd2FyZEJ5TGlu ZUNvbW1hbmQoKTsKKy8vIEZJWE1FOiBUaGlzIGlzIHdyb25nLiBUaGUgcHJlIHRhZ3MgZ2V0IGNv cGllZCB3aGVuIHRoZXkgc2hvdWxkbid0IGJlLiAKKy8vIFNlZSBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDIwMDkKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCJpbmRlbnQi KTsKK2RvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJyZXN1bHRzIikuaW5uZXJUZXh0ID0gIlBBU1NF RCAoZGlkIG5vdCBjcmFzaCkiOworPC9TQ1JJUFQ+Cis8I3RleHQ+Cis8LyN0ZXh0PgorPC9CT0RZ PgorPC9IVE1MPgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9p bmRlbnQtcHJlLmh0bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL2V4ZWNDb21tYW5kL2luZGVudC1w cmUuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwLi4zY2QwYzUxNjk1NzNiYjEyZWFhNGQ3OTgwMjQ3YjliNGVmMDU3 YWIxCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9leGVjQ29tbWFuZC9p bmRlbnQtcHJlLmh0bWwKQEAgLTAsMCArMSw5NCBAQAorPHA+VGhpcyB0ZXN0IHRyaWVzIHRvIGlu ZGVudCBsaW5lcyB3aXRoaW4gcHJlIHRhZ3MuICBUaGlzIHRlc3QgcGFzc2VzIGlmIGl0Citkb2Vz IG5vdCBjcmFzaC48L3A+Cis8ZGl2IGNvbnRlbnRFZGl0YWJsZT4KKzxwcmUgaWQ9InByZS1iYXNp YyI+bGluZSBvbmUKK2xpbmUgdHdvCitsaW5lIHRocmVlCitsaW5lIGZvdXI8L3ByZT4KKworPHVs PjxsaT48cHJlIGlkPSJwcmUtbGlzdCI+bGlzdCBvbmUKK2xpc3QgdHdvCitsaXN0IHRocmVlCits aXN0IGZvdXIKKzwvcHJlPjwvbGk+PC91bD4KKworPHRhYmxlPgorPHRyPjx0ZD48cHJlIGlkPSJw cmUtdGFibGUiPnRhYmxlIG9uZQordGFibGUgdHdvCit0YWJsZSB0aHJlZTwvcHJlPjwvdGQ+PHRk PnJpZ2h0IGNlbGw8L3RkPjwvdHI+PC90YWJsZT4KKworPGRpdiBpZD0icmVzdWx0cyI+RkFJTEVE PC9kaXY+Cis8L2Rpdj4KKworPGEgaHJlZj0iamF2YXNjcmlwdDpkb2N1bWVudC5leGVjQ29tbWFu ZCgnaW5kZW50JykiPmluZGVudDwvYT4KKzxhIGhyZWY9ImphdmFzY3JpcHQ6ZG9jdW1lbnQuZXhl Y0NvbW1hbmQoJ291dGRlbnQnKSI+b3V0ZGVudDwvYT4KKzxzY3JpcHQgc3JjPSIuLi8uLi9yZXNv dXJjZXMvZHVtcC1hcy1tYXJrdXAuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9Ii4uL2VkaXRp bmcuanMiPjwvc2NyaXB0PgorPHNjcmlwdD4KK2Z1bmN0aW9uIHNldFNlbGVjdGlvbihub2RlKQor eworICAgIHZhciB0ZXh0Tm9kZSA9IG5vZGUuZmlyc3RDaGlsZDsKKyAgICBpZiAodGV4dE5vZGUu bm9kZVR5cGUgIT0gTm9kZS5URVhUX05PREUpCisgICAgICAgIHRocm93ICJXcm9uZyBub2RlIHR5 cGU6ICIgKyB0ZXh0Tm9kZTsKKyAgICBleGVjU2V0U2VsZWN0aW9uQ29tbWFuZCh0ZXh0Tm9kZSwg MCwgMCk7Cit9CisKK2Z1bmN0aW9uIHZlcmlmeVRleHRTZWxlY3Rpb24oc3RhcnROb2RlLCBzdGFy dE9mZnNldCwgZW5kTm9kZSwgZW5kT2Zmc2V0KQoreworICAgIGlmIChzdGFydE5vZGUubm9kZVR5 cGUgIT0gTm9kZS5URVhUX05PREUpCisgICAgICAgIGNvbnNvbGUubG9nKCJXcm9uZyBzdGFydCBu b2RlIHR5cGU6ICIgKyBzdGFydE5vZGUpOworICAgIGlmIChlbmROb2RlLm5vZGVUeXBlICE9IE5v ZGUuVEVYVF9OT0RFKQorICAgICAgICBjb25zb2xlLmxvZygiV3JvbmcgZW5kIG5vZGUgdHlwZTog IiArIGVuZE5vZGUpOworICAgIHZhciBzZWwgPSB3aW5kb3cuZ2V0U2VsZWN0aW9uKCk7CisgICAg aWYgKHNlbC5hbmNob3JOb2RlICE9IHN0YXJ0Tm9kZSB8fCBzZWwuZm9jdXNOb2RlICE9IGVuZE5v ZGUpCisgICAgICAgIGNvbnNvbGUubG9nKCJXcm9uZyBub2RlIHNlbGVjdGVkLiIpOworICAgIGlm IChzZWwuYW5jaG9yT2Zmc2V0ICE9IHN0YXJ0T2Zmc2V0KQorICAgICAgICBjb25zb2xlLmxvZygi V3JvbmcgYW5jaG9yIG9mZnNldDogIiArIHNlbC5hbmNob3JPZmZzZXQgKyAiIGluc3RlYWQgb2Yg IiArIHN0YXJ0T2Zmc2V0KTsKKyAgICBpZiAoc2VsLmZvY3VzT2Zmc2V0ICE9IGVuZE9mZnNldCkK KyAgICAgICAgY29uc29sZS5sb2coIldyb25nIGZvY3VzIG9mZnNldDogIiArIHNlbC5mb2N1c09m ZnNldCArICIgaW5zdGVhZCBvZiAiICsgZW5kT2Zmc2V0KTsKK30KKworLy8gSW5kZW50IGEgc2lu Z2xlIGxpbmUgaW4gYSBwcmUgYW5kIG1ha2Ugc3VyZSB0aGUgc2VsZWN0aW9uIGlzIGNvcnJlY3Rs eSBwcmVzZXJ2ZWQuCit2YXIgcHJlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInByZS1iYXNp YyIpOworc2V0U2VsZWN0aW9uKHByZSk7CitleGVjTW92ZVNlbGVjdGlvbkZvcndhcmRCeUNoYXJh Y3RlckNvbW1hbmQoKTsKK2V4ZWNFeHRlbmRTZWxlY3Rpb25Gb3J3YXJkQnlXb3JkQ29tbWFuZCgp OworZG9jdW1lbnQuZXhlY0NvbW1hbmQoImluZGVudCIpOwordmVyaWZ5VGV4dFNlbGVjdGlvbihk b2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJlIilbMF0uZmlyc3RDaGlsZCwgMSwKKyAg ICAgICAgICAgICAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInByZSIpWzBd LmZpcnN0Q2hpbGQsIDQpOworCisvLyBJbmRlbnQgMiBsaW5lcy4KK3NldFNlbGVjdGlvbihwcmUp OworZXhlY01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNl bGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7CitleGVjRXh0ZW5kU2VsZWN0aW9uRm9yd2Fy ZEJ5V29yZENvbW1hbmQoKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCJpbmRlbnQiKTsKK2lmIChk b2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJlIikubGVuZ3RoID4gMykgeworICAgIC8v IEZJWE1FOiBUaGUgc2VsZWN0aW9uIGZvciB0aGUgYW5jaG9yTm9kZSBpcyB3cm9uZy4gIEl0IHNo b3VsZCBzdGF5IGF0CisgICAgLy8gdGhlIGJlZ2lubmluZyBvZiAibGluZSB0aHJlZSIsIGJ1dCBp dCBtb3ZlcyB0byB0aGUgZW5kIG9mICJsaW5lIDIiLgorICAgIHZlcmlmeVRleHRTZWxlY3Rpb24o ZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoInByZSIpWzJdLmZpcnN0Q2hpbGQsIDAsCisg ICAgICAgICAgICAgICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50c0J5VGFnTmFtZSgicHJl IilbM10uZmlyc3RDaGlsZCwgNCk7Cit9IGVsc2UgeworICAgIGNvbnNvbGUubG9nKCJXcm9uZyBu dW1iZXIgb2YgcHJlIG5vZGVzLiIpOworfQorCisvLyBJbmRlbnQgPHByZT4gbGluZXMgaW4gYSBs aXN0LgorcHJlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInByZS1saXN0Iik7CitzZXRTZWxl Y3Rpb24ocHJlKTsKK2V4ZWNNb3ZlU2VsZWN0aW9uRm9yd2FyZEJ5TGluZUNvbW1hbmQoKTsKK2V4 ZWNFeHRlbmRTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNlbGVj dGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgiaW5kZW50 Iik7Cit2ZXJpZnlUZXh0U2VsZWN0aW9uKGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJi bG9ja3F1b3RlIilbMl0uZmlyc3RDaGlsZCwgMCwKKyAgICAgICAgICAgICAgICAgICAgZG9jdW1l bnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoImJsb2NrcXVvdGUiKVsyXS5maXJzdENoaWxkLm5leHRT aWJsaW5nLCAxMCk7CisvLyBJbmRlbnRpbmcgPHByZT4gbGluZXMgaW4gYSB0YWJsZS4KK3ByZSA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJwcmUtdGFibGUiKTsKK3NldFNlbGVjdGlvbihwcmUp OworZXhlY01vdmVTZWxlY3Rpb25Gb3J3YXJkQnlMaW5lQ29tbWFuZCgpOworZXhlY0V4dGVuZFNl bGVjdGlvbkZvcndhcmRCeUxpbmVDb21tYW5kKCk7CitleGVjRXh0ZW5kU2VsZWN0aW9uRm9yd2Fy ZEJ5TGluZUNvbW1hbmQoKTsKKy8vIEZJWE1FOiBUaGlzIGlzIHdyb25nLiAgVGhlIHByZSB0YWdz IGdldCBjb3BpZWQgd2hlbiB0aGV5IHNob3VsZG4ndCBiZS4gCisvLyBTZWUgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQyMDA5Citkb2N1bWVudC5leGVjQ29tbWFuZCgi aW5kZW50Iik7Citkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgicmVzdWx0cyIpLmlubmVyVGV4dCA9 ICJQQVNTRUQgKGRpZCBub3QgY3Jhc2gpIjsKKzwvc2NyaXB0PgpkaWZmIC0tZ2l0IGEvV2ViQ29y ZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCAwNjMxMDNhNWM0Y2QyOGZhZDQz Njg5ZGQ2ZjdjYWU5MmVlNWYzOTQ2Li4zYWJkYTM3NjhjMWQzZjkxOWI5NWE0YTY0ZGQ1MWM1Yzc1 YmM2NTI3IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5n ZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDEwLTA3LTA5ICBUb255IENoYW5nICA8dG9ueUBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgT2phbiBWYWZhaS4KKworICAgICAgICBj cmFzaCBpbiBXZWJDb3JlOjpDb21wb3NpdGVFZGl0Q29tbWFuZDo6c3BsaXRUcmVlVG9Ob2RlIHdo ZW4gaW5kZW50aW5nIHByZQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MzgyMzEKKworICAgICAgICBUZXN0OiBlZGl0aW5nL2V4ZWNDb21tYW5kL2luZGVu dC1wcmUuaHRtbAorCisgICAgICAgICogZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpjb3VudFBhcmFncmFwaHMpOgorICAgICAgICAoV2ViQ29yZTo6 SW5kZW50T3V0ZGVudENvbW1hbmQ6OmluZGVudFJlZ2lvbik6IFNwbGl0IHRleHQgbm9kZXMgaW50 byBvbmUgbm9kZSBwZXIgcGFyYWdyYXBoCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgc28gbW92ZVBhcmFncmFwaCBkb2Vzbid0IGdldCBjb25m dXNlZC4KKyAgICAgICAgKFdlYkNvcmU6OkluZGVudE91dGRlbnRDb21tYW5kOjpzcGxpdFRleHRO b2Rlcyk6CisgICAgICAgICogZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oOgorCiAyMDEw LTA3LTA5ICBKZXN1cyBTYW5jaGV6LVBhbGVuY2lhICA8amVzdXMucGFsZW5jaWFAb3BlbmJvc3Nh Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBLZW5uZXRoIFJvaGRlIENocmlzdGlhbnNlbi4K ZGlmZiAtLWdpdCBhL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5jcHAgYi9X ZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuY3BwCmluZGV4IDQxNTg1MjFlNGVj MTNhMzg3OWZmMmNkNmNmYjcxMGFmNzFiY2E5OTQuLmYwNDFhYTcwYjMyN2QzNTQyZGE5Y2M4N2Q5 YzQ2MDcwZDFhZmVjYWEgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50 Q29tbWFuZC5jcHAKKysrIGIvV2ViQ29yZS9lZGl0aW5nL0luZGVudE91dGRlbnRDb21tYW5kLmNw cApAQCAtMzQsNiArMzQsNyBAQAogI2luY2x1ZGUgIkluc2VydExpc3RDb21tYW5kLmgiCiAjaW5j bHVkZSAiUmFuZ2UuaCIKICNpbmNsdWRlICJTcGxpdEVsZW1lbnRDb21tYW5kLmgiCisjaW5jbHVk ZSAiVGV4dC5oIgogI2luY2x1ZGUgIlRleHRJdGVyYXRvci5oIgogI2luY2x1ZGUgImh0bWxlZGl0 aW5nLmgiCiAjaW5jbHVkZSAidmlzaWJsZV91bml0cy5oIgpAQCAtNjIsNiArNjMsMjIgQEAgc3Rh dGljIGJvb2wgaXNMaXN0T3JJbmRlbnRCbG9ja3F1b3RlKGNvbnN0IE5vZGUqIG5vZGUpCiAgICAg cmV0dXJuIG5vZGUgJiYgKG5vZGUtPmhhc1RhZ05hbWUodWxUYWcpIHx8IG5vZGUtPmhhc1RhZ05h bWUob2xUYWcpIHx8IG5vZGUtPmhhc1RhZ05hbWUoYmxvY2txdW90ZVRhZykpOwogfQogCisvLyBU aGlzIGZ1bmN0aW9uIGNhbiByZXR1cm4gLTEgaWYgd2UgYXJlIHVuYWJsZSB0byBjb3VudCB0aGUg cGFyYWdyYXBocyBiZXR3ZWVuIHxzdGFydHwgYW5kIHxlbmR8Lgorc3RhdGljIGludCBjb3VudFBh cmFncmFwaHMoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiBlbmRPZkZpcnN0UGFyYWdyYXBoLCBjb25z dCBWaXNpYmxlUG9zaXRpb24mIGVuZE9mTGFzdFBhcmFncmFwaCkKK3sKKyAgICBpbnQgY291bnQg PSAwOworICAgIFZpc2libGVQb3NpdGlvbiBjdXIgPSBlbmRPZkZpcnN0UGFyYWdyYXBoOworICAg IHdoaWxlIChjdXIgIT0gZW5kT2ZMYXN0UGFyYWdyYXBoKSB7CisgICAgICAgICsrY291bnQ7Cisg ICAgICAgIGN1ciA9IGVuZE9mUGFyYWdyYXBoKGN1ci5uZXh0KCkpOworICAgICAgICAvLyBJZiBz dGFydCBpcyBiZWZvcmUgYSB0YWJsZSBhbmQgZW5kIGlzIGluc2lkZSBhIHRhYmxlLCB3ZSB3aWxs IG5ldmVyIGhpdCBlbmQgYmVjYXVzZSB0aGUKKyAgICAgICAgLy8gd2hvbGUgdGFibGUgaXMgY29u c2lkZXJlZCBhIHNpbmdsZSBwYXJhZ3JhcGguCisgICAgICAgIGlmIChjdXIuaXNOdWxsKCkpCisg ICAgICAgICAgICByZXR1cm4gLTE7CisgICAgfQorICAgIHJldHVybiBjb3VudDsKK30KKwogSW5k ZW50T3V0ZGVudENvbW1hbmQ6OkluZGVudE91dGRlbnRDb21tYW5kKERvY3VtZW50KiBkb2N1bWVu dCwgRUluZGVudFR5cGUgdHlwZU9mQWN0aW9uLCBpbnQgbWFyZ2luSW5QaXhlbHMpCiAgICAgOiBD b21wb3NpdGVFZGl0Q29tbWFuZChkb2N1bWVudCksIG1fdHlwZU9mQWN0aW9uKHR5cGVPZkFjdGlv biksIG1fbWFyZ2luSW5QaXhlbHMobWFyZ2luSW5QaXhlbHMpCiB7CkBAIC0xNDcsNiArMTY0LDI0 IEBAIHZvaWQgSW5kZW50T3V0ZGVudENvbW1hbmQ6OmluZGVudFJlZ2lvbihjb25zdCBWaXNpYmxl UG9zaXRpb24mIHN0YXJ0T2ZTZWxlY3Rpb24sCiAgICAgUmVmUHRyPEVsZW1lbnQ+IGJsb2NrcXVv dGVGb3JOZXh0SW5kZW50OwogICAgIFZpc2libGVQb3NpdGlvbiBlbmRPZkN1cnJlbnRQYXJhZ3Jh cGggPSBlbmRPZlBhcmFncmFwaChzdGFydE9mU2VsZWN0aW9uKTsKICAgICBWaXNpYmxlUG9zaXRp b24gZW5kQWZ0ZXJTZWxlY3Rpb24gPSBlbmRPZlBhcmFncmFwaChlbmRPZlBhcmFncmFwaChlbmRP ZlNlbGVjdGlvbikubmV4dCgpKTsKKyAgICBpbnQgZW5kT2ZDdXJyZW50UGFyYWdyYXBoSW5kZXgg PSBpbmRleEZvclZpc2libGVQb3NpdGlvbihlbmRPZkN1cnJlbnRQYXJhZ3JhcGgpOworICAgIGlu dCBlbmRBZnRlclNlbGVjdGlvbkluZGV4ID0gaW5kZXhGb3JWaXNpYmxlUG9zaXRpb24oZW5kQWZ0 ZXJTZWxlY3Rpb24pOworCisgICAgLy8gV2hlbiBpbmRlbnRpbmcgd2l0aGluIGEgPHByZT4gdGFn LCB3ZSBuZWVkIHRvIHNwbGl0IGVhY2ggcGFyYWdyYXBoIGludG8gYSBzZXBhcmF0ZSBub2RlIGZv ciBtb3ZlUGFyYWdyYXBoV2l0aENsb25lcyB0byB3b3JrLgorICAgIC8vIEhvd2V2ZXIsIHNwbGl0 dGluZyB0ZXh0IG5vZGVzIGNhbiBjYXVzZSBlbmRPZkN1cnJlbnRQYXJhZ3JhcGggYW5kIGVuZEFm dGVyU2VsZWN0aW9uIHRvIHBvaW50IHRvIGFuIGludmFsaWQgcG9zaXRpb24gaWYgd2UKKyAgICAv LyBjaGFuZ2VkIHRoZSB0ZXh0IG5vZGUgaXQgd2FzIHBvaW50aW5nIGF0LiAgU28gd2UgaGF2ZSB0 byByZXNldCB0aGVzZSBwb3NpdGlvbnMuCisgICAgaW50IG51bVBhcmFncmFwaHMgPSBjb3VudFBh cmFncmFwaHMoZW5kT2ZDdXJyZW50UGFyYWdyYXBoLCBlbmRBZnRlclNlbGVjdGlvbik7CisgICAg aWYgKHNwbGl0VGV4dE5vZGVzKHN0YXJ0T2ZQYXJhZ3JhcGgoc3RhcnRPZlNlbGVjdGlvbiksIG51 bVBhcmFncmFwaHMgKyAxKSkgeworICAgICAgICBSZWZQdHI8UmFuZ2U+IGVuZE9mQ3VycmVudFBh cmFncmFwaFJhbmdlID0gVGV4dEl0ZXJhdG9yOjpyYW5nZUZyb21Mb2NhdGlvbkFuZExlbmd0aChk b2N1bWVudCgpLT5kb2N1bWVudEVsZW1lbnQoKSwgZW5kT2ZDdXJyZW50UGFyYWdyYXBoSW5kZXgs IDAsIHRydWUpOworICAgICAgICBSZWZQdHI8UmFuZ2U+IGVuZEFmdGVyU2VsZWN0aW9uUmFuZ2Ug PSBUZXh0SXRlcmF0b3I6OnJhbmdlRnJvbUxvY2F0aW9uQW5kTGVuZ3RoKGRvY3VtZW50KCktPmRv Y3VtZW50RWxlbWVudCgpLCBlbmRBZnRlclNlbGVjdGlvbkluZGV4LCAwLCB0cnVlKTsKKyAgICAg ICAgaWYgKCFlbmRPZkN1cnJlbnRQYXJhZ3JhcGhSYW5nZS5nZXQoKSB8fCAhZW5kQWZ0ZXJTZWxl Y3Rpb25SYW5nZS5nZXQoKSkgeworICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7Cisg ICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgZW5kT2ZDdXJyZW50UGFyYWdy YXBoID0gVmlzaWJsZVBvc2l0aW9uKGVuZE9mQ3VycmVudFBhcmFncmFwaFJhbmdlLT5zdGFydFBv c2l0aW9uKCksIERPV05TVFJFQU0pOworICAgICAgICBlbmRBZnRlclNlbGVjdGlvbiA9IFZpc2li bGVQb3NpdGlvbihlbmRBZnRlclNlbGVjdGlvblJhbmdlLT5zdGFydFBvc2l0aW9uKCksIERPV05T VFJFQU0pOworICAgIH0KKwogICAgIHdoaWxlIChlbmRPZkN1cnJlbnRQYXJhZ3JhcGggIT0gZW5k QWZ0ZXJTZWxlY3Rpb24pIHsKICAgICAgICAgLy8gSXRlcmF0ZSBhY3Jvc3MgdGhlIHNlbGVjdGVk IHBhcmFncmFwaHMuLi4KICAgICAgICAgVmlzaWJsZVBvc2l0aW9uIGVuZE9mTmV4dFBhcmFncmFw aCA9IGVuZE9mUGFyYWdyYXBoKGVuZE9mQ3VycmVudFBhcmFncmFwaC5uZXh0KCkpOwpAQCAtMTcw LDYgKzIwNSwyOSBAQCB2b2lkIEluZGVudE91dGRlbnRDb21tYW5kOjppbmRlbnRSZWdpb24oY29u c3QgVmlzaWJsZVBvc2l0aW9uJiBzdGFydE9mU2VsZWN0aW9uLAogICAgIH0gICAKIH0KIAorLy8g UmV0dXJucyB0cnVlIGlmIGF0IGxlYXN0IG9uZSB0ZXh0IG5vZGUgd2FzIHNwbGl0LgorYm9vbCBJ bmRlbnRPdXRkZW50Q29tbWFuZDo6c3BsaXRUZXh0Tm9kZXMoY29uc3QgVmlzaWJsZVBvc2l0aW9u JiBzdGFydCwgaW50IG51bVBhcmFncmFwaHMpCit7CisgICAgVmlzaWJsZVBvc2l0aW9uIGN1cnJl bnRQYXJhZ3JhcGhTdGFydCA9IHN0YXJ0OworICAgIGJvb2wgaGFzU3BsaXQgPSBmYWxzZTsKKyAg ICBpbnQgcGFyYWdyYXBoQ291bnQ7CisgICAgZm9yIChwYXJhZ3JhcGhDb3VudCA9IDA7IHBhcmFn cmFwaENvdW50IDwgbnVtUGFyYWdyYXBoczsgKytwYXJhZ3JhcGhDb3VudCkgeworICAgICAgICAv LyBJZiB0aGVyZSBhcmUgbXVsdGlwbGUgcGFyYWdyYXBocyBpbiBhIHNpbmdsZSB0ZXh0IG5vZGUs IHdlIHNwbGl0IHRoZSB0ZXh0IG5vZGUgaW50byBhIHNlcGFyYXRlIG5vZGUgZm9yIGVhY2ggcGFy YWdyYXBoLgorICAgICAgICBpZiAoY3VycmVudFBhcmFncmFwaFN0YXJ0LmRlZXBFcXVpdmFsZW50 KCkubm9kZSgpLT5pc1RleHROb2RlKCkgJiYgY3VycmVudFBhcmFncmFwaFN0YXJ0LmRlZXBFcXVp dmFsZW50KCkubm9kZSgpID09IHN0YXJ0T2ZQYXJhZ3JhcGgoY3VycmVudFBhcmFncmFwaFN0YXJ0 LnByZXZpb3VzKCkpLmRlZXBFcXVpdmFsZW50KCkubm9kZSgpKSB7CisgICAgICAgICAgICBUZXh0 KiB0ZXh0Tm9kZSA9IHN0YXRpY19jYXN0PFRleHQgKj4oY3VycmVudFBhcmFncmFwaFN0YXJ0LmRl ZXBFcXVpdmFsZW50KCkubm9kZSgpKTsKKyAgICAgICAgICAgIGludCBvZmZzZXQgPSBjdXJyZW50 UGFyYWdyYXBoU3RhcnQuZGVlcEVxdWl2YWxlbnQoKS5vZmZzZXRJbkNvbnRhaW5lck5vZGUoKTsK KyAgICAgICAgICAgIHNwbGl0VGV4dE5vZGUodGV4dE5vZGUsIG9mZnNldCk7CisgICAgICAgICAg ICBjdXJyZW50UGFyYWdyYXBoU3RhcnQgPSBWaXNpYmxlUG9zaXRpb24odGV4dE5vZGUsIDAsIFZQ X0RFRkFVTFRfQUZGSU5JVFkpOworICAgICAgICAgICAgaGFzU3BsaXQgPSB0cnVlOworICAgICAg ICB9CisgICAgICAgIFZpc2libGVQb3NpdGlvbiBuZXh0UGFyYWdyYXBoID0gc3RhcnRPZlBhcmFn cmFwaChlbmRPZlBhcmFncmFwaChjdXJyZW50UGFyYWdyYXBoU3RhcnQpLm5leHQoKSk7CisgICAg ICAgIGlmIChuZXh0UGFyYWdyYXBoLmlzTnVsbCgpKQorICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgIGN1cnJlbnRQYXJhZ3JhcGhTdGFydCA9IG5leHRQYXJhZ3JhcGg7CisgICAgfQorICAgIHJl dHVybiBoYXNTcGxpdDsKK30KKwogdm9pZCBJbmRlbnRPdXRkZW50Q29tbWFuZDo6b3V0ZGVudFBh cmFncmFwaCgpCiB7CiAgICAgVmlzaWJsZVBvc2l0aW9uIHZpc2libGVTdGFydE9mUGFyYWdyYXBo ID0gc3RhcnRPZlBhcmFncmFwaChlbmRpbmdTZWxlY3Rpb24oKS52aXNpYmxlU3RhcnQoKSk7CmRp ZmYgLS1naXQgYS9XZWJDb3JlL2VkaXRpbmcvSW5kZW50T3V0ZGVudENvbW1hbmQuaCBiL1dlYkNv cmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oCmluZGV4IDg3MDViZjEwM2MyMjEyMjI5 OGQxZTg0OTVkYzAwN2U5YzI1ODA5MTEuLjg2NDRjYzU2YWE4MjA4MzA1MmU1MmU3YTY1NGE0NjBm ZWYzZGI5NjQgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFu ZC5oCisrKyBiL1dlYkNvcmUvZWRpdGluZy9JbmRlbnRPdXRkZW50Q29tbWFuZC5oCkBAIC01MSw2 ICs1MSw3IEBAIHByaXZhdGU6CiAgICAgdm9pZCBvdXRkZW50UGFyYWdyYXBoKCk7CiAgICAgYm9v bCB0cnlJbmRlbnRpbmdBc0xpc3RJdGVtKGNvbnN0IFZpc2libGVQb3NpdGlvbiYpOwogICAgIHZv aWQgaW5kZW50SW50b0Jsb2NrcXVvdGUoY29uc3QgVmlzaWJsZVBvc2l0aW9uJiwgY29uc3QgVmlz aWJsZVBvc2l0aW9uJiwgUmVmUHRyPEVsZW1lbnQ+Jik7CisgICAgYm9vbCBzcGxpdFRleHROb2Rl cyhjb25zdCBWaXNpYmxlUG9zaXRpb24mIHN0YXJ0LCBpbnQgbnVtUGFyYWdyYXBocyk7CiAKICAg ICBFSW5kZW50VHlwZSBtX3R5cGVPZkFjdGlvbjsKICAgICBpbnQgbV9tYXJnaW5JblBpeGVsczsK