42941 2010-07-24 18:42:53 -0700 Redo fails after text node is split by SplitTextNodeCommand 2010-07-26 02:03:43 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) All All RESOLVED FIXED P2 Normal --- 27156 1 rniwa rniwa abarth darin enrica eric ojan tkent tony webkit.review.bot oldest_to_newest 255779 0 62516 rniwa 2010-07-24 18:42:53 -0700 Created attachment 62516 demonstrates the bug Because SplitTextNodeCommand's doReapply is not implemented and creates new text node when reapplying, re-applying inline style to the first half of the split text node fails. Reproduction steps: 1. Type in "hello" 2. Split into "he" and "llo" by inserting a new paragraph 3. Apply any inline style "he" 4. Undo twice 5. Redo twice Expected result: "he" is bolded Actual result: "he" is not bolded. 255782 1 62518 rniwa 2010-07-24 19:27:07 -0700 Created attachment 62518 Added doReapply to SplitTextNodeCommand Trivial fix. 255841 2 62531 rniwa 2010-07-25 14:05:32 -0700 Created attachment 62531 Added doReapply to SplitTextNodeCommand (asserts parent node is editable) Instead of bailing out of doApply when the parent node is not editable, assert that the parent node is editable because callee shouldn't be calling SplitTextNode on a non-editable text node. 255852 3 eric 2010-07-25 14:30:28 -0700 Attachment 62531 did not build on mac: Build output: http://queues.webkit.org/results/3583474 255859 4 62534 rniwa 2010-07-25 15:00:25 -0700 Created attachment 62534 Added doReapply to SplitTextNodeCommand (asserts parent node is editable) (In reply to comment #3) > Attachment 62531 [details] did not build on mac: > Build output: http://queues.webkit.org/results/3583474 Oh right, ASSERT will be gone in release build and parent isn't accessed elsewhere. Fixed. 255867 5 62534 darin 2010-07-25 19:36:04 -0700 Comment on attachment 62534 Added doReapply to SplitTextNodeCommand (asserts parent node is editable) I don’t understand why this patch is needed. By default, doReapply calls doApply. The existing logic in SplitTextNodeCommand::doApply looks like it would work fine if you called it again after doUnapply was called. I trust that there is a failure because you provide a test case. Could you be more specific about exactly what fails? I suspect there is a much simpler way to fix this. > - Node* parent = m_text2->parentNode(); > - if (!parent || !parent->isContentEditable()) > - return; > + ASSERT(m_text2->parentNode() && m_text2->parentNode()->isContentEditable()); I don’t think it’s a good idea to change this into an assertion. What’s the guarantee this function won’t be called incorrectly? In general, the approach we’ve been using in the editing commands is to have the low level commands themselves do reality checks. This makes it a a little harder to cause crashes by using the functions wrong and also makes it safer to use a doApply function later as a doReapply function, where there has been time for the organization of the document to possibly have been changed a bit. I’m not sure why you decided to reverse this design direction for this particular command. > + executeApply(); I think the function name "execute apply" is vague; two verbs in a row is also hard to parse mentally. The function names for commands, such as doApply and doReapply, are already quirky and a little hard to understand. Adding a function named executeApply adds a bit to the confusion. I won’t suggest another name, because I think there is no need to add functions here at all. 255869 6 rniwa 2010-07-25 20:04:47 -0700 (In reply to comment #5) > By default, doReapply calls doApply. The existing logic in SplitTextNodeCommand::doApply looks like it would work fine if you called it again after doUnapply was called. I trust that there is a failure because you provide a test case. Could you be more specific about exactly what fails? Consider a case where a text node <text> is split into <text#1><text#2> (note <text#1> is the new node and <text#2> is the old <text>). Now, suppose we insert a span before <text#1> to wrap the text. At this point, SplitTextCommand and InsertNodeBeforeCommand are added to in our undo stack. However, when we undo these steps and redo them, SplitTextCommand creates <text#3><text#2> and InsertNodeBeforeCommand fails to insert the span because its m_refChild is still pointing to <text#1>. My test case simulates this process using ApplyStyleCommand (it splits the text node and wrap it with a span). > > - Node* parent = m_text2->parentNode(); > > - if (!parent || !parent->isContentEditable()) > > - return; > > + ASSERT(m_text2->parentNode() && m_text2->parentNode()->isContentEditable()); > > I don’t think it’s a good idea to change this into an assertion. What’s the guarantee this function won’t be called incorrectly? In general, the approach we’ve been using in the editing commands is to have the low level commands themselves do reality checks. This makes it a a little harder to cause crashes by using the functions wrong and also makes it safer to use a doApply function later as a doReapply function, where there has been time for the organization of the document to possibly have been changed a bit. The reason I made this change was because there is no way for the caller to know whether or not the text node was really split other than remembering neighboring nodes and comparing it after the call. I don't think simpler commands should be smart and defensive. That makes the code in composite edit commands to miss condition checks before executing simple commands and assume that the command always succeeds or end up having awkward check & branching for two different cases. > I’m not sure why you decided to reverse this design direction for this particular command. i.e. I don't personally like this design decision. But that's totally off from what the bug is addressing so I could just revert this change. > > + executeApply(); > > I think the function name "execute apply" is vague; two verbs in a row is also hard to parse mentally. The function names for commands, such as doApply and doReapply, are already quirky and a little hard to understand. Adding a function named executeApply adds a bit to the confusion. I followed the pattern for SplitElementCommand. 255873 7 62518 rniwa 2010-07-25 20:31:52 -0700 Comment on attachment 62518 Added doReapply to SplitTextNodeCommand In fact, I'll do that now. Reverted the ASSERT change. 255877 8 darin 2010-07-25 20:35:09 -0700 (In reply to comment #6) > I don't think simpler commands should be smart and defensive. In the past we had serious problems with crashes when we try to undo a command after changes to the document. I changed all the simple command undo and redo code to be defensive; after that change those crashes are almost completely a thing of the past. We should not go back to the old way. I agree that the simple command steps should not be "smart". They should know only enough to do a mechanical operation, and not have some higher level view of how this operation fits into a larger comment. Generally speaking I am not fond of functions that can be "called wrong"; ones that have to do a lot of assertions on their arguments. Overall they are harder to use than functions that do something well defined in all cases, make few assumptions, and hence have to make few assertions. In the initial command execution, in doApply, we could use assertions instead of reality checks. If we wanted to turn the command overall into a “don’t call this wrong” type of function. Something I’d generally prefer not to do. But in undo and redo, in doUnappy and doReapply, we’ll need sufficient checks to make sure the code does not lead to a crash or problem if a careless or malicious JavaScript programmer changes the document between the initial command execution, undo, and redo. > That makes the code in composite edit commands to miss condition checks before executing simple commands and assume that the command always succeeds or end up having awkward check & branching for two different cases. I don’t think these complexities you mention in composite edit commands are affected much at all by the simple edit command policy. I could imagine us adopting a new policy that we do assertions on the initial command execution and limit the runtime checks to the undo/redo code. But I don’t think this is the place to start in that new direction and I’m not sure it’s the right direction. > But that's totally off from what the bug is addressing so I could just revert this change. This is the kind of thing we should talk over before we do it, so I’m glad I had a chance to express my thoughts on this. > > > + executeApply(); > > > > I think the function name "execute apply" is vague; two verbs in a row is also hard to parse mentally. The function names for commands, such as doApply and doReapply, are already quirky and a little hard to understand. Adding a function named executeApply adds a bit to the confusion. > > I followed the pattern for SplitElementCommand. Yes, I don’t like the name there either. OK, here are some other comments on the patch now that I know the basic approach of keeping the node around is needed: - With the patch, the redo code path will crash if m_text2 no longer has a parent node. This can arise when JavaScript programmers change the document between the undo and redo operations. So the code we removed from doApply does need to be kept around for doReapply. - With the patch, the redo code path will now operate on the nodes even if they are now part of non-editable content. That’s a policy change that is probably not an improvement. The code we removed from doApply probably does need to be kept around for doReapply - Since we’re going to keep the text node around, we may need to do some reality checks on it and not do the redo command in certain cases. For example, if the text node has a parent we may want to do nothing. This can arise when JavaScript programmers change the document between the undo and redo operations. One of the benefits of the old approach was that changes to that text node could not interfere with future undo/redo. Otherwise it seems like this patch will be OK. 255879 9 62518 darin 2010-07-25 20:35:47 -0700 Comment on attachment 62518 Added doReapply to SplitTextNodeCommand review- because this removes the needed null check of m_text2->parentNode() as well as the possibly-needed content-editable check from the redo operation. 255880 10 62518 darin 2010-07-25 20:36:10 -0700 Comment on attachment 62518 Added doReapply to SplitTextNodeCommand WebCore/editing/SplitTextNodeCommand.cpp:99 + int ec = 0; We normally use the type ExceptionCode rather than just "int". 255913 11 62546 rniwa 2010-07-25 23:07:54 -0700 Created attachment 62546 Added a test and fix per Darin's comment. (In reply to comment #8) > In the past we had serious problems with crashes when we try to undo a command after changes to the document. I changed all the simple command undo and redo code to be defensive; after that change those crashes are almost completely a thing of the past. We should not go back to the old way. > > I agree that the simple command steps should not be "smart". They should know only enough to do a mechanical operation, and not have some higher level view of how this operation fits into a larger comment. > > Generally speaking I am not fond of functions that can be "called wrong"; ones that have to do a lot of assertions on their arguments. Overall they are harder to use than functions that do something well defined in all cases, make few assumptions, and hence have to make few assertions. I see. Thanks for the detailed explanation. > But in undo and redo, in doUnappy and doReapply, we’ll need sufficient checks to make sure the code does not lead to a crash or problem if a careless or malicious JavaScript programmer changes the document between the initial command execution, undo, and redo. Agreed. > > I followed the pattern for SplitElementCommand. > > Yes, I don’t like the name there either. Renamed but let me know if you have a better one. > - With the patch, the redo code path will crash if m_text2 no longer has a parent node. This can arise when JavaScript programmers change the document between the undo and redo operations. So the code we removed from doApply does need to be kept around for doReapply. Fixed with a test. But AppendChildNode is adding back "hello" and I can't spot where it's coming from. It should probably be addressed in another bug though. > - With the patch, the redo code path will now operate on the nodes even if they are now part of non-editable content. That’s a policy change that is probably not an improvement. The code we removed from doApply probably does need to be kept around for doReapply Fixed. > - Since we’re going to keep the text node around, we may need to do some reality checks on it and not do the redo command in certain cases. For example, if the text node has a parent we may want to do nothing. This can arise when JavaScript programmers change the document between the undo and redo operations. One of the benefits of the old approach was that changes to that text node could not interfere with future undo/redo. Are you talking about the case where m_text1 gets a parent? (In reply to comment #10) > (From update of attachment 62518 [details]) > WebCore/editing/SplitTextNodeCommand.cpp:99 > + int ec = 0; > We normally use the type ExceptionCode rather than just "int". Oops, fixed. 255917 12 62546 darin 2010-07-25 23:17:24 -0700 Comment on attachment 62546 Added a test and fix per Darin's comment. > ExceptionCode ec = 0; > m_text2->insertData(0, prefixText, ec); > + ASSERT(!ec); Asserting here is OK because insertData can only return an exception when the offset is larger than the text size, and we are passing an offset of 0. > + m_text2->parentNode()->insertBefore(m_text1.get(), m_text2.get(), ec); > + ASSERT(!ec); But asserting here seems possibly wrong. Are you sure there are no exceptions that insertBefore might raise in unusual circumstances? 255918 13 darin 2010-07-25 23:17:48 -0700 (In reply to comment #11) > > - Since we’re going to keep the text node around, we may need to do some reality checks on it and not do the redo command in certain cases. For example, if the text node has a parent we may want to do nothing. This can arise when JavaScript programmers change the document between the undo and redo operations. One of the benefits of the old approach was that changes to that text node could not interfere with future undo/redo. > > Are you talking about the case where m_text1 gets a parent? That was one case I thought of. And it should not be a problem because insertBefore takes care of that. But perhaps there are other ways the text node could be in an unusual state. 255921 14 rniwa 2010-07-25 23:30:20 -0700 (In reply to comment #12) > > + m_text2->parentNode()->insertBefore(m_text1.get(), m_text2.get(), ec); > > + ASSERT(!ec); > > But asserting here seems possibly wrong. Are you sure there are no exceptions that insertBefore might raise in unusual circumstances? The only case in which exception occurs is if checkAddChild fails on m_text1 (which seem to happen only if m_text1 was moved out of the document), or removeChild on m_text1's parent caused an exception. I don't think either case is realistic in most cases but I could change it to bail out just to be safe and also to match with the defensive approach taken elsewhere. Should I change it to bail out before I commit or would you prefer to review the patch again before I commit? 255922 15 darin 2010-07-25 23:36:40 -0700 (In reply to comment #14) > The only case in which exception occurs is if checkAddChild fails on m_text1 (which seem to happen only if m_text1 was moved out of the document), or removeChild on m_text1's parent caused an exception. > > I don't think either case is realistic in most cases but I could change it to bail out just to be safe and also to match with the defensive approach taken elsewhere. Should I change it to bail out before I commit or would you prefer to review the patch again before I commit? I don’t know exactly what you mean by realistic. I suppose the question is twofold: 1) Can we prove that an exception never will occur? 2) If an exception does occur, is it important that we do not go on with the removal from the text node? The point of having code like this is to avoid unpleasant crashes that could possibly be security vulnerabilities, and also to avoid possible data loss if half of an editing operation happens and the other half does not. In this case, I think we’re really close to proving (1). I can’t come up with a case where an exception could occur. But usually the burden of proof goes in the other direction. But more importantly, I think the answer to (2) is no. So it’s probably OK to keep running even if we do have an assertion. It goes against good programming practice to assert something that probably won’t happen. We should assert only things we know won’t happen. Assertions are not for wishful thinking. So on balance, I’d suggest removing the assertion, but I don’t really care if we add back code to exit when we get an exception. And I stand by my review+ so you are also welcome to land the patch as-is. 255931 16 rniwa 2010-07-26 00:33:49 -0700 (In reply to comment #15) > > I don't think either case is realistic in most cases but I could change it to bail out just to be safe and also to match with the defensive approach taken elsewhere. Should I change it to bail out before I commit or would you prefer to review the patch again before I commit? > > I don’t know exactly what you mean by realistic. I meant that I couldn't think of a way that the condition occurs but I say it with 100% assurance. > 1) Can we prove that an exception never will occur? No. > 2) If an exception does occur, is it important that we do not go on with the removal from the text node? ... > But more importantly, I think the answer to (2) is no. So it’s probably OK to keep running even if we do have an assertion. I'm not sure I fully understand you but if we somehow fail to insert the node and remove the text, then we end up losing text. So I think the answer to (2) is yes. > It goes against good programming practice to assert something that probably won’t happen. We should assert only things we know won’t happen. Assertions are not for wishful thinking. I agree. > So on balance, I’d suggest removing the assertion, but I don’t really care if we add back code to exit when we get an exception. And I stand by my review+ so you are also welcome to land the patch as-is. I'll add back the bail out since that was the original code to begin with. Thank you again for the detailed reviews. 255942 17 webkit.review.bot 2010-07-26 01:40:13 -0700 http://trac.webkit.org/changeset/64034 might have broken Qt Linux Release 255945 18 rniwa 2010-07-26 02:03:43 -0700 Landed as http://trac.webkit.org/changeset/64034. I don't think the test failure on Qt platform is caused by this patch but will check back tomorrow morning. 62516 2010-07-24 18:42:53 -0700 2010-07-24 18:42:53 -0700 demonstrates the bug split-text-node-bug.html text/html 823 rniwa PGJvZHk+CjxkaXYgaWQ9InRlc3QiIGNvbnRlbnRlZGl0YWJsZT5oZWxsbzwvZGl2Pgo8c2NyaXB0 PgoKdmFyIGRpdiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0Jyk7CndpbmRvdy5nZXRT ZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KGRpdi5maXJzdENoaWxkLCAyLCBkaXYuZmlyc3RD aGlsZCwgMik7CmRvY3VtZW50LmV4ZWNDb21tYW5kKCdJbnNlcnRQYXJhZ3JhcGgnLCB0cnVlLCBu dWxsKTsKLy9kb2N1bWVudC5leGVjQ29tbWFuZCgiSW5zZXJ0VGV4dCIsIGZhbHNlLCAnd29ybGQn KTsKd2luZG93LmdldFNlbGVjdGlvbigpLnNldEJhc2VBbmRFeHRlbnQoZGl2LmZpcnN0Q2hpbGQs IDAsIGRpdi5maXJzdENoaWxkLCAyKTsKZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2JvbGQnLCBmYWxz ZSwgbnVsbCk7Cgpkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKGRvY3VtZW50LmNyZWF0ZVRleHRO b2RlKCdiZWZvcmUgdW5kbzogJytkaXYuaW5uZXJIVE1MKSk7CmRvY3VtZW50LmJvZHkuYXBwZW5k Q2hpbGQoZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnYnInKSk7CmRvY3VtZW50LmV4ZWNDb21tYW5k KCd1bmRvJywgZmFsc2UsIG51bGwpOwpkb2N1bWVudC5leGVjQ29tbWFuZCgndW5kbycsIGZhbHNl LCBudWxsKTsKCmRvY3VtZW50LmV4ZWNDb21tYW5kKCdyZWRvJywgZmFsc2UsIG51bGwpOwpkb2N1 bWVudC5leGVjQ29tbWFuZCgncmVkbycsIGZhbHNlLCBudWxsKTsKZG9jdW1lbnQuYm9keS5hcHBl bmRDaGlsZChkb2N1bWVudC5jcmVhdGVUZXh0Tm9kZSgnYWZ0ZXIgcmVkbzogJytkaXYuaW5uZXJI VE1MKSk7Cgo8L3NjcmlwdD4KPC9ib2R5Pg== 62518 2010-07-24 19:27:07 -0700 2010-07-25 23:07:54 -0700 Added doReapply to SplitTextNodeCommand fix42941 text/plain 6438 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NDAxOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjIgQEAKKzIwMTAtMDctMjQgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVk byBmYWlscyBhZnRlciB0ZXh0IG5vZGUgaXMgc3BsaXQgYnkgU3BsaXRUZXh0Tm9kZUNvbW1hbmQK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQyOTQxCisK KyAgICAgICAgVGhlIGJ1ZyB3YXMgY2F1c2VkIGJ5IFNwbGl0VGV4dE5vZGVDb21tYW5kIG5vdCBp bXBsZW1lbnRpbmcgZG9SZWFwcGx5LgorICAgICAgICBJbXBsZW1lbnRlZCBkb1JlYXBwbHkgYW5k IGFkZGVkIGV4ZWN1dGVBcHBseSB0byBzaGFyZSB0aGUgY29kZSBiZXR3ZWVuIGRvQXBwbHkgYW5k IGRvUmVhcHBseS4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0 LW5vZGUuaHRtbAorCisgICAgICAgICogZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFuZC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6IENhbGxz IGV4ZWN1dGVBcHBseS4KKyAgICAgICAgKFdlYkNvcmU6OlNwbGl0VGV4dE5vZGVDb21tYW5kOjpk b1VuYXBwbHkpOiBEb24ndCBkZWxldGUgbV90ZXh0MSwgd2hpY2ggaXMgbGF0ZXIgdXNlZCBpbiBk b1JlYXBwbHkuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9SZWFw cGx5KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZXhl Y3V0ZUFwcGx5KTogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFu ZC5oOgorCiAyMDEwLTA3LTI0ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvU3Bs aXRUZXh0Tm9kZUNvbW1hbmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TcGxp dFRleHROb2RlQ29tbWFuZC5jcHAJKHJldmlzaW9uIDY0MDEzKQorKysgV2ViQ29yZS9lZGl0aW5n L1NwbGl0VGV4dE5vZGVDb21tYW5kLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTksMTYgKzU5LDEx IEBAIHZvaWQgU3BsaXRUZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogICAgIGlmIChwcmVmaXhU ZXh0LmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgUmVmUHRyPFRleHQ+IHByZWZp eFRleHROb2RlID0gVGV4dDo6Y3JlYXRlKGRvY3VtZW50KCksIHByZWZpeFRleHQpOwotICAgIEFT U0VSVChwcmVmaXhUZXh0Tm9kZSk7Ci0gICAgZG9jdW1lbnQoKS0+Y29weU1hcmtlcnMobV90ZXh0 Mi5nZXQoKSwgMCwgbV9vZmZzZXQsIHByZWZpeFRleHROb2RlLmdldCgpLCAwKTsKKyAgICBtX3Rl eHQxID0gVGV4dDo6Y3JlYXRlKGRvY3VtZW50KCksIHByZWZpeFRleHQpOworICAgIEFTU0VSVCht X3RleHQxKTsKKyAgICBkb2N1bWVudCgpLT5jb3B5TWFya2VycyhtX3RleHQyLmdldCgpLCAwLCBt X29mZnNldCwgbV90ZXh0MS5nZXQoKSwgMCk7CiAKLSAgICBwYXJlbnQtPmluc2VydEJlZm9yZShw cmVmaXhUZXh0Tm9kZS5nZXQoKSwgbV90ZXh0Mi5nZXQoKSwgZWMpOwotICAgIGlmIChlYykKLSAg ICAgICAgcmV0dXJuOwotCi0gICAgbV90ZXh0Mi0+ZGVsZXRlRGF0YSgwLCBtX29mZnNldCwgZWMp OwotICAgIG1fdGV4dDEgPSBwcmVmaXhUZXh0Tm9kZS5yZWxlYXNlKCk7CisgICAgZXhlY3V0ZUFw cGx5KCk7CiB9CiAKIHZvaWQgU3BsaXRUZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCkBAIC03 OCwxNiArNzMsMzMgQEAgdm9pZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKIAog ICAgIEFTU0VSVChtX3RleHQxLT5kb2N1bWVudCgpID09IGRvY3VtZW50KCkpOwogCi0gICAgUmVm UHRyPFRleHQ+IHByZWZpeFRleHROb2RlID0gbV90ZXh0MS5yZWxlYXNlKCk7Ci0gICAgU3RyaW5n IHByZWZpeFRleHQgPSBwcmVmaXhUZXh0Tm9kZS0+ZGF0YSgpOworICAgIFN0cmluZyBwcmVmaXhU ZXh0ID0gbV90ZXh0MS0+ZGF0YSgpOwogCiAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAg bV90ZXh0Mi0+aW5zZXJ0RGF0YSgwLCBwcmVmaXhUZXh0LCBlYyk7Ci0gICAgaWYgKGVjKQorICAg IEFTU0VSVCghZWMpOworCisgICAgZG9jdW1lbnQoKS0+Y29weU1hcmtlcnMobV90ZXh0MS5nZXQo KSwgMCwgcHJlZml4VGV4dC5sZW5ndGgoKSwgbV90ZXh0Mi5nZXQoKSwgMCk7CisgICAgbV90ZXh0 MS0+cmVtb3ZlKGVjKTsKK30KKwordm9pZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9SZWFwcGx5 KCkKK3sKKyAgICBpZiAoIW1fdGV4dDIpCiAgICAgICAgIHJldHVybjsKIAotICAgIGRvY3VtZW50 KCktPmNvcHlNYXJrZXJzKHByZWZpeFRleHROb2RlLmdldCgpLCAwLCBwcmVmaXhUZXh0Lmxlbmd0 aCgpLCBtX3RleHQyLmdldCgpLCAwKTsKLSAgICBwcmVmaXhUZXh0Tm9kZS0+cmVtb3ZlKGVjKTsK KyAgICBleGVjdXRlQXBwbHkoKTsKIH0KIAordm9pZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6ZXhl Y3V0ZUFwcGx5KCkKK3sKKyAgICBBU1NFUlQobV90ZXh0MSk7CisgICAgQVNTRVJUKG1fdGV4dDIp OworCisgICAgaW50IGVjID0gMDsKKyAgICBtX3RleHQyLT5wYXJlbnROb2RlKCktPmluc2VydEJl Zm9yZShtX3RleHQxLmdldCgpLCBtX3RleHQyLmdldCgpLCBlYyk7CisgICAgQVNTRVJUKCFlYyk7 CisgICAgbV90ZXh0Mi0+ZGVsZXRlRGF0YSgwLCBtX29mZnNldCwgZWMpOworfQorICAgIAogfSAv LyBuYW1lc3BhY2UgV2ViQ29yZQpJbmRleDogV2ViQ29yZS9lZGl0aW5nL1NwbGl0VGV4dE5vZGVD b21tYW5kLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9lZGl0aW5nL1NwbGl0VGV4dE5vZGVDb21t YW5kLmgJKHJldmlzaW9uIDY0MDEzKQorKysgV2ViQ29yZS9lZGl0aW5nL1NwbGl0VGV4dE5vZGVD b21tYW5kLmgJKHdvcmtpbmcgY29weSkKQEAgLTQ0LDYgKzQ0LDggQEAgcHJpdmF0ZToKIAogICAg IHZpcnR1YWwgdm9pZCBkb0FwcGx5KCk7CiAgICAgdmlydHVhbCB2b2lkIGRvVW5hcHBseSgpOwor ICAgIHZpcnR1YWwgdm9pZCBkb1JlYXBwbHkoKTsKKyAgICB2b2lkIGV4ZWN1dGVBcHBseSgpOwog CiAgICAgUmVmUHRyPFRleHQ+IG1fdGV4dDE7CiAgICAgUmVmUHRyPFRleHQ+IG1fdGV4dDI7Cklu ZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCShyZXZpc2lvbiA2NDAxOCkKKysrIExheW91dFRlc3RzL0NoYW5nZUxvZwkod29ya2lu ZyBjb3B5KQpAQCAtMSwzICsxLDE2IEBACisyMDEwLTA3LTI0ICBSeW9zdWtlIE5pd2EgIDxybml3 YUB3ZWJraXQub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIEFkZGVkIGEgdGVzdCB0aGF0IHNwbGl0cyBhIHRleHQgbm9kZSBieSBpbnNlcnRpbmcg YSBwYXJhZ3JhcGggYW5kIGFwcGxpZXMgaW5saW5lIHN0eWxlLgorICAgICAgICBUaGUgdGVzdCB0 aGVuIGVuc3VyZXMgdGhhdCB0aGUgc3R5bGUgaXMgcHJlc2VydmVkIGFmdGVyIHVuZG9zIGFuZCBy ZWRvcy4KKworICAgICAgICBSZWRvIGZhaWxzIGFmdGVyIHRleHQgbm9kZSBpcyBzcGxpdCBieSBT cGxpdFRleHROb2RlQ29tbWFuZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9NDI5NDEKKworICAgICAgICAqIGVkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRl eHQtbm9kZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvdW5kby9yZWRv LXNwbGl0LXRleHQtbm9kZS5odG1sOiBBZGRlZC4KKwogMjAxMC0wNy0yNCAgQ2hyaXMgRmxlaXph Y2ggIDxjZmxlaXphY2hAYXBwbGUuY29tPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhdmlkIEtp bHplci4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQtbm9k ZS1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRpdGluZy91bmRvL3Jl ZG8tc3BsaXQtdGV4dC1ub2RlLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKKysrIExheW91dFRl c3RzL2VkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQtbm9kZS1leHBlY3RlZC50eHQJKHJldmlz aW9uIDApCkBAIC0wLDAgKzEsMjYgQEAKK1RoaXMgdGVzdCBzcGxpdHMgYSB0ZXh0IG5vZGUgYnkg aW5zZXJ0aW5nIGEgbmV3IHBhcmFncmFwaCBhbmQgYm9sZHMgdGhlIHRoZSBmaXJzdCBoYWxmLiBJ ZiBzcGxpdFRleHROb2RlIGNvcnJlY3RseSByZWFwcGxpZWQgdGhlIHNwbGl0LCB1bmRvIGFuZCBy ZWRvIHNob3VsZCBwcmVzZXJ2ZSB0aGUgc3R5bGUuIChTZWUgYnVnIDQyOTQxKS4KKworYmVmb3Jl IHVuZG86Cis8RElWIGlkPSJ0ZXN0IiBjb250ZW50RWRpdGFibGU9IiI+Cis8Qj4KKzwjdGV4dD48 c2VsZWN0aW9uLWFuY2hvcj5oZTxzZWxlY3Rpb24tZm9jdXM+PC8jdGV4dD4KKzwvQj4KKzxESVY+ Cis8I3RleHQ+bGxvPC8jdGV4dD4KKzwvRElWPgorPC9ESVY+CisKK2FmdGVyIHVuZG86Cis8RElW IGlkPSJ0ZXN0IiBjb250ZW50RWRpdGFibGU9IiI+Cis8I3RleHQ+aGU8c2VsZWN0aW9uLWNhcmV0 PmxsbzwvI3RleHQ+Cis8L0RJVj4KKworYWZ0ZXIgcmVkbzoKKzxESVYgaWQ9InRlc3QiIGNvbnRl bnRFZGl0YWJsZT0iIj4KKzxCPgorPCN0ZXh0PjxzZWxlY3Rpb24tYW5jaG9yPmhlPHNlbGVjdGlv bi1mb2N1cz48LyN0ZXh0PgorPC9CPgorPERJVj4KKzwjdGV4dD5sbG88LyN0ZXh0PgorPC9ESVY+ Cis8L0RJVj4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQt bm9kZS5odG1sCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRvLXNw bGl0LXRleHQtbm9kZS5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy91 bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjIg QEAKKzxzY3JpcHQgc3JjPSIuLi8uLi9yZXNvdXJjZXMvZHVtcC1hcy1tYXJrdXAuanMiIHR5cGU9 InRleHQvamF2YXNjcmlwdCI+PC9zY3JpcHQ+Cis8Ym9keT4KKzxkaXYgaWQ9InRlc3QiIGNvbnRl bnRlZGl0YWJsZT5oZWxsbzwvZGl2PgorPHNjcmlwdD4KKwordmFyIGRpdiA9IGRvY3VtZW50Lmdl dEVsZW1lbnRCeUlkKCd0ZXN0Jyk7Cit3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0QmFzZUFuZEV4 dGVudChkaXYuZmlyc3RDaGlsZCwgMiwgZGl2LmZpcnN0Q2hpbGQsIDIpOworZG9jdW1lbnQuZXhl Y0NvbW1hbmQoJ0luc2VydFBhcmFncmFwaCcsIHRydWUsIG51bGwpOword2luZG93LmdldFNlbGVj dGlvbigpLnNldEJhc2VBbmRFeHRlbnQoZGl2LmZpcnN0Q2hpbGQsIDAsIGRpdi5maXJzdENoaWxk LCAyKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCdib2xkJywgZmFsc2UsIG51bGwpOworCitNYXJr dXAuZGVzY3JpcHRpb24oIlRoaXMgdGVzdCBzcGxpdHMgYSB0ZXh0IG5vZGUgYnkgaW5zZXJ0aW5n IGEgbmV3IHBhcmFncmFwaCBhbmQgYm9sZHMgdGhlIHRoZSBmaXJzdCBoYWxmLiBJZiBzcGxpdFRl eHROb2RlIGNvcnJlY3RseSByZWFwcGxpZWQgdGhlIHNwbGl0LCB1bmRvIGFuZCByZWRvIHNob3Vs ZCBwcmVzZXJ2ZSB0aGUgc3R5bGUuIChTZWUgYnVnIDQyOTQxKS4iKQorTWFya3VwLmR1bXAoZGl2 LCAiYmVmb3JlIHVuZG8iKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCd1bmRvJywgZmFsc2UsIG51 bGwpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3VuZG8nLCBmYWxzZSwgbnVsbCk7CitNYXJrdXAu ZHVtcChkaXYsICJhZnRlciB1bmRvIik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgncmVkbycsIGZh bHNlLCBudWxsKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCdyZWRvJywgZmFsc2UsIG51bGwpOwor TWFya3VwLmR1bXAoZGl2LCAiYWZ0ZXIgcmVkbyIpOworCis8L3NjcmlwdD4KKzwvYm9keT4K 62531 2010-07-25 14:05:32 -0700 2010-07-25 15:00:25 -0700 Added doReapply to SplitTextNodeCommand (asserts parent node is editable) fix42941b text/plain 6746 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NDAxOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjIgQEAKKzIwMTAtMDctMjQgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVk byBmYWlscyBhZnRlciB0ZXh0IG5vZGUgaXMgc3BsaXQgYnkgU3BsaXRUZXh0Tm9kZUNvbW1hbmQK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQyOTQxCisK KyAgICAgICAgVGhlIGJ1ZyB3YXMgY2F1c2VkIGJ5IFNwbGl0VGV4dE5vZGVDb21tYW5kIG5vdCBp bXBsZW1lbnRpbmcgZG9SZWFwcGx5LgorICAgICAgICBJbXBsZW1lbnRlZCBkb1JlYXBwbHkgYW5k IGFkZGVkIGV4ZWN1dGVBcHBseSB0byBzaGFyZSB0aGUgY29kZSBiZXR3ZWVuIGRvQXBwbHkgYW5k IGRvUmVhcHBseS4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0 LW5vZGUuaHRtbAorCisgICAgICAgICogZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFuZC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6IENhbGxz IGV4ZWN1dGVBcHBseS4KKyAgICAgICAgKFdlYkNvcmU6OlNwbGl0VGV4dE5vZGVDb21tYW5kOjpk b1VuYXBwbHkpOiBEb24ndCBkZWxldGUgbV90ZXh0MSwgd2hpY2ggaXMgbGF0ZXIgdXNlZCBpbiBk b1JlYXBwbHkuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9SZWFw cGx5KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZXhl Y3V0ZUFwcGx5KTogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFu ZC5oOgorCiAyMDEwLTA3LTI0ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvU3Bs aXRUZXh0Tm9kZUNvbW1hbmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TcGxp dFRleHROb2RlQ29tbWFuZC5jcHAJKHJldmlzaW9uIDY0MDEzKQorKysgV2ViQ29yZS9lZGl0aW5n L1NwbGl0VGV4dE5vZGVDb21tYW5kLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNTAsOCArNTAsNyBA QCBTcGxpdFRleHROb2RlQ29tbWFuZDo6U3BsaXRUZXh0Tm9kZUNvbW1hCiB2b2lkIFNwbGl0VGV4 dE5vZGVDb21tYW5kOjpkb0FwcGx5KCkKIHsKICAgICBOb2RlKiBwYXJlbnQgPSBtX3RleHQyLT5w YXJlbnROb2RlKCk7Ci0gICAgaWYgKCFwYXJlbnQgfHwgIXBhcmVudC0+aXNDb250ZW50RWRpdGFi bGUoKSkKLSAgICAgICAgcmV0dXJuOworICAgIEFTU0VSVChwYXJlbnQgJiYgcGFyZW50LT5pc0Nv bnRlbnRFZGl0YWJsZSgpKTsKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogCkBAIC01OSwx NiArNTgsMTEgQEAgdm9pZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSgpCiAgICAgaWYg KHByZWZpeFRleHQuaXNFbXB0eSgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBSZWZQdHI8VGV4 dD4gcHJlZml4VGV4dE5vZGUgPSBUZXh0OjpjcmVhdGUoZG9jdW1lbnQoKSwgcHJlZml4VGV4dCk7 Ci0gICAgQVNTRVJUKHByZWZpeFRleHROb2RlKTsKLSAgICBkb2N1bWVudCgpLT5jb3B5TWFya2Vy cyhtX3RleHQyLmdldCgpLCAwLCBtX29mZnNldCwgcHJlZml4VGV4dE5vZGUuZ2V0KCksIDApOwot Ci0gICAgcGFyZW50LT5pbnNlcnRCZWZvcmUocHJlZml4VGV4dE5vZGUuZ2V0KCksIG1fdGV4dDIu Z2V0KCksIGVjKTsKLSAgICBpZiAoZWMpCi0gICAgICAgIHJldHVybjsKKyAgICBtX3RleHQxID0g VGV4dDo6Y3JlYXRlKGRvY3VtZW50KCksIHByZWZpeFRleHQpOworICAgIEFTU0VSVChtX3RleHQx KTsKKyAgICBkb2N1bWVudCgpLT5jb3B5TWFya2VycyhtX3RleHQyLmdldCgpLCAwLCBtX29mZnNl dCwgbV90ZXh0MS5nZXQoKSwgMCk7CiAKLSAgICBtX3RleHQyLT5kZWxldGVEYXRhKDAsIG1fb2Zm c2V0LCBlYyk7Ci0gICAgbV90ZXh0MSA9IHByZWZpeFRleHROb2RlLnJlbGVhc2UoKTsKKyAgICBl eGVjdXRlQXBwbHkoKTsKIH0KIAogdm9pZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5 KCkKQEAgLTc4LDE2ICs3MiwzMiBAQCB2b2lkIFNwbGl0VGV4dE5vZGVDb21tYW5kOjpkb1VuYXBw bHkoKQogCiAgICAgQVNTRVJUKG1fdGV4dDEtPmRvY3VtZW50KCkgPT0gZG9jdW1lbnQoKSk7CiAK LSAgICBSZWZQdHI8VGV4dD4gcHJlZml4VGV4dE5vZGUgPSBtX3RleHQxLnJlbGVhc2UoKTsKLSAg ICBTdHJpbmcgcHJlZml4VGV4dCA9IHByZWZpeFRleHROb2RlLT5kYXRhKCk7CisgICAgU3RyaW5n IHByZWZpeFRleHQgPSBtX3RleHQxLT5kYXRhKCk7CiAKICAgICBFeGNlcHRpb25Db2RlIGVjID0g MDsKICAgICBtX3RleHQyLT5pbnNlcnREYXRhKDAsIHByZWZpeFRleHQsIGVjKTsKLSAgICBpZiAo ZWMpCi0gICAgICAgIHJldHVybjsKKyAgICBBU1NFUlQoIWVjKTsKIAotICAgIGRvY3VtZW50KCkt PmNvcHlNYXJrZXJzKHByZWZpeFRleHROb2RlLmdldCgpLCAwLCBwcmVmaXhUZXh0Lmxlbmd0aCgp LCBtX3RleHQyLmdldCgpLCAwKTsKLSAgICBwcmVmaXhUZXh0Tm9kZS0+cmVtb3ZlKGVjKTsKKyAg ICBkb2N1bWVudCgpLT5jb3B5TWFya2VycyhtX3RleHQxLmdldCgpLCAwLCBwcmVmaXhUZXh0Lmxl bmd0aCgpLCBtX3RleHQyLmdldCgpLCAwKTsKKyAgICBtX3RleHQxLT5yZW1vdmUoZWMpOwogfQog Cit2b2lkIFNwbGl0VGV4dE5vZGVDb21tYW5kOjpkb1JlYXBwbHkoKQoreworICAgIGlmICghbV90 ZXh0MikKKyAgICAgICAgcmV0dXJuOworICAgIGV4ZWN1dGVBcHBseSgpOworfQorCit2b2lkIFNw bGl0VGV4dE5vZGVDb21tYW5kOjpleGVjdXRlQXBwbHkoKQoreworICAgIEFTU0VSVChtX3RleHQx KTsKKyAgICBBU1NFUlQobV90ZXh0Mik7CisKKyAgICBpbnQgZWMgPSAwOworICAgIG1fdGV4dDIt PnBhcmVudE5vZGUoKS0+aW5zZXJ0QmVmb3JlKG1fdGV4dDEuZ2V0KCksIG1fdGV4dDIuZ2V0KCks IGVjKTsKKyAgICBBU1NFUlQoIWVjKTsKKyAgICBtX3RleHQyLT5kZWxldGVEYXRhKDAsIG1fb2Zm c2V0LCBlYyk7Cit9CisgICAgCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBXZWJDb3Jl L2VkaXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL2Vk aXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuaAkocmV2aXNpb24gNjQwMTMpCisrKyBXZWJDb3Jl L2VkaXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuaAkod29ya2luZyBjb3B5KQpAQCAtNDQsNiAr NDQsOCBAQCBwcml2YXRlOgogCiAgICAgdmlydHVhbCB2b2lkIGRvQXBwbHkoKTsKICAgICB2aXJ0 dWFsIHZvaWQgZG9VbmFwcGx5KCk7CisgICAgdmlydHVhbCB2b2lkIGRvUmVhcHBseSgpOworICAg IHZvaWQgZXhlY3V0ZUFwcGx5KCk7CiAKICAgICBSZWZQdHI8VGV4dD4gbV90ZXh0MTsKICAgICBS ZWZQdHI8VGV4dD4gbV90ZXh0MjsKSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDY0MDE4KQorKysgTGF5b3V0 VGVzdHMvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTAtMDct MjQgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5vcmc+CisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkZWQgYSB0ZXN0IHRoYXQgc3BsaXRzIGEg dGV4dCBub2RlIGJ5IGluc2VydGluZyBhIHBhcmFncmFwaCBhbmQgYXBwbGllcyBpbmxpbmUgc3R5 bGUuCisgICAgICAgIFRoZSB0ZXN0IHRoZW4gZW5zdXJlcyB0aGF0IHRoZSBzdHlsZSBpcyBwcmVz ZXJ2ZWQgYWZ0ZXIgdW5kb3MgYW5kIHJlZG9zLgorCisgICAgICAgIFJlZG8gZmFpbHMgYWZ0ZXIg dGV4dCBub2RlIGlzIHNwbGl0IGJ5IFNwbGl0VGV4dE5vZGVDb21tYW5kCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD00Mjk0MQorCisgICAgICAgICogZWRp dGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAg ICAgICogZWRpdGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLmh0bWw6IEFkZGVkLgorCiAy MDEwLTA3LTI0ICBDaHJpcyBGbGVpemFjaCAgPGNmbGVpemFjaEBhcHBsZS5jb20+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgRGF2aWQgS2lsemVyLgpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGluZy91 bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLWV4cGVjdGVkLnR4dAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlv dXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5vZGUtZXhwZWN0ZWQudHh0CShy ZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvZWRpdGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC1u b2RlLWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyNiBAQAorVGhpcyB0ZXN0 IHNwbGl0cyBhIHRleHQgbm9kZSBieSBpbnNlcnRpbmcgYSBuZXcgcGFyYWdyYXBoIGFuZCBib2xk cyB0aGUgdGhlIGZpcnN0IGhhbGYuIElmIHNwbGl0VGV4dE5vZGUgY29ycmVjdGx5IHJlYXBwbGll ZCB0aGUgc3BsaXQsIHVuZG8gYW5kIHJlZG8gc2hvdWxkIHByZXNlcnZlIHRoZSBzdHlsZS4gKFNl ZSBidWcgNDI5NDEpLgorCitiZWZvcmUgdW5kbzoKKzxESVYgaWQ9InRlc3QiIGNvbnRlbnRFZGl0 YWJsZT0iIj4KKzxCPgorPCN0ZXh0PjxzZWxlY3Rpb24tYW5jaG9yPmhlPHNlbGVjdGlvbi1mb2N1 cz48LyN0ZXh0PgorPC9CPgorPERJVj4KKzwjdGV4dD5sbG88LyN0ZXh0PgorPC9ESVY+Cis8L0RJ Vj4KKworYWZ0ZXIgdW5kbzoKKzxESVYgaWQ9InRlc3QiIGNvbnRlbnRFZGl0YWJsZT0iIj4KKzwj dGV4dD5oZTxzZWxlY3Rpb24tY2FyZXQ+bGxvPC8jdGV4dD4KKzwvRElWPgorCithZnRlciByZWRv OgorPERJViBpZD0idGVzdCIgY29udGVudEVkaXRhYmxlPSIiPgorPEI+Cis8I3RleHQ+PHNlbGVj dGlvbi1hbmNob3I+aGU8c2VsZWN0aW9uLWZvY3VzPjwvI3RleHQ+Cis8L0I+Cis8RElWPgorPCN0 ZXh0PmxsbzwvI3RleHQ+Cis8L0RJVj4KKzwvRElWPgpJbmRleDogTGF5b3V0VGVzdHMvZWRpdGlu Zy91bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVz dHMvZWRpdGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLmh0bWwJKHJldmlzaW9uIDApCisr KyBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5vZGUuaHRtbAkocmV2 aXNpb24gMCkKQEAgLTAsMCArMSwyMiBAQAorPHNjcmlwdCBzcmM9Ii4uLy4uL3Jlc291cmNlcy9k dW1wLWFzLW1hcmt1cC5qcyIgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij48L3NjcmlwdD4KKzxib2R5 PgorPGRpdiBpZD0idGVzdCIgY29udGVudGVkaXRhYmxlPmhlbGxvPC9kaXY+Cis8c2NyaXB0Pgor Cit2YXIgZGl2ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKTsKK3dpbmRvdy5nZXRT ZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KGRpdi5maXJzdENoaWxkLCAyLCBkaXYuZmlyc3RD aGlsZCwgMik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgnSW5zZXJ0UGFyYWdyYXBoJywgdHJ1ZSwg bnVsbCk7Cit3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0QmFzZUFuZEV4dGVudChkaXYuZmlyc3RD aGlsZCwgMCwgZGl2LmZpcnN0Q2hpbGQsIDIpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2JvbGQn LCBmYWxzZSwgbnVsbCk7CisKK01hcmt1cC5kZXNjcmlwdGlvbigiVGhpcyB0ZXN0IHNwbGl0cyBh IHRleHQgbm9kZSBieSBpbnNlcnRpbmcgYSBuZXcgcGFyYWdyYXBoIGFuZCBib2xkcyB0aGUgdGhl IGZpcnN0IGhhbGYuIElmIHNwbGl0VGV4dE5vZGUgY29ycmVjdGx5IHJlYXBwbGllZCB0aGUgc3Bs aXQsIHVuZG8gYW5kIHJlZG8gc2hvdWxkIHByZXNlcnZlIHRoZSBzdHlsZS4gKFNlZSBidWcgNDI5 NDEpLiIpCitNYXJrdXAuZHVtcChkaXYsICJiZWZvcmUgdW5kbyIpOworZG9jdW1lbnQuZXhlY0Nv bW1hbmQoJ3VuZG8nLCBmYWxzZSwgbnVsbCk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgndW5kbycs IGZhbHNlLCBudWxsKTsKK01hcmt1cC5kdW1wKGRpdiwgImFmdGVyIHVuZG8iKTsKK2RvY3VtZW50 LmV4ZWNDb21tYW5kKCdyZWRvJywgZmFsc2UsIG51bGwpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQo J3JlZG8nLCBmYWxzZSwgbnVsbCk7CitNYXJrdXAuZHVtcChkaXYsICJhZnRlciByZWRvIik7CisK Kzwvc2NyaXB0PgorPC9ib2R5Pgo= 62534 2010-07-25 15:00:25 -0700 2010-07-25 23:07:54 -0700 Added doReapply to SplitTextNodeCommand (asserts parent node is editable) fix42941c text/plain 6778 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NDAxOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjIgQEAKKzIwMTAtMDctMjQgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVk byBmYWlscyBhZnRlciB0ZXh0IG5vZGUgaXMgc3BsaXQgYnkgU3BsaXRUZXh0Tm9kZUNvbW1hbmQK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQyOTQxCisK KyAgICAgICAgVGhlIGJ1ZyB3YXMgY2F1c2VkIGJ5IFNwbGl0VGV4dE5vZGVDb21tYW5kIG5vdCBp bXBsZW1lbnRpbmcgZG9SZWFwcGx5LgorICAgICAgICBJbXBsZW1lbnRlZCBkb1JlYXBwbHkgYW5k IGFkZGVkIGV4ZWN1dGVBcHBseSB0byBzaGFyZSB0aGUgY29kZSBiZXR3ZWVuIGRvQXBwbHkgYW5k IGRvUmVhcHBseS4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0 LW5vZGUuaHRtbAorCisgICAgICAgICogZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFuZC5jcHA6 CisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9BcHBseSk6IENhbGxz IGV4ZWN1dGVBcHBseS4KKyAgICAgICAgKFdlYkNvcmU6OlNwbGl0VGV4dE5vZGVDb21tYW5kOjpk b1VuYXBwbHkpOiBEb24ndCBkZWxldGUgbV90ZXh0MSwgd2hpY2ggaXMgbGF0ZXIgdXNlZCBpbiBk b1JlYXBwbHkuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9SZWFw cGx5KTogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2RlQ29tbWFuZDo6ZXhl Y3V0ZUFwcGx5KTogQWRkZWQuCisgICAgICAgICogZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFu ZC5oOgorCiAyMDEwLTA3LTI0ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5vcmc+CiAKICAg ICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCkluZGV4OiBXZWJDb3JlL2VkaXRpbmcvU3Bs aXRUZXh0Tm9kZUNvbW1hbmQuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TcGxp dFRleHROb2RlQ29tbWFuZC5jcHAJKHJldmlzaW9uIDY0MDEzKQorKysgV2ViQ29yZS9lZGl0aW5n L1NwbGl0VGV4dE5vZGVDb21tYW5kLmNwcAkod29ya2luZyBjb3B5KQpAQCAtNDksOSArNDksNyBA QCBTcGxpdFRleHROb2RlQ29tbWFuZDo6U3BsaXRUZXh0Tm9kZUNvbW1hCiAKIHZvaWQgU3BsaXRU ZXh0Tm9kZUNvbW1hbmQ6OmRvQXBwbHkoKQogewotICAgIE5vZGUqIHBhcmVudCA9IG1fdGV4dDIt PnBhcmVudE5vZGUoKTsKLSAgICBpZiAoIXBhcmVudCB8fCAhcGFyZW50LT5pc0NvbnRlbnRFZGl0 YWJsZSgpKQotICAgICAgICByZXR1cm47CisgICAgQVNTRVJUKG1fdGV4dDItPnBhcmVudE5vZGUo KSAmJiBtX3RleHQyLT5wYXJlbnROb2RlKCktPmlzQ29udGVudEVkaXRhYmxlKCkpOwogCiAgICAg RXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAKQEAgLTU5LDE2ICs1NywxMSBAQCB2b2lkIFNwbGl0VGV4 dE5vZGVDb21tYW5kOjpkb0FwcGx5KCkKICAgICBpZiAocHJlZml4VGV4dC5pc0VtcHR5KCkpCiAg ICAgICAgIHJldHVybjsKIAotICAgIFJlZlB0cjxUZXh0PiBwcmVmaXhUZXh0Tm9kZSA9IFRleHQ6 OmNyZWF0ZShkb2N1bWVudCgpLCBwcmVmaXhUZXh0KTsKLSAgICBBU1NFUlQocHJlZml4VGV4dE5v ZGUpOwotICAgIGRvY3VtZW50KCktPmNvcHlNYXJrZXJzKG1fdGV4dDIuZ2V0KCksIDAsIG1fb2Zm c2V0LCBwcmVmaXhUZXh0Tm9kZS5nZXQoKSwgMCk7Ci0KLSAgICBwYXJlbnQtPmluc2VydEJlZm9y ZShwcmVmaXhUZXh0Tm9kZS5nZXQoKSwgbV90ZXh0Mi5nZXQoKSwgZWMpOwotICAgIGlmIChlYykK LSAgICAgICAgcmV0dXJuOworICAgIG1fdGV4dDEgPSBUZXh0OjpjcmVhdGUoZG9jdW1lbnQoKSwg cHJlZml4VGV4dCk7CisgICAgQVNTRVJUKG1fdGV4dDEpOworICAgIGRvY3VtZW50KCktPmNvcHlN YXJrZXJzKG1fdGV4dDIuZ2V0KCksIDAsIG1fb2Zmc2V0LCBtX3RleHQxLmdldCgpLCAwKTsKIAot ICAgIG1fdGV4dDItPmRlbGV0ZURhdGEoMCwgbV9vZmZzZXQsIGVjKTsKLSAgICBtX3RleHQxID0g cHJlZml4VGV4dE5vZGUucmVsZWFzZSgpOworICAgIGV4ZWN1dGVBcHBseSgpOwogfQogCiB2b2lk IFNwbGl0VGV4dE5vZGVDb21tYW5kOjpkb1VuYXBwbHkoKQpAQCAtNzgsMTYgKzcxLDMyIEBAIHZv aWQgU3BsaXRUZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCiAKICAgICBBU1NFUlQobV90ZXh0 MS0+ZG9jdW1lbnQoKSA9PSBkb2N1bWVudCgpKTsKIAotICAgIFJlZlB0cjxUZXh0PiBwcmVmaXhU ZXh0Tm9kZSA9IG1fdGV4dDEucmVsZWFzZSgpOwotICAgIFN0cmluZyBwcmVmaXhUZXh0ID0gcHJl Zml4VGV4dE5vZGUtPmRhdGEoKTsKKyAgICBTdHJpbmcgcHJlZml4VGV4dCA9IG1fdGV4dDEtPmRh dGEoKTsKIAogICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOwogICAgIG1fdGV4dDItPmluc2VydERh dGEoMCwgcHJlZml4VGV4dCwgZWMpOwotICAgIGlmIChlYykKLSAgICAgICAgcmV0dXJuOworICAg IEFTU0VSVCghZWMpOwogCi0gICAgZG9jdW1lbnQoKS0+Y29weU1hcmtlcnMocHJlZml4VGV4dE5v ZGUuZ2V0KCksIDAsIHByZWZpeFRleHQubGVuZ3RoKCksIG1fdGV4dDIuZ2V0KCksIDApOwotICAg IHByZWZpeFRleHROb2RlLT5yZW1vdmUoZWMpOworICAgIGRvY3VtZW50KCktPmNvcHlNYXJrZXJz KG1fdGV4dDEuZ2V0KCksIDAsIHByZWZpeFRleHQubGVuZ3RoKCksIG1fdGV4dDIuZ2V0KCksIDAp OworICAgIG1fdGV4dDEtPnJlbW92ZShlYyk7CiB9CiAKK3ZvaWQgU3BsaXRUZXh0Tm9kZUNvbW1h bmQ6OmRvUmVhcHBseSgpCit7CisgICAgaWYgKCFtX3RleHQyKQorICAgICAgICByZXR1cm47Cisg ICAgZXhlY3V0ZUFwcGx5KCk7Cit9CisKK3ZvaWQgU3BsaXRUZXh0Tm9kZUNvbW1hbmQ6OmV4ZWN1 dGVBcHBseSgpCit7CisgICAgQVNTRVJUKG1fdGV4dDEpOworICAgIEFTU0VSVChtX3RleHQyKTsK KworICAgIGludCBlYyA9IDA7CisgICAgbV90ZXh0Mi0+cGFyZW50Tm9kZSgpLT5pbnNlcnRCZWZv cmUobV90ZXh0MS5nZXQoKSwgbV90ZXh0Mi5nZXQoKSwgZWMpOworICAgIEFTU0VSVCghZWMpOwor ICAgIG1fdGV4dDItPmRlbGV0ZURhdGEoMCwgbV9vZmZzZXQsIGVjKTsKK30KKyAgICAKIH0gLy8g bmFtZXNwYWNlIFdlYkNvcmUKSW5kZXg6IFdlYkNvcmUvZWRpdGluZy9TcGxpdFRleHROb2RlQ29t bWFuZC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFu ZC5oCShyZXZpc2lvbiA2NDAxMykKKysrIFdlYkNvcmUvZWRpdGluZy9TcGxpdFRleHROb2RlQ29t bWFuZC5oCSh3b3JraW5nIGNvcHkpCkBAIC00NCw2ICs0NCw4IEBAIHByaXZhdGU6CiAKICAgICB2 aXJ0dWFsIHZvaWQgZG9BcHBseSgpOwogICAgIHZpcnR1YWwgdm9pZCBkb1VuYXBwbHkoKTsKKyAg ICB2aXJ0dWFsIHZvaWQgZG9SZWFwcGx5KCk7CisgICAgdm9pZCBleGVjdXRlQXBwbHkoKTsKIAog ICAgIFJlZlB0cjxUZXh0PiBtX3RleHQxOwogICAgIFJlZlB0cjxUZXh0PiBtX3RleHQyOwpJbmRl eDogTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5n ZUxvZwkocmV2aXNpb24gNjQwMTgpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcg Y29weSkKQEAgLTEsMyArMSwxNiBAQAorMjAxMC0wNy0yNCAgUnlvc3VrZSBOaXdhICA8cm5pd2FA d2Via2l0Lm9yZz4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBBZGRlZCBhIHRlc3QgdGhhdCBzcGxpdHMgYSB0ZXh0IG5vZGUgYnkgaW5zZXJ0aW5nIGEg cGFyYWdyYXBoIGFuZCBhcHBsaWVzIGlubGluZSBzdHlsZS4KKyAgICAgICAgVGhlIHRlc3QgdGhl biBlbnN1cmVzIHRoYXQgdGhlIHN0eWxlIGlzIHByZXNlcnZlZCBhZnRlciB1bmRvcyBhbmQgcmVk b3MuCisKKyAgICAgICAgUmVkbyBmYWlscyBhZnRlciB0ZXh0IG5vZGUgaXMgc3BsaXQgYnkgU3Bs aXRUZXh0Tm9kZUNvbW1hbmQKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTQyOTQxCisKKyAgICAgICAgKiBlZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0 LW5vZGUtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3VuZG8vcmVkby1z cGxpdC10ZXh0LW5vZGUuaHRtbDogQWRkZWQuCisKIDIwMTAtMDctMjQgIENocmlzIEZsZWl6YWNo ICA8Y2ZsZWl6YWNoQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYXZpZCBLaWx6 ZXIuCkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5vZGUt ZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRv LXNwbGl0LXRleHQtbm9kZS1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5vZGUtZXhwZWN0ZWQudHh0CShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDI2IEBACitUaGlzIHRlc3Qgc3BsaXRzIGEgdGV4dCBub2RlIGJ5IGlu c2VydGluZyBhIG5ldyBwYXJhZ3JhcGggYW5kIGJvbGRzIHRoZSB0aGUgZmlyc3QgaGFsZi4gSWYg c3BsaXRUZXh0Tm9kZSBjb3JyZWN0bHkgcmVhcHBsaWVkIHRoZSBzcGxpdCwgdW5kbyBhbmQgcmVk byBzaG91bGQgcHJlc2VydmUgdGhlIHN0eWxlLiAoU2VlIGJ1ZyA0Mjk0MSkuCisKK2JlZm9yZSB1 bmRvOgorPERJViBpZD0idGVzdCIgY29udGVudEVkaXRhYmxlPSIiPgorPEI+Cis8I3RleHQ+PHNl bGVjdGlvbi1hbmNob3I+aGU8c2VsZWN0aW9uLWZvY3VzPjwvI3RleHQ+Cis8L0I+Cis8RElWPgor PCN0ZXh0PmxsbzwvI3RleHQ+Cis8L0RJVj4KKzwvRElWPgorCithZnRlciB1bmRvOgorPERJViBp ZD0idGVzdCIgY29udGVudEVkaXRhYmxlPSIiPgorPCN0ZXh0PmhlPHNlbGVjdGlvbi1jYXJldD5s bG88LyN0ZXh0PgorPC9ESVY+CisKK2FmdGVyIHJlZG86Cis8RElWIGlkPSJ0ZXN0IiBjb250ZW50 RWRpdGFibGU9IiI+Cis8Qj4KKzwjdGV4dD48c2VsZWN0aW9uLWFuY2hvcj5oZTxzZWxlY3Rpb24t Zm9jdXM+PC8jdGV4dD4KKzwvQj4KKzxESVY+Cis8I3RleHQ+bGxvPC8jdGV4dD4KKzwvRElWPgor PC9ESVY+CkluZGV4OiBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5v ZGUuaHRtbAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxp dC10ZXh0LW5vZGUuaHRtbAkocmV2aXNpb24gMCkKKysrIExheW91dFRlc3RzL2VkaXRpbmcvdW5k by9yZWRvLXNwbGl0LXRleHQtbm9kZS5odG1sCShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDIyIEBA Cis8c2NyaXB0IHNyYz0iLi4vLi4vcmVzb3VyY2VzL2R1bXAtYXMtbWFya3VwLmpzIiB0eXBlPSJ0 ZXh0L2phdmFzY3JpcHQiPjwvc2NyaXB0PgorPGJvZHk+Cis8ZGl2IGlkPSJ0ZXN0IiBjb250ZW50 ZWRpdGFibGU+aGVsbG88L2Rpdj4KKzxzY3JpcHQ+CisKK3ZhciBkaXYgPSBkb2N1bWVudC5nZXRF bGVtZW50QnlJZCgndGVzdCcpOword2luZG93LmdldFNlbGVjdGlvbigpLnNldEJhc2VBbmRFeHRl bnQoZGl2LmZpcnN0Q2hpbGQsIDIsIGRpdi5maXJzdENoaWxkLCAyKTsKK2RvY3VtZW50LmV4ZWND b21tYW5kKCdJbnNlcnRQYXJhZ3JhcGgnLCB0cnVlLCBudWxsKTsKK3dpbmRvdy5nZXRTZWxlY3Rp b24oKS5zZXRCYXNlQW5kRXh0ZW50KGRpdi5maXJzdENoaWxkLCAwLCBkaXYuZmlyc3RDaGlsZCwg Mik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgnYm9sZCcsIGZhbHNlLCBudWxsKTsKKworTWFya3Vw LmRlc2NyaXB0aW9uKCJUaGlzIHRlc3Qgc3BsaXRzIGEgdGV4dCBub2RlIGJ5IGluc2VydGluZyBh IG5ldyBwYXJhZ3JhcGggYW5kIGJvbGRzIHRoZSB0aGUgZmlyc3QgaGFsZi4gSWYgc3BsaXRUZXh0 Tm9kZSBjb3JyZWN0bHkgcmVhcHBsaWVkIHRoZSBzcGxpdCwgdW5kbyBhbmQgcmVkbyBzaG91bGQg cHJlc2VydmUgdGhlIHN0eWxlLiAoU2VlIGJ1ZyA0Mjk0MSkuIikKK01hcmt1cC5kdW1wKGRpdiwg ImJlZm9yZSB1bmRvIik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgndW5kbycsIGZhbHNlLCBudWxs KTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCd1bmRvJywgZmFsc2UsIG51bGwpOworTWFya3VwLmR1 bXAoZGl2LCAiYWZ0ZXIgdW5kbyIpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3JlZG8nLCBmYWxz ZSwgbnVsbCk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgncmVkbycsIGZhbHNlLCBudWxsKTsKK01h cmt1cC5kdW1wKGRpdiwgImFmdGVyIHJlZG8iKTsKKworPC9zY3JpcHQ+Cis8L2JvZHk+Cg== 62546 2010-07-25 23:07:54 -0700 2010-07-25 23:17:24 -0700 Added a test and fix per Darin's comment. fix42941d text/plain 9299 rniwa SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA2NDAyOCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjMgQEAKKzIwMTAtMDctMjUgIFJ5b3N1a2UgTml3YSAgPHJuaXdhQHdlYmtpdC5v cmc+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgUmVk byBmYWlscyBhZnRlciB0ZXh0IG5vZGUgaXMgc3BsaXQgYnkgU3BsaXRUZXh0Tm9kZUNvbW1hbmQK KyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTQyOTQxCisK KyAgICAgICAgVGhlIGJ1ZyB3YXMgY2F1c2VkIGJ5IFNwbGl0VGV4dE5vZGVDb21tYW5kIG5vdCBp bXBsZW1lbnRpbmcgZG9SZWFwcGx5LgorICAgICAgICBJbXBsZW1lbnRlZCBkb1JlYXBwbHkgYW5k IGFkZGVkIGV4ZWN1dGVBcHBseSB0byBzaGFyZSB0aGUgY29kZSBiZXR3ZWVuIGRvQXBwbHkgYW5k IGRvUmVhcHBseS4KKworICAgICAgICBUZXN0OiBlZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0 LW5vZGUuaHRtbAorICAgICAgICAgICAgICBlZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5v ZGUtd2l0aC1yZW1vdmFsLmh0bWwKKworICAgICAgICAqIGVkaXRpbmcvU3BsaXRUZXh0Tm9kZUNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U3BsaXRUZXh0Tm9kZUNvbW1hbmQ6OmRvQXBw bHkpOiBDYWxscyBleGVjdXRlQXBwbHkuCisgICAgICAgIChXZWJDb3JlOjpTcGxpdFRleHROb2Rl Q29tbWFuZDo6ZG9VbmFwcGx5KTogRG9uJ3QgZGVsZXRlIG1fdGV4dDEsIHdoaWNoIGlzIGxhdGVy IHVzZWQgaW4gZG9SZWFwcGx5LgorICAgICAgICAoV2ViQ29yZTo6U3BsaXRUZXh0Tm9kZUNvbW1h bmQ6OmRvUmVhcHBseSk6IEFkZGVkLgorICAgICAgICAoV2ViQ29yZTo6U3BsaXRUZXh0Tm9kZUNv bW1hbmQ6Omluc2VydFRleHQxQW5kVHJpbVRleHQyKTogQWRkZWQuCisgICAgICAgICogZWRpdGlu Zy9TcGxpdFRleHROb2RlQ29tbWFuZC5oOgorCiAyMDEwLTA3LTI1ICBSeW9zdWtlIE5pd2EgIDxy bml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEtlbnQgVGFtdXJhLgpJbmRl eDogV2ViQ29yZS9lZGl0aW5nL1NwbGl0VGV4dE5vZGVDb21tYW5kLmNwcAo9PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0t LSBXZWJDb3JlL2VkaXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuY3BwCShyZXZpc2lvbiA2NDAy OCkKKysrIFdlYkNvcmUvZWRpdGluZy9TcGxpdFRleHROb2RlQ29tbWFuZC5jcHAJKHdvcmtpbmcg Y29weSkKQEAgLTU0LDIxICs1NCwxNSBAQCB2b2lkIFNwbGl0VGV4dE5vZGVDb21tYW5kOjpkb0Fw cGx5KCkKICAgICAgICAgcmV0dXJuOwogCiAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7Ci0KICAg ICBTdHJpbmcgcHJlZml4VGV4dCA9IG1fdGV4dDItPnN1YnN0cmluZ0RhdGEoMCwgbV9vZmZzZXQs IGVjKTsKICAgICBpZiAocHJlZml4VGV4dC5pc0VtcHR5KCkpCiAgICAgICAgIHJldHVybjsKIAot ICAgIFJlZlB0cjxUZXh0PiBwcmVmaXhUZXh0Tm9kZSA9IFRleHQ6OmNyZWF0ZShkb2N1bWVudCgp LCBwcmVmaXhUZXh0KTsKLSAgICBBU1NFUlQocHJlZml4VGV4dE5vZGUpOwotICAgIGRvY3VtZW50 KCktPmNvcHlNYXJrZXJzKG1fdGV4dDIuZ2V0KCksIDAsIG1fb2Zmc2V0LCBwcmVmaXhUZXh0Tm9k ZS5nZXQoKSwgMCk7Ci0KLSAgICBwYXJlbnQtPmluc2VydEJlZm9yZShwcmVmaXhUZXh0Tm9kZS5n ZXQoKSwgbV90ZXh0Mi5nZXQoKSwgZWMpOwotICAgIGlmIChlYykKLSAgICAgICAgcmV0dXJuOwor ICAgIG1fdGV4dDEgPSBUZXh0OjpjcmVhdGUoZG9jdW1lbnQoKSwgcHJlZml4VGV4dCk7CisgICAg QVNTRVJUKG1fdGV4dDEpOworICAgIGRvY3VtZW50KCktPmNvcHlNYXJrZXJzKG1fdGV4dDIuZ2V0 KCksIDAsIG1fb2Zmc2V0LCBtX3RleHQxLmdldCgpLCAwKTsKIAotICAgIG1fdGV4dDItPmRlbGV0 ZURhdGEoMCwgbV9vZmZzZXQsIGVjKTsKLSAgICBtX3RleHQxID0gcHJlZml4VGV4dE5vZGUucmVs ZWFzZSgpOworICAgIGluc2VydFRleHQxQW5kVHJpbVRleHQyKCk7CiB9CiAKIHZvaWQgU3BsaXRU ZXh0Tm9kZUNvbW1hbmQ6OmRvVW5hcHBseSgpCkBAIC03OCwxNiArNzIsMzQgQEAgdm9pZCBTcGxp dFRleHROb2RlQ29tbWFuZDo6ZG9VbmFwcGx5KCkKIAogICAgIEFTU0VSVChtX3RleHQxLT5kb2N1 bWVudCgpID09IGRvY3VtZW50KCkpOwogCi0gICAgUmVmUHRyPFRleHQ+IHByZWZpeFRleHROb2Rl ID0gbV90ZXh0MS5yZWxlYXNlKCk7Ci0gICAgU3RyaW5nIHByZWZpeFRleHQgPSBwcmVmaXhUZXh0 Tm9kZS0+ZGF0YSgpOworICAgIFN0cmluZyBwcmVmaXhUZXh0ID0gbV90ZXh0MS0+ZGF0YSgpOwog CiAgICAgRXhjZXB0aW9uQ29kZSBlYyA9IDA7CiAgICAgbV90ZXh0Mi0+aW5zZXJ0RGF0YSgwLCBw cmVmaXhUZXh0LCBlYyk7Ci0gICAgaWYgKGVjKQorICAgIEFTU0VSVCghZWMpOworCisgICAgZG9j dW1lbnQoKS0+Y29weU1hcmtlcnMobV90ZXh0MS5nZXQoKSwgMCwgcHJlZml4VGV4dC5sZW5ndGgo KSwgbV90ZXh0Mi5nZXQoKSwgMCk7CisgICAgbV90ZXh0MS0+cmVtb3ZlKGVjKTsKK30KKwordm9p ZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6ZG9SZWFwcGx5KCkKK3sKKyAgICBpZiAoIW1fdGV4dDEg fHwgIW1fdGV4dDIpCisgICAgICAgIHJldHVybjsKKworICAgIE5vZGUqIHBhcmVudCA9IG1fdGV4 dDItPnBhcmVudE5vZGUoKTsKKyAgICBpZiAoIXBhcmVudCB8fCAhcGFyZW50LT5pc0NvbnRlbnRF ZGl0YWJsZSgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBkb2N1bWVudCgpLT5jb3B5TWFya2Vy cyhwcmVmaXhUZXh0Tm9kZS5nZXQoKSwgMCwgcHJlZml4VGV4dC5sZW5ndGgoKSwgbV90ZXh0Mi5n ZXQoKSwgMCk7Ci0gICAgcHJlZml4VGV4dE5vZGUtPnJlbW92ZShlYyk7CisgICAgaW5zZXJ0VGV4 dDFBbmRUcmltVGV4dDIoKTsKIH0KIAordm9pZCBTcGxpdFRleHROb2RlQ29tbWFuZDo6aW5zZXJ0 VGV4dDFBbmRUcmltVGV4dDIoKQoreworICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgIG1f dGV4dDItPnBhcmVudE5vZGUoKS0+aW5zZXJ0QmVmb3JlKG1fdGV4dDEuZ2V0KCksIG1fdGV4dDIu Z2V0KCksIGVjKTsKKyAgICBBU1NFUlQoIWVjKTsKKyAgICBtX3RleHQyLT5kZWxldGVEYXRhKDAs IG1fb2Zmc2V0LCBlYyk7Cit9CisgICAgCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCkluZGV4OiBX ZWJDb3JlL2VkaXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuaAo9PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJD b3JlL2VkaXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuaAkocmV2aXNpb24gNjQwMjgpCisrKyBX ZWJDb3JlL2VkaXRpbmcvU3BsaXRUZXh0Tm9kZUNvbW1hbmQuaAkod29ya2luZyBjb3B5KQpAQCAt NDQsNiArNDQsOCBAQCBwcml2YXRlOgogCiAgICAgdmlydHVhbCB2b2lkIGRvQXBwbHkoKTsKICAg ICB2aXJ0dWFsIHZvaWQgZG9VbmFwcGx5KCk7CisgICAgdmlydHVhbCB2b2lkIGRvUmVhcHBseSgp OworICAgIHZvaWQgaW5zZXJ0VGV4dDFBbmRUcmltVGV4dDIoKTsKIAogICAgIFJlZlB0cjxUZXh0 PiBtX3RleHQxOwogICAgIFJlZlB0cjxUZXh0PiBtX3RleHQyOwpJbmRleDogTGF5b3V0VGVzdHMv Q2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL0NoYW5nZUxvZwkocmV2aXNpb24g NjQwMjgpCisrKyBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cJKHdvcmtpbmcgY29weSkKQEAgLTEsMyAr MSwyMCBAQAorMjAxMC0wNy0yNSAgUnlvc3VrZSBOaXdhICA8cm5pd2FAd2Via2l0Lm9yZz4KKwor ICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBBZGRlZCBhIHRl c3QgdGhhdCBzcGxpdHMgYSB0ZXh0IG5vZGUgYnkgaW5zZXJ0aW5nIGEgcGFyYWdyYXBoIGFuZCBh cHBsaWVzIGlubGluZSBzdHlsZS4KKyAgICAgICAgVGhlIHRlc3QgdGhlbiBlbnN1cmVzIHRoYXQg dGhlIHN0eWxlIGlzIHByZXNlcnZlZCBhZnRlciB1bmRvcyBhbmQgcmVkb3MuCisKKyAgICAgICAg QWxzbyBhZGRlZCBhIHRlc3QgaW4gd2hpY2ggdGhlIHRleHQgbm9kZSBpcyByZW1vdmVkIGJ5IHRo ZSBzY3JpcHQgYWZ0ZXIgdW5kby4KKworICAgICAgICBSZWRvIGZhaWxzIGFmdGVyIHRleHQgbm9k ZSBpcyBzcGxpdCBieSBTcGxpdFRleHROb2RlQ29tbWFuZAorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NDI5NDEKKworICAgICAgICAqIGVkaXRpbmcvdW5k by9yZWRvLXNwbGl0LXRleHQtbm9kZS1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVk aXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQtbm9kZS5odG1sOiBBZGRlZC4KKyAgICAgICAgKiBl ZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LXdpdGgtcmVtb3ZhbC1leHBlY3RlZC50eHQ6IEFk ZGVkLgorICAgICAgICAqIGVkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQtd2l0aC1yZW1vdmFs Lmh0bWw6IEFkZGVkLgorCiAyMDEwLTA3LTI1ICBBZGFtIEJhcnRoICA8YWJhcnRoQHdlYmtpdC5v cmc+CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgRXJpYyBTZWlkZWwuCkluZGV4OiBMYXlvdXRUZXN0 cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5vZGUtZXhwZWN0ZWQudHh0Cj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQtbm9kZS1leHBl Y3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1z cGxpdC10ZXh0LW5vZGUtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDI3IEBA CitUaGlzIHRlc3Qgc3BsaXRzIGEgdGV4dCBub2RlIGJ5IGluc2VydGluZyBhIG5ldyBwYXJhZ3Jh cGggYW5kIGJvbGRzIHRoZSB0aGUgZmlyc3QgaGFsZi4KK0lmIHNwbGl0VGV4dE5vZGUgY29ycmVj dGx5IHJlYXBwbGllZCB0aGUgc3BsaXQsIHVuZG8gYW5kIHJlZG8gc2hvdWxkIHByZXNlcnZlIHRo ZSBzdHlsZS4gKFNlZSBidWcgNDI5NDEpLgorCitiZWZvcmUgdW5kbzoKKzxESVYgaWQ9InRlc3Qi IGNvbnRlbnRFZGl0YWJsZT0iIj4KKzxCPgorPCN0ZXh0PjxzZWxlY3Rpb24tYW5jaG9yPmhlPHNl bGVjdGlvbi1mb2N1cz48LyN0ZXh0PgorPC9CPgorPERJVj4KKzwjdGV4dD5sbG88LyN0ZXh0Pgor PC9ESVY+Cis8L0RJVj4KKworYWZ0ZXIgdW5kbzoKKzxESVYgaWQ9InRlc3QiIGNvbnRlbnRFZGl0 YWJsZT0iIj4KKzwjdGV4dD5oZTxzZWxlY3Rpb24tY2FyZXQ+bGxvPC8jdGV4dD4KKzwvRElWPgor CithZnRlciByZWRvOgorPERJViBpZD0idGVzdCIgY29udGVudEVkaXRhYmxlPSIiPgorPEI+Cis8 I3RleHQ+PHNlbGVjdGlvbi1hbmNob3I+aGU8c2VsZWN0aW9uLWZvY3VzPjwvI3RleHQ+Cis8L0I+ Cis8RElWPgorPCN0ZXh0PmxsbzwvI3RleHQ+Cis8L0RJVj4KKzwvRElWPgpJbmRleDogTGF5b3V0 VGVzdHMvZWRpdGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLmh0bWwKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQot LS0gTGF5b3V0VGVzdHMvZWRpdGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC1ub2RlLmh0bWwJKHJl dmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LW5v ZGUuaHRtbAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMiBAQAorPHNjcmlwdCBzcmM9Ii4uLy4u L3Jlc291cmNlcy9kdW1wLWFzLW1hcmt1cC5qcyIgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij48L3Nj cmlwdD4KKzxib2R5PgorPGRpdiBpZD0idGVzdCIgY29udGVudGVkaXRhYmxlPmhlbGxvPC9kaXY+ Cis8c2NyaXB0PgorCit2YXIgZGl2ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3Rlc3QnKTsK K3dpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KGRpdi5maXJzdENoaWxkLCAy LCBkaXYuZmlyc3RDaGlsZCwgMik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgnSW5zZXJ0UGFyYWdy YXBoJywgdHJ1ZSwgbnVsbCk7Cit3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0QmFzZUFuZEV4dGVu dChkaXYuZmlyc3RDaGlsZCwgMCwgZGl2LmZpcnN0Q2hpbGQsIDIpOworZG9jdW1lbnQuZXhlY0Nv bW1hbmQoJ2JvbGQnLCBmYWxzZSwgbnVsbCk7CisKK01hcmt1cC5kZXNjcmlwdGlvbigiVGhpcyB0 ZXN0IHNwbGl0cyBhIHRleHQgbm9kZSBieSBpbnNlcnRpbmcgYSBuZXcgcGFyYWdyYXBoIGFuZCBi b2xkcyB0aGUgdGhlIGZpcnN0IGhhbGYuXG5JZiBzcGxpdFRleHROb2RlIGNvcnJlY3RseSByZWFw cGxpZWQgdGhlIHNwbGl0LCB1bmRvIGFuZCByZWRvIHNob3VsZCBwcmVzZXJ2ZSB0aGUgc3R5bGUu IChTZWUgYnVnIDQyOTQxKS4iKQorTWFya3VwLmR1bXAoZGl2LCAiYmVmb3JlIHVuZG8iKTsKK2Rv Y3VtZW50LmV4ZWNDb21tYW5kKCd1bmRvJywgZmFsc2UsIG51bGwpOworZG9jdW1lbnQuZXhlY0Nv bW1hbmQoJ3VuZG8nLCBmYWxzZSwgbnVsbCk7CitNYXJrdXAuZHVtcChkaXYsICJhZnRlciB1bmRv Iik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgncmVkbycsIGZhbHNlLCBudWxsKTsKK2RvY3VtZW50 LmV4ZWNDb21tYW5kKCdyZWRvJywgZmFsc2UsIG51bGwpOworTWFya3VwLmR1bXAoZGl2LCAiYWZ0 ZXIgcmVkbyIpOworCis8L3NjcmlwdD4KKzwvYm9keT4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRp bmcvdW5kby9yZWRvLXNwbGl0LXRleHQtd2l0aC1yZW1vdmFsLWV4cGVjdGVkLnR4dAo9PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09Ci0tLSBMYXlvdXRUZXN0cy9lZGl0aW5nL3VuZG8vcmVkby1zcGxpdC10ZXh0LXdpdGgtcmVt b3ZhbC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0cy9lZGl0aW5nL3Vu ZG8vcmVkby1zcGxpdC10ZXh0LXdpdGgtcmVtb3ZhbC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMjggQEAKK1RoaXMgdGVzdCBzcGxpdHMgYSB0ZXh0IG5vZGUgYnkgaW5zZXJ0 aW5nIGEgbmV3IHBhcmFncmFwaCBhbmQgYm9sZHMgdGhlIHRoZSBmaXJzdCBoYWxmLgorQWZ0ZXIg dW5kb2luZyB0aGVzZSB0d28gc3RlcHMsIGl0IHJlbW92ZXMgdGhlIHRleHQgbm9kZSwgYW5kIHRo ZW4gcmVkby4gVGhlIHRlc3Qgc2hvdWxkIG5vdCBjcmFzaC4gKFNlZSBidWcgNDI5NDEpLgorCiti ZWZvcmUgdW5kbzoKKzxESVYgaWQ9InRlc3QiIGNvbnRlbnRFZGl0YWJsZT0iIj4KKzxCPgorPCN0 ZXh0PjxzZWxlY3Rpb24tYW5jaG9yPmhlPHNlbGVjdGlvbi1mb2N1cz48LyN0ZXh0PgorPC9CPgor PERJVj4KKzwjdGV4dD5sbG88LyN0ZXh0PgorPC9ESVY+Cis8L0RJVj4KKworYWZ0ZXIgdW5kbzoK KzxESVYgaWQ9InRlc3QiIGNvbnRlbnRFZGl0YWJsZT0iIj4KKzwjdGV4dD5oZTxzZWxlY3Rpb24t Y2FyZXQ+bGxvPC8jdGV4dD4KKzwvRElWPgorCithZnRlciBub2RlIHJlbW92YWw6Cis8RElWIGlk PSJ0ZXN0IiBjb250ZW50RWRpdGFibGU9IiI+Cis8L0RJVj4KKworYWZ0ZXIgcmVkbzoKKzxESVYg aWQ9InRlc3QiIGNvbnRlbnRFZGl0YWJsZT0iIj4KKzxESVY+Cis8I3RleHQ+aGVsbG88LyN0ZXh0 PgorPC9ESVY+Cis8L0RJVj4KSW5kZXg6IExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRvLXNw bGl0LXRleHQtd2l0aC1yZW1vdmFsLmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvZWRp dGluZy91bmRvL3JlZG8tc3BsaXQtdGV4dC13aXRoLXJlbW92YWwuaHRtbAkocmV2aXNpb24gMCkK KysrIExheW91dFRlc3RzL2VkaXRpbmcvdW5kby9yZWRvLXNwbGl0LXRleHQtd2l0aC1yZW1vdmFs Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMjcgQEAKKzxzY3JpcHQgc3JjPSIuLi8uLi9y ZXNvdXJjZXMvZHVtcC1hcy1tYXJrdXAuanMiIHR5cGU9InRleHQvamF2YXNjcmlwdCI+PC9zY3Jp cHQ+Cis8Ym9keT4KKzxkaXYgaWQ9InRlc3QiIGNvbnRlbnRlZGl0YWJsZT5oZWxsbzwvZGl2Pgor PHNjcmlwdD4KKwordmFyIGRpdiA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCd0ZXN0Jyk7CisK K3dpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KGRpdi5maXJzdENoaWxkLCAy LCBkaXYuZmlyc3RDaGlsZCwgMik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgnSW5zZXJ0UGFyYWdy YXBoJywgdHJ1ZSwgbnVsbCk7Cit3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0QmFzZUFuZEV4dGVu dChkaXYuZmlyc3RDaGlsZCwgMCwgZGl2LmZpcnN0Q2hpbGQsIDIpOworZG9jdW1lbnQuZXhlY0Nv bW1hbmQoJ2JvbGQnLCBmYWxzZSwgbnVsbCk7CisKK01hcmt1cC5kZXNjcmlwdGlvbigiVGhpcyB0 ZXN0IHNwbGl0cyBhIHRleHQgbm9kZSBieSBpbnNlcnRpbmcgYSBuZXcgcGFyYWdyYXBoIGFuZCBi b2xkcyB0aGUgdGhlIGZpcnN0IGhhbGYuXG5BZnRlciB1bmRvaW5nIHRoZXNlIHR3byBzdGVwcywg aXQgcmVtb3ZlcyB0aGUgdGV4dCBub2RlLCBhbmQgdGhlbiByZWRvLiBUaGUgdGVzdCBzaG91bGQg bm90IGNyYXNoLiAoU2VlIGJ1ZyA0Mjk0MSkuIikKK01hcmt1cC5kdW1wKGRpdiwgImJlZm9yZSB1 bmRvIik7Citkb2N1bWVudC5leGVjQ29tbWFuZCgndW5kbycsIGZhbHNlLCBudWxsKTsKK2RvY3Vt ZW50LmV4ZWNDb21tYW5kKCd1bmRvJywgZmFsc2UsIG51bGwpOworCitNYXJrdXAuZHVtcChkaXYs ICJhZnRlciB1bmRvIik7CitkaXYucmVtb3ZlQ2hpbGQoZGl2LmZpcnN0Q2hpbGQpOworTWFya3Vw LmR1bXAoZGl2LCAiYWZ0ZXIgbm9kZSByZW1vdmFsIik7CisKK2RvY3VtZW50LmV4ZWNDb21tYW5k KCdyZWRvJywgZmFsc2UsIG51bGwpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ3JlZG8nLCBmYWxz ZSwgbnVsbCk7CitNYXJrdXAuZHVtcChkaXYsICJhZnRlciByZWRvIik7CisKKzwvc2NyaXB0Pgor PC9ib2R5Pgo=