88484 2012-06-06 19:27:10 -0700 [Shadow][Editing] Deleting character in distributed element caused a crash 2012-06-29 00:44:42 -0700 1 1 1 Unclassified WebKit HTML Editing 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 82697 1 shinyak hayato darin enrica eric hayato rniwa webkit.review.bot oldest_to_newest 643095 0 shinyak 2012-06-06 19:27:10 -0700 <div id="host" contenteditable><div>foo</div></div> var root = new WebKitShadowRoot(host); root.innerHTML = "<content></content>"; When removing 'o' of foo, 'foo' will be deleted. 645737 1 hayato 2012-06-10 22:42:50 -0700 I had a different behavior in r119949. We can remove character by character as expected. But when I tried to remove the last one character, it crashed. ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp(344) : void WebCore::CompositeEditCommand::insertNodeAt(WTF::PassRefPtr<WebCore::Node>, const WebCore::Position&) Let me investigate further. 645762 2 shinyak 2012-06-10 23:51:09 -0700 (In reply to comment #1) > I had a different behavior in r119949. > We can remove character by character as expected. But when I tried to remove the last one character, it crashed. > > ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp(344) : void WebCore::CompositeEditCommand::insertNodeAt(WTF::PassRefPtr<WebCore::Node>, const WebCore::Position&) > > Let me investigate further. Oh... 645913 3 146835 hayato 2012-06-11 05:20:59 -0700 Created attachment 146835 fix 645914 4 hayato 2012-06-11 05:21:48 -0700 This WIP patch is just a quick fix for crashes. Let me add a test later. I am afraid that attaching node while in editing is a bad idea, isn't it? Although I'll think about a better fix which does not require attaching nodes, early feedback from editing guys is welcome. (In reply to comment #3) > Created an attachment (id=146835) [details] > fix 646621 5 hayato 2012-06-11 22:15:39 -0700 Things are not so simple. Let me summarize what the issue is in general: - In applying editing command, If we mutate nodes which are children of a shadow host, it causes ElementShadow:: invalidateDistribution(), which is called from Element::childrenChanged(). As a result, shadow host is detached (and lazyAttached()) and its renderer is gone. - There are many places where we call isEditablePosition(Position) in edition code. The problem is Position's anchorNode might be a shadow host which is currently detached. isEditablePosition(Position) uses anchorNode's renderer to judge whether it is editable or not. So we have to recalcStyle somehow in order to make the shadow host get renderer. Ideally, we should do recalcStyle in isEditablePosition(), but there are other callers of isEditablePosition() other than editing. eg. paintCaret(). Which would fire assertion ASSERT(!isPainting) in recalcStyle. Node::rendererIsEditable() has some notable comments: // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion // would fire in the middle of Document::setFocusedNode(). So there are other callers. That means we can not recalcStyle in isEditablePosition easily. 646646 6 hayato 2012-06-11 23:00:06 -0700 It seems a bad idea that we do recalcStyle in isEditablePosition(Position) anyway. Because that is used in assertion, like ASSERT(isEditablePosition(..)). ASSERT should not have a side effect. (In reply to comment #5) > Things are not so simple. Let me summarize what the issue is in general: > > - In applying editing command, If we mutate nodes which are children of a shadow host, it causes ElementShadow:: invalidateDistribution(), which is called from Element::childrenChanged(). As a result, shadow host is detached (and lazyAttached()) and its renderer is gone. > - There are many places where we call isEditablePosition(Position) in edition code. The problem is Position's anchorNode might be a shadow host which is currently detached. isEditablePosition(Position) uses anchorNode's renderer to judge whether it is editable or not. > > So we have to recalcStyle somehow in order to make the shadow host get renderer. > Ideally, we should do recalcStyle in isEditablePosition(), but there are other callers of isEditablePosition() other than editing. eg. paintCaret(). Which would fire assertion ASSERT(!isPainting) in recalcStyle. > > Node::rendererIsEditable() has some notable comments: > > // Ideally we'd call ASSERT(!needsStyleRecalc()) here, but > // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion > // would fire in the middle of Document::setFocusedNode(). > > So there are other callers. That means we can not recalcStyle in isEditablePosition easily. 646724 7 shinyak 2012-06-12 01:24:27 -0700 The root cause of W88502 seems the same thing... calling invalidateDistribution() will remove renderer()... 647724 8 147242 hayato 2012-06-12 23:12:25 -0700 Created attachment 147242 ensure Editable is available 648509 9 147242 rniwa 2012-06-13 15:25:22 -0700 Comment on attachment 147242 ensure Editable is available View in context: https://bugs.webkit.org/attachment.cgi?id=147242&action=review > Source/WebCore/ChangeLog:14 > + isEditablePosition() assertion in the following insertNodeAt() > + operation. So we have to make sure that style is updated before asking > + isEditablePosition(). Where is insertNodeAt called in this case? We might need to call document()->updateLayoutIgnorePendingStylesheets() in its call site instead. > Source/WebCore/editing/CompositeEditCommand.cpp:344 > + ensureEditableCalculated(editingPosition); What's the point of adding this function? I'd just call document()->updateLayoutIgnorePendingStylesheets() here instead. 648672 10 hayato 2012-06-13 18:50:27 -0700 Thank you for the review. (In reply to comment #9) > (From update of attachment 147242 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=147242&action=review > > > Source/WebCore/ChangeLog:14 > > + isEditablePosition() assertion in the following insertNodeAt() > > + operation. So we have to make sure that style is updated before asking > > + isEditablePosition(). > > Where is insertNodeAt called in this case? We might need to call document()->updateLayoutIgnorePendingStylesheets() in its call site instead. Call stack is here. That is called from DeleteSelectionCommand::doApply(). The previous patch (https://bugs.webkit.org/attachment.cgi?id=146835&action=review) might tells you the exact position. #0 0x00007f7166118716 in WebCore::CompositeEditCommand::insertNodeAt (this=0x7f7155f6c000, insertChild=..., editingPosition=...) at ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp:344 #1 0x00007f716612df6d in WebCore::DeleteSelectionCommand::doApply (this=0x7f7155f6c000) at ../../third_party/WebKit/Source/WebCore/editing/DeleteSelectionCommand.cpp:821 #2 0x00007f7166117d7c in WebCore::CompositeEditCommand::applyCommandToComposite (this=0x7f7155e38c80, prpCommand=...) at ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp:256 #3 0x00007f716611a3ad in WebCore::CompositeEditCommand::deleteSelection (this=0x7f7155e38c80, selection=..., smartDelete=false, mergeBlocksAfterDelete=true, replace=false, expandForSpecialElements=true, sanitizeMarkup=true) at ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp:579 #4 0x00007f7166192ca8 in WebCore::TypingCommand::deleteKeyPressed (this=0x7f7155e38c80, granularity=WebCore::CharacterGranularity, killRing=false) at ... > > > Source/WebCore/editing/CompositeEditCommand.cpp:344 > > + ensureEditableCalculated(editingPosition); > > What's the point of adding this function? I'd like to make the intention clear. See the follow up meta bug also https://bugs.webkit.org/show_bug.cgi?id=88968. I am afraid we have to insert the similar code to other places. It might be better to name the function explicitly. I am okay to make that inline if needed. > I'd just call document()->updateLayoutIgnorePendingStylesheets() here instead. Thank you. updateLayoutIgnorePendingStylesheets() looks better than updateStyleIfNeeded(). But it has a comment: > // FIXME: This is a bad idea and needs to be removed eventually. > // Other browsers load stylesheets before they continue parsing the web page. > // Since we don't, we can run JavaScript code that needs answers before the > // stylesheets are loaded. Doing a layout ignoring the pending stylesheets > // lets us get reasonable answers. The long term solution to this problem is > // to instead suspend JavaScript execution. > void Document::updateLayoutIgnorePendingStylesheets() Do you still suggest using this? 648709 11 147242 rniwa 2012-06-13 19:41:11 -0700 Comment on attachment 147242 ensure Editable is available View in context: https://bugs.webkit.org/attachment.cgi?id=147242&action=review >>> Source/WebCore/ChangeLog:14 >>> + isEditablePosition(). >> >> Where is insertNodeAt called in this case? We might need to call document()->updateLayoutIgnorePendingStylesheets() in its call site instead. > > Call stack is here. That is called from DeleteSelectionCommand::doApply(). The previous patch (https://bugs.webkit.org/attachment.cgi?id=146835&action=review) might tells you the exact position. > > #0 0x00007f7166118716 in WebCore::CompositeEditCommand::insertNodeAt (this=0x7f7155f6c000, insertChild=..., editingPosition=...) at ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp:344 > #1 0x00007f716612df6d in WebCore::DeleteSelectionCommand::doApply (this=0x7f7155f6c000) at ../../third_party/WebKit/Source/WebCore/editing/DeleteSelectionCommand.cpp:821 > #2 0x00007f7166117d7c in WebCore::CompositeEditCommand::applyCommandToComposite (this=0x7f7155e38c80, prpCommand=...) at ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp:256 > #3 0x00007f716611a3ad in WebCore::CompositeEditCommand::deleteSelection (this=0x7f7155e38c80, selection=..., smartDelete=false, mergeBlocksAfterDelete=true, replace=false, expandForSpecialElements=true, sanitizeMarkup=true) at ../../third_party/WebKit/Source/WebCore/editing/CompositeEditCommand.cpp:579 > #4 0x00007f7166192ca8 in WebCore::TypingCommand::deleteKeyPressed (this=0x7f7155e38c80, granularity=WebCore::CharacterGranularity, killRing=false) at > ... Okay, I think what we need to do is to call document()->updateLayoutIgnorePendingStylesheets() in isEditablePosition. >>> Source/WebCore/editing/CompositeEditCommand.cpp:344 >>> + ensureEditableCalculated(editingPosition); >> >> What's the point of adding this function? >> I'd just call document()->updateLayoutIgnorePendingStylesheets() here instead. > > I'd like to make the intention clear. See the follow up meta bug also https://bugs.webkit.org/show_bug.cgi?id=88968. > I am afraid we have to insert the similar code to other places. It might be better to name the function explicitly. I am okay to make that inline if needed. Once we move this call to inside isEditablePosition, the indention is very clear. 648713 12 hayato 2012-06-13 19:53:10 -0700 Thank you for the review. (In reply to comment #11) > Okay, I think what we need to do is to call document()->updateLayoutIgnorePendingStylesheets() in isEditablePosition. Yeah, that was what I thought at first, but I gave up that idea. The previous comment #5 and #6 might explained why I gave up. https://bugs.webkit.org/show_bug.cgi?id=88484#c5 https://bugs.webkit.org/show_bug.cgi?id=88484#c6 Another idea is to make ensureEditableCalculated(Position) returns bool (as a result of isEditablePosition) so that we don't have to call isEditablePosition(position) after that. Instead of: ensureEditableCalculated(position); ASSERT(isEditablePosition(position)); We can: bool editable = ensureEditableCalculated(position); ASSERT(editable); But I prefer the former to the latter. What do you think? > > >>> Source/WebCore/editing/CompositeEditCommand.cpp:344 > >>> + ensureEditableCalculated(editingPosition); > >> > >> What's the point of adding this function? > >> I'd just call document()->updateLayoutIgnorePendingStylesheets() here instead. > > > > I'd like to make the intention clear. See the follow up meta bug also https://bugs.webkit.org/show_bug.cgi?id=88968. > > I am afraid we have to insert the similar code to other places. It might be better to name the function explicitly. I am okay to make that inline if needed. > > Once we move this call to inside isEditablePosition, the indention is very clear. 648736 13 rniwa 2012-06-13 20:30:07 -0700 (In reply to comment #12) > Another idea is to make ensureEditableCalculated(Position) returns bool (as a result of isEditablePosition) so that we don't have to call isEditablePosition(position) after that. > > Instead of: > ensureEditableCalculated(position); > ASSERT(isEditablePosition(position)); > > We can: > bool editable = ensureEditableCalculated(position); > ASSERT(editable); > > But I prefer the former to the latter. What do you think? It sounds like we're just working-around the real bug here. We should be able to call updateLayout() in isEditablePosition. If not, then we need to fix that problem first. 648742 14 hayato 2012-06-13 20:43:57 -0700 (In reply to comment #13) > (In reply to comment #12) > > Another idea is to make ensureEditableCalculated(Position) returns bool (as a result of isEditablePosition) so that we don't have to call isEditablePosition(position) after that. > > > > Instead of: > > ensureEditableCalculated(position); > > ASSERT(isEditablePosition(position)); > > > > We can: > > bool editable = ensureEditableCalculated(position); > > ASSERT(editable); > > > > But I prefer the former to the latter. What do you think? > > It sounds like we're just working-around the real bug here. We should be able to call updateLayout() in isEditablePosition. If not, then we need to fix that problem first. As I explained in comment #5, we cannot easily call updateLayout() in isEditablePosion. That hit another assertion. Do you have any ideas to avoid assertion? 648745 15 rniwa 2012-06-13 20:46:39 -0700 (In reply to comment #14) > As I explained in comment #5, we cannot easily call updateLayout() in isEditablePosion. That hit another assertion. Do you have any ideas to avoid assertion? Then we'll need to fix that assertion first. 648748 16 hayato 2012-06-13 20:52:07 -0700 Okay. Let me re-think how to refactor isEditablePosition and its caller other than editing. My first rough idea is: - Make isEditablePosition() call updateLayoutXXX(). - Have new function, like isEditablePositionWithoutUpdatingStyle(tentative name :) ), and make some callers call this new function. isEditablePosition has already 2nd parameter which has default value. So I'd like to avoid adding third parameter to it. What do you think about it? (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > > > Another idea is to make ensureEditableCalculated(Position) returns bool (as a result of isEditablePosition) so that we don't have to call isEditablePosition(position) after that. > > > > > > Instead of: > > > ensureEditableCalculated(position); > > > ASSERT(isEditablePosition(position)); > > > > > > We can: > > > bool editable = ensureEditableCalculated(position); > > > ASSERT(editable); > > > > > > But I prefer the former to the latter. What do you think? > > > > It sounds like we're just working-around the real bug here. We should be able to call updateLayout() in isEditablePosition. If not, then we need to fix that problem first. > > As I explained in comment #5, we cannot easily call updateLayout() in isEditablePosion. That hit another assertion. Do you have any ideas to avoid assertion? 648752 17 rniwa 2012-06-13 20:55:13 -0700 (In reply to comment #16) > Okay. Let me re-think how to refactor isEditablePosition and its caller other than editing. > My first rough idea is: > - Make isEditablePosition() call updateLayoutXXX(). > - Have new function, like isEditablePositionWithoutUpdatingStyle(tentative name :) ), and make some callers call this new function. > > isEditablePosition has already 2nd parameter which has default value. So I'd like to avoid adding third parameter to it. What do you think about it? The thing is, calling rendererIsEditable() when the style is not up-to-date gives you a bogus result because editability depends on styles. 648757 18 hayato 2012-06-13 20:56:41 -0700 One more question. Do you think it is okay that we have isXXX function which has a side effect? I think it is not preferred in general, but it is allowed? I am afraid that someone will use ASSERT(isEditablePosition(position)) in the future carelessly. (In reply to comment #16) > Okay. Let me re-think how to refactor isEditablePosition and its caller other than editing. > My first rough idea is: > - Make isEditablePosition() call updateLayoutXXX(). > - Have new function, like isEditablePositionWithoutUpdatingStyle(tentative name :) ), and make some callers call this new function. > > isEditablePosition has already 2nd parameter which has default value. So I'd like to avoid adding third parameter to it. What do you think about it? > > (In reply to comment #14) > > (In reply to comment #13) > > > (In reply to comment #12) > > > > Another idea is to make ensureEditableCalculated(Position) returns bool (as a result of isEditablePosition) so that we don't have to call isEditablePosition(position) after that. > > > > > > > > Instead of: > > > > ensureEditableCalculated(position); > > > > ASSERT(isEditablePosition(position)); > > > > > > > > We can: > > > > bool editable = ensureEditableCalculated(position); > > > > ASSERT(editable); > > > > > > > > But I prefer the former to the latter. What do you think? > > > > > > It sounds like we're just working-around the real bug here. We should be able to call updateLayout() in isEditablePosition. If not, then we need to fix that problem first. > > > > As I explained in comment #5, we cannot easily call updateLayout() in isEditablePosion. That hit another assertion. Do you have any ideas to avoid assertion? 648758 19 rniwa 2012-06-13 20:58:02 -0700 (In reply to comment #18) > One more question. Do you think it is okay that we have isXXX function which has a side effect? > I think it is not preferred in general, but it is allowed? > I am afraid that someone will use ASSERT(isEditablePosition(position)) in the future carelessly. A lot of is~ functions has a side effect. e.g. isContentEditable() triggers a layout. 648771 20 hayato 2012-06-13 21:09:34 -0700 (In reply to comment #19) > (In reply to comment #18) > > One more question. Do you think it is okay that we have isXXX function which has a side effect? > > I think it is not preferred in general, but it is allowed? > > I am afraid that someone will use ASSERT(isEditablePosition(position)) in the future carelessly. > > A lot of is~ functions has a side effect. e.g. isContentEditable() triggers a layout. Okay. Thank you. Then nothing prevents us from calling updateLayout() in isEditablePosition. In fact, I tried to do it and add third parameter to isEditablePositon() once. Let me proceed in this way. 648783 21 hayato 2012-06-13 21:30:51 -0700 To avoid hitting assertion caused by paintCaret(), it seems we also have to modify FrameSelection::isContentEditable() and VisibleSelection::isContentEditable so that we can pass a enum to isEditablePosition(). STDERR: ASSERTION FAILED: !view() || (!view()->isInLayout() && !view()->isPainting()) STDERR: ../../third_party/WebKit/Source/WebCore/dom/Document.cpp(1858) : virtual void WebCore::Document::updateStyleIfNeeded() STDERR: [17052:17052:360193340672:ERROR:process_util_posix.cc(143)] Received signal 11 STDERR: base::debug::StackTrace::StackTrace() [0x7f50be3d3ade] STDERR: base::(anonymous namespace)::StackDumpSignalHandler() [0x7f50be42fa55] STDERR: 0x7f50b51b64c0 STDERR: WebCore::Document::updateStyleIfNeeded() [0x7f50b9573336] STDERR: WebCore::Document::updateLayout() [0x7f50b9573559] STDERR: WebCore::Document::updateLayoutIgnorePendingStylesheets() [0x7f50b957369b] STDERR: WebCore::isEditablePosition() [0x7f50b9feed46] STDERR: WebCore::VisibleSelection::isContentEditable() [0x7f50b9fed8f0] STDERR: WebCore::FrameSelection::isContentEditable() [0x7f50b8baa8ec] STDERR: WebCore::RenderBlock::paintCaret() [0x7f50b936083a] STDERR: WebCore::RenderBlock::paintObject() [0x7f50b9360f22] STDERR: WebCore::RenderView::paint() [0x7f50b95056b9] 648812 22 147486 hayato 2012-06-13 22:34:03 -0700 Created attachment 147486 call updatelayout in isEditablePosition 648813 23 147487 hayato 2012-06-13 22:35:54 -0700 Created attachment 147487 minor update of changelog 648819 24 hayato 2012-06-13 22:44:48 -0700 I've uploaded a new patch where we call updateLayout in isEditablePosition(). We should feel shame that we have a lot of isXX function which have side effects. But I guess its WebKit's way. 648840 25 147487 buildbot 2012-06-13 23:28:25 -0700 Comment on attachment 147487 minor update of changelog Attachment 147487 did not pass mac-ews (mac): Output: http://queues.webkit.org/results/12957215 648876 26 shinyak 2012-06-14 00:19:07 -0700 > We should feel shame that we have a lot of isXX function which have side effects. But I guess its WebKit's way. It's very error-prone... I think we should fix them whenever possible... 648924 27 147514 hayato 2012-06-14 01:13:29 -0700 Created attachment 147514 fix mac build 648976 28 rniwa 2012-06-14 02:20:38 -0700 (In reply to comment #24) > I've uploaded a new patch where we call updateLayout in isEditablePosition(). > > We should feel shame that we have a lot of isXX function which have side effects. But I guess its WebKit's way. Some functions ought to have side-effects. e.g. it's impossible to determine if something is editable without up-to-date style like it's impossible to determine the width of some element without up-to-date layout. And if we require callers to make things up-to-date, then we'll end up calling updateLayout() and other functions that require non-dirty style or layout such as rendererIsEditable() in pairs, which is strictly worse than having a function that does automatically updates them for you. The way I see, the bigger problem is the fact that VisiblePosition's constructor triggers layout. 649015 29 147514 rniwa 2012-06-14 02:53:37 -0700 Comment on attachment 147514 fix mac build View in context: https://bugs.webkit.org/attachment.cgi?id=147514&action=review > Source/WebCore/editing/FrameSelection.h:132 > - bool isContentEditable() const { return m_selection.isContentEditable(); } > + bool isContentEditable(EUpdateStyle updateStyle = UpdateStyle) const { return m_selection.isContentEditable(updateStyle); } A better approach will be to add rendererIsEditable() function since we already have Node::isContentEditable() and Node::rendererIsEditable(). > Source/WebCore/rendering/RenderBlock.cpp:2842 > + isContentEditable = frame()->selection()->isContentEditable(DoNotUpdateStyle); > } else { > caretPainter = frame()->page()->dragCaretController()->caretRenderer(); > isContentEditable = frame()->page()->dragCaretController()->isContentEditable(); We have the same problem with DragCaretController::isContentEditable. Yet another approach is to use caretPainter->node()->rendererIsEditable() that might be cleaner because then you can reduce the code paths. 649017 30 rniwa 2012-06-14 02:54:59 -0700 In the future, I highly recommend to cc darin and enrica on your bugs. They're both editing experts. 649836 31 hayato 2012-06-14 21:25:31 -0700 Thank you for the review. I'll upload a new patch soon. (In reply to comment #28) > (In reply to comment #24) > > I've uploaded a new patch where we call updateLayout in isEditablePosition(). > > > > We should feel shame that we have a lot of isXX function which have side effects. But I guess its WebKit's way. > > Some functions ought to have side-effects. e.g. it's impossible to determine if something is editable without up-to-date style like it's impossible to determine the width of some element without up-to-date layout. > > And if we require callers to make things up-to-date, then we'll end up calling updateLayout() and other functions that require non-dirty style or layout such as rendererIsEditable() in pairs, which is strictly worse than having a function that does automatically updates them for you. > > The way I see, the bigger problem is the fact that VisiblePosition's constructor triggers layout. Thank you for explanation. Yeah, most side-effects seem to be unavoidable. I think a side-effect issue might be worth discussing, but that is beyond this bug. Let's move forward. :) (In reply to comment #29) > (From update of attachment 147514 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=147514&action=review > > > Source/WebCore/editing/FrameSelection.h:132 > > - bool isContentEditable() const { return m_selection.isContentEditable(); } > > + bool isContentEditable(EUpdateStyle updateStyle = UpdateStyle) const { return m_selection.isContentEditable(updateStyle); } > > A better approach will be to add rendererIsEditable() function since we already have Node::isContentEditable() and Node::rendererIsEditable(). Okay. that sounds nice. Done. But I can not get rid of the third parameter of isEditablePosition still. Since there is some code that should be shared. > > > Source/WebCore/rendering/RenderBlock.cpp:2842 > > + isContentEditable = frame()->selection()->isContentEditable(DoNotUpdateStyle); > > } else { > > caretPainter = frame()->page()->dragCaretController()->caretRenderer(); > > isContentEditable = frame()->page()->dragCaretController()->isContentEditable(); > > We have the same problem with DragCaretController::isContentEditable. > Yet another approach is to use caretPainter->node()->rendererIsEditable() that might be cleaner because then you can reduce the code paths. Done. 649860 32 147728 hayato 2012-06-14 22:05:04 -0700 Created attachment 147728 add rendererIsEditable 650021 33 147728 rniwa 2012-06-15 01:58:23 -0700 Comment on attachment 147728 add rendererIsEditable View in context: https://bugs.webkit.org/attachment.cgi?id=147728&action=review > Source/WebCore/editing/htmlediting.cpp:150 > Node* node = p.deprecatedNode(); This should be p.containerNode(). We may consider fixing it while we're at. > Source/WebCore/editing/htmlediting.cpp:162 > + switch (updateStyle) { > + case UpdateStyle: > + node->document()->updateLayoutIgnorePendingStylesheets(); > + break; > + case DoNotUpdateStyle: > + break; > + default: > + ASSERT_NOT_REACHED(); > + break; > + } I wouldn't use a switch for this since we only have two values. if (updateStyle == UpdateStyle) node->document()->updateLayoutIgnorePendingStylesheets(); else ASSERT(updateStyle == DoNotUpdateStyle); is probably sufficient. > Source/WebCore/editing/htmlediting.h:158 > +enum EUpdateStyle { > + UpdateStyle, > + DoNotUpdateStyle, > +}; No need to place each value on its own line. You can just them all in one line. > Source/WebCore/rendering/RenderBlock.cpp:2842 > + isContentEditable = caretPainter ? caretPainter->node()->rendererIsEditable() : false; You can do that same for the line 2839. And then we wouldn't need FrameSelection::rendererIsEditable! > LayoutTests/editing/shadow/delete-characters-in-distributed-node-crash-expected.txt:3 > +PASS successfullyParsed is true > + > +TEST COMPLETE I wouldn't use js-test for this since you don't have any test cases. It's probably better to just spit out PASS by document.write or innerHTML. 650121 34 147728 hayato 2012-06-15 06:40:28 -0700 Comment on attachment 147728 add rendererIsEditable Thank you for the review. Let me address your comment later. Now I have one notice: View in context: https://bugs.webkit.org/attachment.cgi?id=147728&action=review >> Source/WebCore/rendering/RenderBlock.cpp:2842 >> + isContentEditable = caretPainter ? caretPainter->node()->rendererIsEditable() : false; > > You can do that same for the line 2839. And then we wouldn't need FrameSelection::rendererIsEditable! I've found that DragCaretContoller::isContentEditable has a different behavior semantically from it's render->node()->rendererIsEditable(). Also FrameSelection::isContentEditable() and frameselection->caretRenderer()->rendererIsEditable have different behavior semantically. So it seems we can not simply replace current code with renderer->node()->rendererIsEditable(). Let me think later further. 650127 35 147728 rniwa 2012-06-15 06:48:32 -0700 Comment on attachment 147728 add rendererIsEditable View in context: https://bugs.webkit.org/attachment.cgi?id=147728&action=review >>> Source/WebCore/rendering/RenderBlock.cpp:2842 >>> + isContentEditable = caretPainter ? caretPainter->node()->rendererIsEditable() : false; >> >> You can do that same for the line 2839. And then we wouldn't need FrameSelection::rendererIsEditable! > > I've found that DragCaretContoller::isContentEditable has a different behavior semantically from it's render->node()->rendererIsEditable(). > Also FrameSelection::isContentEditable() and frameselection->caretRenderer()->rendererIsEditable have different behavior semantically. > > So it seems we can not simply replace current code with renderer->node()->rendererIsEditable(). Let me think later further. Do some tests fail? By the way, you don't even need to use caretPainter->node()->rendererIsEditable(). Just node()->rendererIsEditable() is sufficient because we check that caretPainter is equal to "this" pointer in the line 2845. All we care about here is whether this block is editable or not. 653994 36 148676 hayato 2012-06-20 16:34:24 -0700 Created attachment 148676 update 654013 37 147728 hayato 2012-06-20 16:54:58 -0700 Comment on attachment 147728 add rendererIsEditable Thank you for the review. I've resumed on working on this bug. View in context: https://bugs.webkit.org/attachment.cgi?id=147728&action=review >> Source/WebCore/editing/htmlediting.cpp:162 >> + } > > I wouldn't use a switch for this since we only have two values. > if (updateStyle == UpdateStyle) > node->document()->updateLayoutIgnorePendingStylesheets(); > else > ASSERT(updateStyle == DoNotUpdateStyle); > is probably sufficient. Done. >> Source/WebCore/editing/htmlediting.h:158 >> +}; > > No need to place each value on its own line. You can just them all in one line. Done. >>>> Source/WebCore/rendering/RenderBlock.cpp:2842 >>>> + isContentEditable = caretPainter ? caretPainter->node()->rendererIsEditable() : false; >>> >>> You can do that same for the line 2839. And then we wouldn't need FrameSelection::rendererIsEditable! >> >> I've found that DragCaretContoller::isContentEditable has a different behavior semantically from it's render->node()->rendererIsEditable(). >> Also FrameSelection::isContentEditable() and frameselection->caretRenderer()->rendererIsEditable have different behavior semantically. >> >> So it seems we can not simply replace current code with renderer->node()->rendererIsEditable(). Let me think later further. > > Do some tests fail? By the way, you don't even need to use caretPainter->node()->rendererIsEditable(). Just node()->rendererIsEditable() is sufficient because we check that caretPainter is equal to "this" pointer in the line 2845. All we care about here is whether this block is editable or not. editing/pasteboard/copy-element-with-conflicting-background-color-from-rule.html will fail if we use caretPainter->node()->renderer() or node()->rendererIsEditable() here. It seems that there is a possibility that 'frame()->selection()->isContentEditable()' returns true, but caretPainter->node() (or this->node()) is null here. So I reverted the change of the previous patch. >> LayoutTests/editing/shadow/delete-characters-in-distributed-node-crash-expected.txt:3 >> +TEST COMPLETE > > I wouldn't use js-test for this since you don't have any test cases. > It's probably better to just spit out PASS by document.write or innerHTML. Done. 654021 38 rniwa 2012-06-20 17:07:36 -0700 (In reply to comment #37) > It seems that there is a possibility that 'frame()->selection()->isContentEditable()' returns true, but caretPainter->node() (or this->node()) is null here. So I reverted the change of the previous patch. Ah! We're probably at an anonymous renderer object. I think we can get the parent render object with non-null node() in that case. 654027 39 148676 rniwa 2012-06-20 17:10:46 -0700 Comment on attachment 148676 update Anyway the patch looks landable as is. 654060 40 hayato 2012-06-20 17:41:48 -0700 Thank you for the review. (In reply to comment #38) > (In reply to comment #37) > > It seems that there is a possibility that 'frame()->selection()->isContentEditable()' returns true, but caretPainter->node() (or this->node()) is null here. So I reverted the change of the previous patch. > > Ah! We're probably at an anonymous renderer object. I think we can get the parent render object with non-null node() in that case. Can we assume that such an anonymous renderer has always a parent renderer and the parent renderer has always a node? Maybe this should be done in another patch, but I am wondering whether the following is a right assumption or not. if (type == CursorCaret) { caretPainter = frame()->selection()->caretRenderer(); if (!caretPainter) isContentEditable = false; else if (caretPainter->node()) isContentEditable = caretPainter->node()->rendererIsEditable(); else { ASSERT(caretPainter->parent()); ASSERT(caretPainter->parent()->node()); isContentEditable = caretPainter->parent()->node()->rendererIsEditable(); } 654114 41 148676 webkit.review.bot 2012-06-20 18:34:29 -0700 Comment on attachment 148676 update Clearing flags on attachment: 148676 Committed r120896: <http://trac.webkit.org/changeset/120896> 654115 42 webkit.review.bot 2012-06-20 18:34:55 -0700 All reviewed patches have been landed. Closing bug. 660241 43 148676 rniwa 2012-06-29 00:44:42 -0700 Comment on attachment 148676 update View in context: https://bugs.webkit.org/attachment.cgi?id=148676&action=review > Source/WebCore/editing/VisibleSelection.h:31 > +#include "htmlediting.h" We shouldn't be adding this. Removed it in http://trac.webkit.org/changeset/121526. 146835 2012-06-11 05:20:59 -0700 2012-06-12 23:12:21 -0700 fix bug-88484-20120611212058.patch text/plain 2112 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTE5OTQ5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMjNjNzdmZjdhMWMwMmM5 YjY1MDhiNWQ2Y2Y1NGEyOTg2YjljZDc5ZC4uM2E5N2JlMzkzZGQyNmEyYjViOGE2ZDlkYjU5MjY1 NDI4NzMxZjAwNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDIwIEBACisyMDEyLTA2LTExICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQmVjYXVz ZSByZW1vdmluZyByZWR1bmRhbnQgYmxvY2tzIG1heSBpbnZhbGlkYXRlIHNoYWRvdyBob3N0J3MK KyAgICAgICAgbm9kZSBkaXN0cmlidXRpb24sIHdlIGhhdmUgdG8gbWFrZSBzdXJlIGFuY2hvck5v ZGUgb2YKKyAgICAgICAgZW5kaW5nUG9zaXRpb24gaXMgYXR0YWNoZWQuIE90aGVyd2lzZSwgdGhl IGZvbGxvd2luZyBpbnNlcnROb2RlKCkKKyAgICAgICAgaGl0cyBhbiBhc3NlcnRpb24gc2luY2Ug dGhlIGFuY2hvck5vZGUgZG9lcyBub3QgaGF2ZSBhIHJlbmRlcmVyKCkuCisKKyAgICAgICAgTm8g bmV3IHRlc3RzLiAoT09QUyEpCisKKyAgICAgICAgKiBlZGl0aW5nL0RlbGV0ZVNlbGVjdGlvbkNv bW1hbmQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RGVsZXRlU2VsZWN0aW9uQ29tbWFuZDo6ZG9B cHBseSk6CisKIDIwMTItMDYtMTAgIEhheWF0byBJdG8gIDxoYXlhdG9AY2hyb21pdW0ub3JnPgog CiAgICAgICAgIEFuIGluaGVyaXRhbmNlIG9mICctd2Via2l0LXVzZXItbW9kaWZ5JyBkb2VzIG5v dCBzdG9wIGF0IHNoYWRvdyBib3VuZGFyeS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29tbWFuZC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L0RlbGV0ZVNlbGVjdGlvbkNvbW1hbmQuY3BwCmluZGV4IGE1OWVkNjE4MmNkMjkyMGFiYTI0ZWJj Y2NkYWE4NzNkZTE2YjUwOWQuLjY0ZTk1NjgzNzI0YTk1MmEyOGFjY2Y5YWZlZWVjNmM5ZGM4OGUx YTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRGVsZXRlU2VsZWN0aW9uQ29t bWFuZC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9EZWxldGVTZWxlY3Rpb25Db21t YW5kLmNwcApAQCAtODE2LDggKzgxNiwxNSBAQCB2b2lkIERlbGV0ZVNlbGVjdGlvbkNvbW1hbmQ6 OmRvQXBwbHkoKQogICAgIFJlZlB0cjxOb2RlPiBwbGFjZWhvbGRlciA9IG1fbmVlZFBsYWNlaG9s ZGVyID8gY3JlYXRlQnJlYWtFbGVtZW50KGRvY3VtZW50KCkpLmdldCgpIDogMDsKICAgICAKICAg ICBpZiAocGxhY2Vob2xkZXIpIHsKLSAgICAgICAgaWYgKG1fc2FuaXRpemVNYXJrdXApCisgICAg ICAgIGlmIChtX3Nhbml0aXplTWFya3VwKSB7CiAgICAgICAgICAgICByZW1vdmVSZWR1bmRhbnRC bG9ja3MoKTsKKyAgICAgICAgICAgIC8vIE1ha2VzIHN1cmUgYW5jaG9yTm9kZSBpcyBhdHRhY2hl ZCBiZWNhdXNlIHJlbW92aW5nIHJlZHVuZGFudAorICAgICAgICAgICAgLy8gYmxvY2tzIG1heSBp bnZhbGlkYXRlIHNoYWRvdyBob3N0J3Mgbm9kZSBkaXN0cmlidXRpb24gYW5kIG1ha2UgYSBzaGFk b3cKKyAgICAgICAgICAgIC8vIGhvc3QgYmUgZGV0YWNoZWQuCisgICAgICAgICAgICBBU1NFUlQo bV9lbmRpbmdQb3NpdGlvbi5hbmNob3JOb2RlKCkpOworICAgICAgICAgICAgaWYgKCFtX2VuZGlu Z1Bvc2l0aW9uLmFuY2hvck5vZGUoKS0+YXR0YWNoZWQoKSkKKyAgICAgICAgICAgICAgICBtX2Vu ZGluZ1Bvc2l0aW9uLmFuY2hvck5vZGUoKS0+YXR0YWNoKCk7CisgICAgICAgIH0KICAgICAgICAg aW5zZXJ0Tm9kZUF0KHBsYWNlaG9sZGVyLmdldCgpLCBtX2VuZGluZ1Bvc2l0aW9uKTsKICAgICB9 CiAK 147242 2012-06-12 23:12:25 -0700 2012-06-13 22:33:58 -0700 ensure Editable is available bug-88484-20120613151224.patch text/plain 5990 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwMDM0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzkxODM4MzUxNTI3ZDMz MmU3Y2Q4MGNlOTlmZWU0YTEyMDlhYmU2Ny4uZmE3YzM4ODdmZGY1MWNkMmZmMDhjZWRiODNjMmIx ZGU3ZDA2OGYxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEyLTA2LTEzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgcmVt b3ZpbmcgcmVkdW5kYW50IGJsb2Nrcywgd2hpY2ggaXMgY2FsbGVkIGluIERlbGV0ZVNlbGVjdGlv bgorICAgICAgICBjb21tYW5kLCBtdXRhdGVzIGNoaWxkcmVuIG9mIGEgc2hhZG93IGhvc3QgZWxl bWVudCwgaXQgaW52YWxpZGF0ZXMKKyAgICAgICAgdGhlIG5vZGUgZGlzdHJpYnV0aW9uIG9mIHRo ZSBzaGFkb3cgaG9zdC4gIEFzIGEgcmVzdWx0LCB0aGUgc2hhZG93CisgICAgICAgIGhvc3Qgd2ls bCBiZSBkZXRhY2hlZCBhbmQgbG9zZSBpdHMgcmVuZGVyZXIuIFRoYXQgd2lsbCBoaXQKKyAgICAg ICAgaXNFZGl0YWJsZVBvc2l0aW9uKCkgYXNzZXJ0aW9uIGluIHRoZSBmb2xsb3dpbmcgaW5zZXJ0 Tm9kZUF0KCkKKyAgICAgICAgb3BlcmF0aW9uLiBTbyB3ZSBoYXZlIHRvIG1ha2Ugc3VyZSB0aGF0 IHN0eWxlIGlzIHVwZGF0ZWQgYmVmb3JlIGFza2luZworICAgICAgICBpc0VkaXRhYmxlUG9zaXRp b24oKS4KKworICAgICAgICBUaGVyZSBhcmUgb3RoZXIgcGxhY2VzIGluIGVkaXRpbmcgY29kZSB3 aGVyZSBpc0VkaXRhYmxlUG9zaXRpb24oKQorICAgICAgICBpcyBjYWxsZWQuIEZvbGxvdyB1cCBw YXRjaGVzIHdpbGwgZml4IHRoYXQuCisKKyAgICAgICAgVGVzdDogZWRpdGlvbi9zaGFkb3cvZGVs ZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS5odG1sCisKKyAgICAgICAgKiBlZGl0 aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNvbXBvc2l0 ZUVkaXRDb21tYW5kOjppbnNlcnROb2RlQXQpOgorICAgICAgICAoV2ViQ29yZTo6Q29tcG9zaXRl RWRpdENvbW1hbmQ6OmVuc3VyZUVkaXRhYmxlQ2FsY3VsYXRlZCk6CisgICAgICAgIChXZWJDb3Jl KToKKyAgICAgICAgKiBlZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmg6CisgICAgICAgIChD b21wb3NpdGVFZGl0Q29tbWFuZCk6CisKIDIwMTItMDYtMTEgIEppbiBZYW5nICA8amluLmEueWFu Z0BpbnRlbC5jb20+CiAKICAgICAgICAgR2VuZXJhdG9yR2VuZXJhdGVkSW1hZ2Ugc2hvdWxkIGNh Y2hlIGltYWdlcyBmb3IgdGhlIG5vbi10aWxlZCBjYXNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5kLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuY3BwCmluZGV4IDk5MmRiNTAyNmZiMDExMzMxYTE3 YWNiYzhkYjg2ZGVhMjUxMjFhMWYuLjc2NWJjYjMxMzI3NTk0YmViYmM5OTUwYjdiYzBjNWZhMmQ0 NjAzN2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENv bW1hbmQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1h bmQuY3BwCkBAIC0zNDEsNiArMzQxLDcgQEAgdm9pZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6aW5z ZXJ0Tm9kZUFmdGVyKFBhc3NSZWZQdHI8Tm9kZT4gaW5zZXJ0Q2hpbGQsIFBhc3NSZWYKIAogdm9p ZCBDb21wb3NpdGVFZGl0Q29tbWFuZDo6aW5zZXJ0Tm9kZUF0KFBhc3NSZWZQdHI8Tm9kZT4gaW5z ZXJ0Q2hpbGQsIGNvbnN0IFBvc2l0aW9uJiBlZGl0aW5nUG9zaXRpb24pCiB7CisgICAgZW5zdXJl RWRpdGFibGVDYWxjdWxhdGVkKGVkaXRpbmdQb3NpdGlvbik7CiAgICAgQVNTRVJUKGlzRWRpdGFi bGVQb3NpdGlvbihlZGl0aW5nUG9zaXRpb24pKTsKICAgICAvLyBGb3IgZWRpdGluZyBwb3NpdGlv bnMgbGlrZSBbdGFibGUsIDBdLCBpbnNlcnQgYmVmb3JlIHRoZSB0YWJsZSwKICAgICAvLyBsaWtl d2lzZSBmb3IgcmVwbGFjZWQgZWxlbWVudHMsIGJycywgZXRjLgpAQCAtMTQ2NCw2ICsxNDY1LDEy IEBAIFBhc3NSZWZQdHI8Tm9kZT4gQ29tcG9zaXRlRWRpdENvbW1hbmQ6OnNwbGl0VHJlZVRvTm9k ZShOb2RlKiBzdGFydCwgTm9kZSogZW5kLCBiCiAgICAgcmV0dXJuIG5vZGUucmVsZWFzZSgpOwog fQogCit2b2lkIENvbXBvc2l0ZUVkaXRDb21tYW5kOjplbnN1cmVFZGl0YWJsZUNhbGN1bGF0ZWQo Y29uc3QgUG9zaXRpb24mIHApCit7CisgICAgaWYgKE5vZGUqIG5vZGUgPSBwLmFuY2hvck5vZGUo KSkKKyAgICAgICAgbm9kZS0+ZG9jdW1lbnQoKS0+dXBkYXRlU3R5bGVJZk5lZWRlZCgpOworfQor CiBQYXNzUmVmUHRyPEVsZW1lbnQ+IGNyZWF0ZUJsb2NrUGxhY2Vob2xkZXJFbGVtZW50KERvY3Vt ZW50KiBkb2N1bWVudCkKIHsKICAgICBSZWZQdHI8RWxlbWVudD4gYnJlYWtOb2RlID0gZG9jdW1l bnQtPmNyZWF0ZUVsZW1lbnQoYnJUYWcsIGZhbHNlKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRp bmcvQ29tcG9zaXRlRWRpdENvbW1hbmQuaAppbmRleCA1MTlkYWJjNzExMjIyNzdlMTYxODRjMDli MjEyMDVjZmI3Y2NlMmY4Li45ZjZlNGIzZjQxZDI4ZDViM2FjNDFlODBiNzA5NWQ3YzBiMTBmNjM0 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0NvbXBvc2l0ZUVkaXRDb21tYW5k LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9Db21wb3NpdGVFZGl0Q29tbWFuZC5oCkBA IC0xNjcsNiArMTY3LDggQEAgcHJvdGVjdGVkOgogICAgIAogICAgIFBhc3NSZWZQdHI8Tm9kZT4g c3BsaXRUcmVlVG9Ob2RlKE5vZGUqLCBOb2RlKiwgYm9vbCBzcGxpdEFuY2VzdG9yID0gZmFsc2Up OwogCisgICAgc3RhdGljIHZvaWQgZW5zdXJlRWRpdGFibGVDYWxjdWxhdGVkKGNvbnN0IFBvc2l0 aW9uJik7CisKICAgICBWZWN0b3I8UmVmUHRyPEVkaXRDb21tYW5kPiA+IG1fY29tbWFuZHM7CiAK IHByaXZhdGU6CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKaW5kZXggMDk1OTY4NGZiNGJhMDgyMjkxOTUxMDAwZjUyZTFlYTRkMzZhMmIy My4uZDkzMmNkZDZkMDYzMTkzNzE3MDQ2ZDFmMDZjYTJmMTlmMjYzY2I3ZCAxMDA2NDQKLS0tIGEv TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwz ICsxLDEzIEBACisyMDEyLTA2LTEzICBIYXlhdG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4K KworICAgICAgICBbU2hhZG93XVtFZGl0aW5nXSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJp YnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFzaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODg0ODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkg KE9PUFMhKS4KKworICAgICAgICAqIGVkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWlu LWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2gtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBl ZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNo Lmh0bWw6IEFkZGVkLgorCiAyMDEyLTA2LTExICBEb21pbmljIENvb25leSAgPGRvbWluaWNjQGNo cm9taXVtLm9yZz4KIAogICAgICAgICBbQ2hyb21pdW1dIFVucmV2aWV3ZWQ6IFVwZGF0ZSB0ZXN0 IGV4cGVjdGF0aW9ucyB3aXRoIGJ1Z3MgZm9yIG1lZGlhIHRlc3QgdGltZW91dHMKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3Ry aWJ1dGVkLW5vZGUtY3Jhc2gtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFk b3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3RlZC50 eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMC4uZjQ2Y2YxMGI1N2UzYjZiODg4ZmEyYmJiODA5MDE0MWI1ZDlkY2VmOQot LS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFy YWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2gtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEs NyBAQAorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCitU aGlzIHRlc3RzIHRoZSBkZWxldGlvbiBvZiB0ZXh0IGluIGRpc3RyaWJ1dGVkIG5vZGUgZG9lcyBu b3QgY3Jhc2guIFRvIHJ1biBpdCBvdXRzaWRlIG9mIERSVCwgeW91IG11c3QgZGVsZXRlIHRleHQs ICdmb28nLCBtYW51YWxseS4KKworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcv c2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2guaHRtbCBi L0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1 dGVkLW5vZGUtY3Jhc2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mYjUwNDQwYWYzMTJjYzIzZmNmYmUyZTIw ZTY5NDkxNzI3NWIzMWE3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9z aGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC5odG1sCkBA IC0wLDAgKzEsMjIgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxzY3JpcHQg c3JjPSIuLi8uLi9mYXN0L2RvbS9yZXNvdXJjZXMvZXZlbnQtc2VuZGVyLXV0aWwuanMiPjwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpz Ij48L3NjcmlwdD4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+VGhpcyB0ZXN0cyB0aGUgZGVsZXRpb24g b2YgdGV4dCBpbiBkaXN0cmlidXRlZCBub2RlIGRvZXMgbm90IGNyYXNoLiBUbyBydW4gaXQgb3V0 c2lkZSBvZiBEUlQsIHlvdSBtdXN0IGRlbGV0ZSB0ZXh0LCAnZm9vJywgbWFudWFsbHkuPC9wPgor PGRpdiBpZD0ic2hhZG93aG9zdCIgY29udGVudGVkaXRhYmxlPjxkaXY+Zm9vPC9kaXY+PC9kaXY+ Cis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cit2YXIgc2hhZG93Um9vdCA9IG5ldyBXZWJLaXRT aGFkb3dSb290KGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzaGFkb3dob3N0JykpOworc2hhZG93 Um9vdC5pbm5lckhUTUwgPSAiPGNvbnRlbnQ+PC9jb250ZW50PiI7CisKK3ZhciB0ZXh0Tm9kZSA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzaGFkb3dob3N0JykuZmlyc3RDaGlsZC5maXJzdENo aWxkOword2luZG93LmdldFNlbGVjdGlvbigpLnNldEJhc2VBbmRFeHRlbnQodGV4dE5vZGUsIDAs IHRleHROb2RlLCAzKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCdEZWxldGUnKTsKKwordmFyIHN1 Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9m YXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9o dG1sPgo= 147486 2012-06-13 22:34:03 -0700 2012-06-13 22:35:49 -0700 call updatelayout in isEditablePosition bug-88484-20120614143402.patch text/plain 9820 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwMTYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWVmOWQ2NmJiMjA3ZmMw NTI3Y2I2NzQ3YzA1NWNjYTY5NTA3NGNiYi4uNGNiMWY1NjNhYjdhNDVmNWU2Y2M3ZTllMWQ3MDRj OTQwYjk0NGFjMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDEyLTA2LTEzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgd2Ug bXV0YXRlIG5vZGVzIHdoaWNoIGFyZSBjaGlsZHJlbiBvZiBhIHNoYWRvdyBob3N0LCBpdCBjYXVz ZXMKKyAgICAgICAgRWxlbWVudFNoYWRvdzo6aW52YWxpZGF0ZURpc3RyaWJ1dGlvbigpLiAgQXMg YSByZXN1bHQsIHNoYWRvdyBob3N0CisgICAgICAgIGlzIGRldGFjaGVkIChhbmQgbGF6eUF0dGFj aGVkKCkpIGFuZCBpdHMgcmVuZGVyZXIgaXMgZ29uZS4gIFRoYXQKKyAgICAgICAgY2F1c2VzIGFz c2VydGlvbiBlcnJvciBzaW5jZSBpc0VkaXRhYmxlUG9zaXRpb24oKSBhc3N1bWVzCisgICAgICAg IGFuY2hvck5vZGUncyBzdHlsZSB3YXMgY29ycmVjdGx5IGNhbGN1bGF0ZWQuCisKKyAgICAgICAg VGhpcyBwYXRjaCBtYWtlcyBpc0VkaXRhYmxlUG9zaXRpb24oKSBjYWxsCisgICAgICAgIGRvY3Vt ZW50LT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKSBzbyB0aGF0IGl0IGRv ZXMKKyAgICAgICAgbm90IHJldHVybiBhIGJvZ3VzIHJlc3VsdC4KKworICAgICAgICBUaGVyZSBp cyBhIGV4Y2VwdGlvbmFsIGNhbGxlciBvZiBpc0VkaXRhYmxlUG9zaXRpb24sCisgICAgICAgIFJl bmRlckJsb2NrOjpwYWludENhcmV0KCksIHdoZXJlIHdlIGNhbiBub3QgY2FsbCB1cGRhdGVMYXlv dXQoKSBpbgorICAgICAgICBpc0VkaXRhYmxlUG9zaXRpb24gYmVjYXVzZSBpdCBoaXRzIGFzc2Vy dGlvbiwKKyAgICAgICAgQVNTRVJUKCFpc1BhaW50aW5nKS4gU28gSSd2ZSBhZGRlZCB0aGUgdGhp cmQgcGFyYW1ldGVyIHRvCisgICAgICAgIGlzRWRpdGFibGVQb3NpdGlvbiB0byBjb250cm9sIHN0 eWxlIHVwZGF0ZS4KKworICAgICAgICBUZXN0OiBlZGl0aW9uL3NoYWRvdy9kZWxldGUtY2hhcmFj dGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLmh0bWwKKworICAgICAgICAqIGVkaXRpbmcvRnJhbWVT ZWxlY3Rpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lU2VsZWN0aW9uOjppc0NvbnRlbnRF ZGl0YWJsZSk6CisgICAgICAgICogZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OlZpc2libGVTZWxlY3Rpb246OmlzQ29udGVudEVkaXRhYmxlKToKKyAgICAg ICAgKiBlZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaDoKKyAgICAgICAgKFZpc2libGVTZWxlY3Rp b24pOgorICAgICAgICAqIGVkaXRpbmcvaHRtbGVkaXRpbmcuY3BwOgorICAgICAgICAoV2ViQ29y ZTo6aXNFZGl0YWJsZVBvc2l0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL2h0bWxlZGl0aW5nLmg6 CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxvY2suY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQmxvY2s6OnBhaW50Q2FyZXQpOgorCiAyMDEyLTA2 LTEyICBXZWkgSmFtZXMgIDxqYW1lcy53ZWlAaW50ZWwuY29tPgogCiAgICAgICAgIHdlYmNvcmUg c2hvdWxkIGRlcGVuZCBvbiB3ZWJjb3JlX2FybV9uZW9uIGZvciBvbmx5IGFybSB0YXJnZXRfYXJj aApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oIGIv U291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oCmluZGV4IDhmYzQyZWNjZTAz NjIwMmE3ZjAyODQwYTBlNWQxMzRkYzY1ZGZiMDguLmEwMmE2NWI0MTJjYmU1NTdlMzAzYjk3YjAz YzhmMGY0ZDlkYWQ4MWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVT ZWxlY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0aW9uLmgK QEAgLTEyOSw3ICsxMjksNyBAQCBwdWJsaWM6CiAKICAgICBFbGVtZW50KiByb290RWRpdGFibGVF bGVtZW50KCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24ucm9vdEVkaXRhYmxlRWxlbWVudCgp OyB9CiAgICAgRWxlbWVudCogcm9vdEVkaXRhYmxlRWxlbWVudE9yRG9jdW1lbnRFbGVtZW50KCkg Y29uc3Q7Ci0gICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2Vs ZWN0aW9uLmlzQ29udGVudEVkaXRhYmxlKCk7IH0KKyAgICBib29sIGlzQ29udGVudEVkaXRhYmxl KEVVcGRhdGVTdHlsZSB1cGRhdGVTdHlsZSA9IFVwZGF0ZVN0eWxlKSBjb25zdCB7IHJldHVybiBt X3NlbGVjdGlvbi5pc0NvbnRlbnRFZGl0YWJsZSh1cGRhdGVTdHlsZSk7IH0KICAgICBib29sIGlz Q29udGVudFJpY2hseUVkaXRhYmxlKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uaXNDb250 ZW50UmljaGx5RWRpdGFibGUoKTsgfQogICAgICAKICAgICB2b2lkIG1vdmVUbyhjb25zdCBSYW5n ZSosIEVBZmZpbml0eSwgRVVzZXJUcmlnZ2VyZWQgPSBOb3RVc2VyVHJpZ2dlcmVkKTsKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwCmluZGV4IDExYjkwMTU0MTJm MTFmODY4MGUwMzViYzk3Nzg2N2NjYWQyOGQ5MDIuLmUyNmZlNjY1NjJmMDQxZmFmMDVmMmQyOGJi NjFlNzJjZWU5ZjAwYTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJs ZVNlbGVjdGlvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0 aW9uLmNwcApAQCAtNjA5LDkgKzYwOSw5IEBAIHZvaWQgVmlzaWJsZVNlbGVjdGlvbjo6YWRqdXN0 U2VsZWN0aW9uVG9Bdm9pZENyb3NzaW5nRWRpdGluZ0JvdW5kYXJpZXMoKQogICAgICAgICBtX2V4 dGVudCA9IG1fYmFzZUlzRmlyc3QgPyBtX2VuZCA6IG1fc3RhcnQ7CiB9CiAKLWJvb2wgVmlzaWJs ZVNlbGVjdGlvbjo6aXNDb250ZW50RWRpdGFibGUoKSBjb25zdAorYm9vbCBWaXNpYmxlU2VsZWN0 aW9uOjppc0NvbnRlbnRFZGl0YWJsZShFVXBkYXRlU3R5bGUgdXBkYXRlU3R5bGUpIGNvbnN0CiB7 Ci0gICAgcmV0dXJuIGlzRWRpdGFibGVQb3NpdGlvbihzdGFydCgpKTsKKyAgICByZXR1cm4gaXNF ZGl0YWJsZVBvc2l0aW9uKHN0YXJ0KCksIENvbnRlbnRJc0VkaXRhYmxlLCB1cGRhdGVTdHlsZSk7 CiB9CiAKIGJvb2wgVmlzaWJsZVNlbGVjdGlvbjo6aXNDb250ZW50UmljaGx5RWRpdGFibGUoKSBj b25zdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9u LmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaAppbmRleCAyMTk5 OWJiM2NhZDRjMzQ1YTE5YWVjMzRkNjdlOWU1NGNiYmM2ZDIxLi5jMTg5NmYzYWVlN2Y0YjM5ZTY2 NjhkYTkwYzc4ZTUzMWRhY2U0OWQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5n L1Zpc2libGVTZWxlY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVT ZWxlY3Rpb24uaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiVGV4dEdyYW51bGFyaXR5 LmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCisjaW5jbHVkZSAiaHRtbGVkaXRpbmcu aCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC05OCw3ICs5OSw3IEBAIHB1YmxpYzoKICAg ICBQYXNzUmVmUHRyPFJhbmdlPiB0b05vcm1hbGl6ZWRSYW5nZSgpIGNvbnN0OwogICAgIAogICAg IEVsZW1lbnQqIHJvb3RFZGl0YWJsZUVsZW1lbnQoKSBjb25zdDsKLSAgICBib29sIGlzQ29udGVu dEVkaXRhYmxlKCkgY29uc3Q7CisgICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZShFVXBkYXRlU3R5 bGUgPSBVcGRhdGVTdHlsZSkgY29uc3Q7CiAgICAgYm9vbCBpc0NvbnRlbnRSaWNobHlFZGl0YWJs ZSgpIGNvbnN0OwogICAgIC8vIFJldHVybnMgYSBzaGFkb3cgdHJlZSBub2RlIGZvciBsZWdhY3kg c2hhZG93IHRyZWVzLCBhIGNoaWxkIG9mIHRoZQogICAgIC8vIFNoYWRvd1Jvb3Qgbm9kZSBmb3Ig bmV3IHNoYWRvdyB0cmVlcywgb3IgMCBmb3Igbm9uLXNoYWRvdyB0cmVlcy4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwIGIvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9odG1sZWRpdGluZy5jcHAKaW5kZXggZTE4MGNjYWJkMWIxNjAxZmI4ZDE3MDhkY2Jm MmRiYWNmNDgwZjQ2NS4uMWQ3MmRlYTdkNTdjN2E3MzcxMjYwMmJjM2VmMjc4MTk4ZjhjN2U2YSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5jcHAKQEAgLTE0NSwxMiArMTQ1LDIx IEBAIE5vZGUqIGxvd2VzdEVkaXRhYmxlQW5jZXN0b3IoTm9kZSogbm9kZSkKICAgICByZXR1cm4g bG93ZXN0Um9vdDsKIH0KIAotYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRpb24m IHAsIEVkaXRhYmxlVHlwZSBlZGl0YWJsZVR5cGUpCitib29sIGlzRWRpdGFibGVQb3NpdGlvbihj b25zdCBQb3NpdGlvbiYgcCwgRWRpdGFibGVUeXBlIGVkaXRhYmxlVHlwZSwgRVVwZGF0ZVN0eWxl IHVwZGF0ZVN0eWxlKQogewogICAgIE5vZGUqIG5vZGUgPSBwLmRlcHJlY2F0ZWROb2RlKCk7CiAg ICAgaWYgKCFub2RlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgIAorICAgIHN3aXRj aCAodXBkYXRlU3R5bGUpIHsKKyAgICBjYXNlIFVwZGF0ZVN0eWxlOgorICAgICAgICBub2RlLT5k b2N1bWVudCgpLT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKTsKKyAgICAg ICAgYnJlYWs7CisgICAgY2FzZSBEb05vdFVwZGF0ZVN0eWxlOgorICAgICAgICBicmVhazsKKyAg ICBkZWZhdWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgYnJlYWs7 CisgICAgfQogICAgIGlmIChub2RlLT5yZW5kZXJlcigpICYmIG5vZGUtPnJlbmRlcmVyKCktPmlz VGFibGUoKSkKICAgICAgICAgbm9kZSA9IG5vZGUtPnBhcmVudE5vZGUoKTsKICAgICAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuaCBiL1NvdXJjZS9XZWJD b3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuaAppbmRleCBhODE5YzQ5MmNiMDZlZjhhYzg5ZWM4YjNm MzE4NjA4ZTliMGUyMmVkLi5hZWEwMjMxZWIxYzc5ZDk1YTc3MThmOWRkYzVmNGFkNGYxYmM0N2Rl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmgKKysrIGIv U291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5oCkBAIC0xNTEsOCArMTUxLDEyIEBA IGlubGluZSBQb3NpdGlvbiBsYXN0UG9zaXRpb25Jbk9yQWZ0ZXJOb2RlKE5vZGUqIG5vZGUpCiBp bnQgY29tcGFyZVBvc2l0aW9ucyhjb25zdCBQb3NpdGlvbiYsIGNvbnN0IFBvc2l0aW9uJik7CiAK IC8vIGJvb2xlYW4gZnVuY3Rpb25zIG9uIFBvc2l0aW9uCi0gICAgCi1ib29sIGlzRWRpdGFibGVQ b3NpdGlvbihjb25zdCBQb3NpdGlvbiYsIEVkaXRhYmxlVHlwZSA9IENvbnRlbnRJc0VkaXRhYmxl KTsKKworZW51bSBFVXBkYXRlU3R5bGUgeworICAgIFVwZGF0ZVN0eWxlLAorICAgIERvTm90VXBk YXRlU3R5bGUsCit9OworYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRpb24mLCBF ZGl0YWJsZVR5cGUgPSBDb250ZW50SXNFZGl0YWJsZSwgRVVwZGF0ZVN0eWxlID0gVXBkYXRlU3R5 bGUpOwogYm9vbCBpc1JpY2hseUVkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRpb24mLCBFZGl0 YWJsZVR5cGUgPSBDb250ZW50SXNFZGl0YWJsZSk7CiBib29sIGlzRmlyc3RWaXNpYmxlUG9zaXRp b25JblNwZWNpYWxFbGVtZW50KGNvbnN0IFBvc2l0aW9uJik7CiBib29sIGlzTGFzdFZpc2libGVQ b3NpdGlvbkluU3BlY2lhbEVsZW1lbnQoY29uc3QgUG9zaXRpb24mKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCmluZGV4IDFlYTkwYzc0ZGZkMjA4YmY2NDM5OGE0N2M5 Zjk5Y2IxNjQ1NjliNGQuLjNjN2U4NjUxOWRiZjUxYmQyN2JmMjZlMmU5MjZlOWI0MTRkOGNiOTAg MTAwNzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtMjgzNiw3ICsy ODM2LDcgQEAgdm9pZCBSZW5kZXJCbG9jazo6cGFpbnRDYXJldChQYWludEluZm8mIHBhaW50SW5m bywgY29uc3QgTGF5b3V0UG9pbnQmIHBhaW50T2Zmc2UKICAgICBib29sIGlzQ29udGVudEVkaXRh YmxlOwogICAgIGlmICh0eXBlID09IEN1cnNvckNhcmV0KSB7CiAgICAgICAgIGNhcmV0UGFpbnRl ciA9IGZyYW1lKCktPnNlbGVjdGlvbigpLT5jYXJldFJlbmRlcmVyKCk7Ci0gICAgICAgIGlzQ29u dGVudEVkaXRhYmxlID0gZnJhbWUoKS0+c2VsZWN0aW9uKCktPmlzQ29udGVudEVkaXRhYmxlKCk7 CisgICAgICAgIGlzQ29udGVudEVkaXRhYmxlID0gZnJhbWUoKS0+c2VsZWN0aW9uKCktPmlzQ29u dGVudEVkaXRhYmxlKERvTm90VXBkYXRlU3R5bGUpOwogICAgIH0gZWxzZSB7CiAgICAgICAgIGNh cmV0UGFpbnRlciA9IGZyYW1lKCktPnBhZ2UoKS0+ZHJhZ0NhcmV0Q29udHJvbGxlcigpLT5jYXJl dFJlbmRlcmVyKCk7CiAgICAgICAgIGlzQ29udGVudEVkaXRhYmxlID0gZnJhbWUoKS0+cGFnZSgp LT5kcmFnQ2FyZXRDb250cm9sbGVyKCktPmlzQ29udGVudEVkaXRhYmxlKCk7CmRpZmYgLS1naXQg YS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggMWUx Mjc4ZGIxNGQ1NzdlMjAyMmYwM2E3MTc4ZmQ2MTc3NTAwN2U5Ni4uOGIxMjdkYWI5NTM2NzVlNDM2 OWNiODhiZjAzNmJlMzlmZmUzNDhhZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9n CisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDEyLTA2LTEz ICBIYXlhdG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtF ZGl0aW5nXSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQg YSBjcmFzaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 ODg0ODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAq IGVkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jh c2gtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NoYWRvdy9kZWxldGUt Y2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLmh0bWw6IEFkZGVkLgorCiAyMDEy LTA2LTEyICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdlYmtpdC5vcmc+CiAKICAgICAgICAg W1F0XSBVbnJldmlld2VkIG1vcm5pbmcgZ2FyZGVuaW5nLCBza2lwIG5ldyBmYWlsaW5nIHRlc3Rz LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3Rl cnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9l ZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNo LWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mNDZjZjEwYjU3ZTNiNmI4ODhmYTJiYmI4MDkwMTQx YjVkOWRjZWY5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cv ZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3RlZC50eHQK QEAgLTAsMCArMSw3IEBACitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisKK1RFU1Qg Q09NUExFVEUKK1RoaXMgdGVzdHMgdGhlIGRlbGV0aW9uIG9mIHRleHQgaW4gZGlzdHJpYnV0ZWQg bm9kZSBkb2VzIG5vdCBjcmFzaC4gVG8gcnVuIGl0IG91dHNpZGUgb2YgRFJULCB5b3UgbXVzdCBk ZWxldGUgdGV4dCwgJ2ZvbycsIG1hbnVhbGx5LgorCisKKwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVz dHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1j cmFzaC5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMt aW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4 IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiNTA0NDBhZjMxMmNj MjNmY2ZiZTJlMjBlNjk0OTE3Mjc1YjMxYTcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNy YXNoLmh0bWwKQEAgLTAsMCArMSwyMiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4KKzxib2R5 PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvZG9tL3Jlc291cmNlcy9ldmVudC1zZW5kZXItdXRp bC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMt dGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj5UaGlzIHRlc3RzIHRo ZSBkZWxldGlvbiBvZiB0ZXh0IGluIGRpc3RyaWJ1dGVkIG5vZGUgZG9lcyBub3QgY3Jhc2guIFRv IHJ1biBpdCBvdXRzaWRlIG9mIERSVCwgeW91IG11c3QgZGVsZXRlIHRleHQsICdmb28nLCBtYW51 YWxseS48L3A+Cis8ZGl2IGlkPSJzaGFkb3dob3N0IiBjb250ZW50ZWRpdGFibGU+PGRpdj5mb288 L2Rpdj48L2Rpdj4KKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9sbGVyKQor ICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK3ZhciBzaGFkb3dSb290ID0g bmV3IFdlYktpdFNoYWRvd1Jvb3QoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3NoYWRvd2hvc3Qn KSk7CitzaGFkb3dSb290LmlubmVySFRNTCA9ICI8Y29udGVudD48L2NvbnRlbnQ+IjsKKwordmFy IHRleHROb2RlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3NoYWRvd2hvc3QnKS5maXJzdENo aWxkLmZpcnN0Q2hpbGQ7Cit3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0QmFzZUFuZEV4dGVudCh0 ZXh0Tm9kZSwgMCwgdGV4dE5vZGUsIDMpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ0RlbGV0ZScp OworCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNjcmlwdCBz cmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+Cis8 L2JvZHk+Cis8L2h0bWw+Cg== 147487 2012-06-13 22:35:54 -0700 2012-06-14 01:13:23 -0700 minor update of changelog bug-88484-20120614143553.patch text/plain 9826 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwMTYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWVmOWQ2NmJiMjA3ZmMw NTI3Y2I2NzQ3YzA1NWNjYTY5NTA3NGNiYi4uYTg5MDAyYzQzODEyOTQxNzJlZDA1ZmUzOGY2ZmUz MGU2OTQ0OWM5OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDEyLTA2LTEzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgd2Ug bXV0YXRlIG5vZGVzIHdoaWNoIGFyZSBjaGlsZHJlbiBvZiBhIHNoYWRvdyBob3N0LCBpdCBjYXVz ZXMKKyAgICAgICAgRWxlbWVudFNoYWRvdzo6aW52YWxpZGF0ZURpc3RyaWJ1dGlvbigpLiAgQXMg YSByZXN1bHQsIHNoYWRvdyBob3N0CisgICAgICAgIGlzIGRldGFjaGVkIChhbmQgbGF6eUF0dGFj aGVkKCkpIGFuZCBpdHMgcmVuZGVyZXIgaXMgZ29uZS4gIFRoYXQKKyAgICAgICAgY2F1c2VzIGFz c2VydGlvbiBlcnJvciBzaW5jZSBpc0VkaXRhYmxlUG9zaXRpb24oKSBhc3N1bWVzCisgICAgICAg IGFuY2hvck5vZGUncyBzdHlsZSB3YXMgY29ycmVjdGx5IGNhbGN1bGF0ZWQuCisKKyAgICAgICAg VGhpcyBwYXRjaCBtYWtlcyBpc0VkaXRhYmxlUG9zaXRpb24oKSBjYWxsCisgICAgICAgIGRvY3Vt ZW50LT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKSBzbyB0aGF0IGl0IGRv ZXMKKyAgICAgICAgbm90IHJldHVybiBhIGJvZ3VzIHJlc3VsdC4KKworICAgICAgICBUaGVyZSBp cyBhbiBleGNlcHRpb25hbCBjYWxsZXIgb2YgaXNFZGl0YWJsZVBvc2l0aW9uLAorICAgICAgICBS ZW5kZXJCbG9jazo6cGFpbnRDYXJldCgpLCBmcm9tIHdoZXJlIHdlIGNhbiBub3QgY2FsbAorICAg ICAgICB1cGRhdGVMYXlvdXQoKSBpbiBpc0VkaXRhYmxlUG9zaXRpb24gYmVjYXVzZSBpdCBoaXRz IGFzc2VydGlvbiwKKyAgICAgICAgQVNTRVJUKCFpc1BhaW50aW5nKS4gU28gSSd2ZSBhZGRlZCB0 aGUgdGhpcmQgcGFyYW1ldGVyIHRvCisgICAgICAgIGlzRWRpdGFibGVQb3NpdGlvbiB0byBjb250 cm9sIHN0eWxlIHVwZGF0ZS4KKworICAgICAgICBUZXN0OiBlZGl0aW9uL3NoYWRvdy9kZWxldGUt Y2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLmh0bWwKKworICAgICAgICAqIGVkaXRpbmcv RnJhbWVTZWxlY3Rpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lU2VsZWN0aW9uOjppc0Nv bnRlbnRFZGl0YWJsZSk6CisgICAgICAgICogZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlZpc2libGVTZWxlY3Rpb246OmlzQ29udGVudEVkaXRhYmxlKToK KyAgICAgICAgKiBlZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaDoKKyAgICAgICAgKFZpc2libGVT ZWxlY3Rpb24pOgorICAgICAgICAqIGVkaXRpbmcvaHRtbGVkaXRpbmcuY3BwOgorICAgICAgICAo V2ViQ29yZTo6aXNFZGl0YWJsZVBvc2l0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL2h0bWxlZGl0 aW5nLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxv Y2suY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQmxvY2s6OnBhaW50Q2FyZXQpOgorCiAy MDEyLTA2LTEyICBXZWkgSmFtZXMgIDxqYW1lcy53ZWlAaW50ZWwuY29tPgogCiAgICAgICAgIHdl YmNvcmUgc2hvdWxkIGRlcGVuZCBvbiB3ZWJjb3JlX2FybV9uZW9uIGZvciBvbmx5IGFybSB0YXJn ZXRfYXJjaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlv bi5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oCmluZGV4IDhmYzQy ZWNjZTAzNjIwMmE3ZjAyODQwYTBlNWQxMzRkYzY1ZGZiMDguLmEwMmE2NWI0MTJjYmU1NTdlMzAz Yjk3YjAzYzhmMGY0ZDlkYWQ4MWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv RnJhbWVTZWxlY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0 aW9uLmgKQEAgLTEyOSw3ICsxMjksNyBAQCBwdWJsaWM6CiAKICAgICBFbGVtZW50KiByb290RWRp dGFibGVFbGVtZW50KCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24ucm9vdEVkaXRhYmxlRWxl bWVudCgpOyB9CiAgICAgRWxlbWVudCogcm9vdEVkaXRhYmxlRWxlbWVudE9yRG9jdW1lbnRFbGVt ZW50KCkgY29uc3Q7Ci0gICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZSgpIGNvbnN0IHsgcmV0dXJu IG1fc2VsZWN0aW9uLmlzQ29udGVudEVkaXRhYmxlKCk7IH0KKyAgICBib29sIGlzQ29udGVudEVk aXRhYmxlKEVVcGRhdGVTdHlsZSB1cGRhdGVTdHlsZSA9IFVwZGF0ZVN0eWxlKSBjb25zdCB7IHJl dHVybiBtX3NlbGVjdGlvbi5pc0NvbnRlbnRFZGl0YWJsZSh1cGRhdGVTdHlsZSk7IH0KICAgICBi b29sIGlzQ29udGVudFJpY2hseUVkaXRhYmxlKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24u aXNDb250ZW50UmljaGx5RWRpdGFibGUoKTsgfQogICAgICAKICAgICB2b2lkIG1vdmVUbyhjb25z dCBSYW5nZSosIEVBZmZpbml0eSwgRVVzZXJUcmlnZ2VyZWQgPSBOb3RVc2VyVHJpZ2dlcmVkKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwCmluZGV4IDExYjkw MTU0MTJmMTFmODY4MGUwMzViYzk3Nzg2N2NjYWQyOGQ5MDIuLmUyNmZlNjY1NjJmMDQxZmFmMDVm MmQyOGJiNjFlNzJjZWU5ZjAwYTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv VmlzaWJsZVNlbGVjdGlvbi5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxl U2VsZWN0aW9uLmNwcApAQCAtNjA5LDkgKzYwOSw5IEBAIHZvaWQgVmlzaWJsZVNlbGVjdGlvbjo6 YWRqdXN0U2VsZWN0aW9uVG9Bdm9pZENyb3NzaW5nRWRpdGluZ0JvdW5kYXJpZXMoKQogICAgICAg ICBtX2V4dGVudCA9IG1fYmFzZUlzRmlyc3QgPyBtX2VuZCA6IG1fc3RhcnQ7CiB9CiAKLWJvb2wg VmlzaWJsZVNlbGVjdGlvbjo6aXNDb250ZW50RWRpdGFibGUoKSBjb25zdAorYm9vbCBWaXNpYmxl U2VsZWN0aW9uOjppc0NvbnRlbnRFZGl0YWJsZShFVXBkYXRlU3R5bGUgdXBkYXRlU3R5bGUpIGNv bnN0CiB7Ci0gICAgcmV0dXJuIGlzRWRpdGFibGVQb3NpdGlvbihzdGFydCgpKTsKKyAgICByZXR1 cm4gaXNFZGl0YWJsZVBvc2l0aW9uKHN0YXJ0KCksIENvbnRlbnRJc0VkaXRhYmxlLCB1cGRhdGVT dHlsZSk7CiB9CiAKIGJvb2wgVmlzaWJsZVNlbGVjdGlvbjo6aXNDb250ZW50UmljaGx5RWRpdGFi bGUoKSBjb25zdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2Vs ZWN0aW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaAppbmRl eCAyMTk5OWJiM2NhZDRjMzQ1YTE5YWVjMzRkNjdlOWU1NGNiYmM2ZDIxLi5jMTg5NmYzYWVlN2Y0 YjM5ZTY2NjhkYTkwYzc4ZTUzMWRhY2U0OWQ5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zp c2libGVTZWxlY3Rpb24uaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiVGV4dEdyYW51 bGFyaXR5LmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCisjaW5jbHVkZSAiaHRtbGVk aXRpbmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC05OCw3ICs5OSw3IEBAIHB1Ymxp YzoKICAgICBQYXNzUmVmUHRyPFJhbmdlPiB0b05vcm1hbGl6ZWRSYW5nZSgpIGNvbnN0OwogICAg IAogICAgIEVsZW1lbnQqIHJvb3RFZGl0YWJsZUVsZW1lbnQoKSBjb25zdDsKLSAgICBib29sIGlz Q29udGVudEVkaXRhYmxlKCkgY29uc3Q7CisgICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZShFVXBk YXRlU3R5bGUgPSBVcGRhdGVTdHlsZSkgY29uc3Q7CiAgICAgYm9vbCBpc0NvbnRlbnRSaWNobHlF ZGl0YWJsZSgpIGNvbnN0OwogICAgIC8vIFJldHVybnMgYSBzaGFkb3cgdHJlZSBub2RlIGZvciBs ZWdhY3kgc2hhZG93IHRyZWVzLCBhIGNoaWxkIG9mIHRoZQogICAgIC8vIFNoYWRvd1Jvb3Qgbm9k ZSBmb3IgbmV3IHNoYWRvdyB0cmVlcywgb3IgMCBmb3Igbm9uLXNoYWRvdyB0cmVlcy4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5jcHAKaW5kZXggZTE4MGNjYWJkMWIxNjAxZmI4ZDE3 MDhkY2JmMmRiYWNmNDgwZjQ2NS4uMWQ3MmRlYTdkNTdjN2E3MzcxMjYwMmJjM2VmMjc4MTk4Zjhj N2U2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5jcHAKQEAgLTE0NSwxMiAr MTQ1LDIxIEBAIE5vZGUqIGxvd2VzdEVkaXRhYmxlQW5jZXN0b3IoTm9kZSogbm9kZSkKICAgICBy ZXR1cm4gbG93ZXN0Um9vdDsKIH0KIAotYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9z aXRpb24mIHAsIEVkaXRhYmxlVHlwZSBlZGl0YWJsZVR5cGUpCitib29sIGlzRWRpdGFibGVQb3Np dGlvbihjb25zdCBQb3NpdGlvbiYgcCwgRWRpdGFibGVUeXBlIGVkaXRhYmxlVHlwZSwgRVVwZGF0 ZVN0eWxlIHVwZGF0ZVN0eWxlKQogewogICAgIE5vZGUqIG5vZGUgPSBwLmRlcHJlY2F0ZWROb2Rl KCk7CiAgICAgaWYgKCFub2RlKQogICAgICAgICByZXR1cm4gZmFsc2U7Ci0gICAgICAgIAorICAg IHN3aXRjaCAodXBkYXRlU3R5bGUpIHsKKyAgICBjYXNlIFVwZGF0ZVN0eWxlOgorICAgICAgICBu b2RlLT5kb2N1bWVudCgpLT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKTsK KyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBEb05vdFVwZGF0ZVN0eWxlOgorICAgICAgICBicmVh azsKKyAgICBkZWZhdWx0OgorICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAg YnJlYWs7CisgICAgfQogICAgIGlmIChub2RlLT5yZW5kZXJlcigpICYmIG5vZGUtPnJlbmRlcmVy KCktPmlzVGFibGUoKSkKICAgICAgICAgbm9kZSA9IG5vZGUtPnBhcmVudE5vZGUoKTsKICAgICAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuaCBiL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuaAppbmRleCBhODE5YzQ5MmNiMDZlZjhhYzg5 ZWM4YjNmMzE4NjA4ZTliMGUyMmVkLi5hZWEwMjMxZWIxYzc5ZDk1YTc3MThmOWRkYzVmNGFkNGYx YmM0N2RlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmgK KysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5oCkBAIC0xNTEsOCArMTUx LDEyIEBAIGlubGluZSBQb3NpdGlvbiBsYXN0UG9zaXRpb25Jbk9yQWZ0ZXJOb2RlKE5vZGUqIG5v ZGUpCiBpbnQgY29tcGFyZVBvc2l0aW9ucyhjb25zdCBQb3NpdGlvbiYsIGNvbnN0IFBvc2l0aW9u Jik7CiAKIC8vIGJvb2xlYW4gZnVuY3Rpb25zIG9uIFBvc2l0aW9uCi0gICAgCi1ib29sIGlzRWRp dGFibGVQb3NpdGlvbihjb25zdCBQb3NpdGlvbiYsIEVkaXRhYmxlVHlwZSA9IENvbnRlbnRJc0Vk aXRhYmxlKTsKKworZW51bSBFVXBkYXRlU3R5bGUgeworICAgIFVwZGF0ZVN0eWxlLAorICAgIERv Tm90VXBkYXRlU3R5bGUsCit9OworYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRp b24mLCBFZGl0YWJsZVR5cGUgPSBDb250ZW50SXNFZGl0YWJsZSwgRVVwZGF0ZVN0eWxlID0gVXBk YXRlU3R5bGUpOwogYm9vbCBpc1JpY2hseUVkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRpb24m LCBFZGl0YWJsZVR5cGUgPSBDb250ZW50SXNFZGl0YWJsZSk7CiBib29sIGlzRmlyc3RWaXNpYmxl UG9zaXRpb25JblNwZWNpYWxFbGVtZW50KGNvbnN0IFBvc2l0aW9uJik7CiBib29sIGlzTGFzdFZp c2libGVQb3NpdGlvbkluU3BlY2lhbEVsZW1lbnQoY29uc3QgUG9zaXRpb24mKTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCmluZGV4IDFlYTkwYzc0ZGZkMjA4YmY2NDM5 OGE0N2M5Zjk5Y2IxNjQ1NjliNGQuLjNjN2U4NjUxOWRiZjUxYmQyN2JmMjZlMmU5MjZlOWI0MTRk OGNiOTAgMTAwNzU1Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5j cHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcApAQCAtMjgz Niw3ICsyODM2LDcgQEAgdm9pZCBSZW5kZXJCbG9jazo6cGFpbnRDYXJldChQYWludEluZm8mIHBh aW50SW5mbywgY29uc3QgTGF5b3V0UG9pbnQmIHBhaW50T2Zmc2UKICAgICBib29sIGlzQ29udGVu dEVkaXRhYmxlOwogICAgIGlmICh0eXBlID09IEN1cnNvckNhcmV0KSB7CiAgICAgICAgIGNhcmV0 UGFpbnRlciA9IGZyYW1lKCktPnNlbGVjdGlvbigpLT5jYXJldFJlbmRlcmVyKCk7Ci0gICAgICAg IGlzQ29udGVudEVkaXRhYmxlID0gZnJhbWUoKS0+c2VsZWN0aW9uKCktPmlzQ29udGVudEVkaXRh YmxlKCk7CisgICAgICAgIGlzQ29udGVudEVkaXRhYmxlID0gZnJhbWUoKS0+c2VsZWN0aW9uKCkt PmlzQ29udGVudEVkaXRhYmxlKERvTm90VXBkYXRlU3R5bGUpOwogICAgIH0gZWxzZSB7CiAgICAg ICAgIGNhcmV0UGFpbnRlciA9IGZyYW1lKCktPnBhZ2UoKS0+ZHJhZ0NhcmV0Q29udHJvbGxlcigp LT5jYXJldFJlbmRlcmVyKCk7CiAgICAgICAgIGlzQ29udGVudEVkaXRhYmxlID0gZnJhbWUoKS0+ cGFnZSgpLT5kcmFnQ2FyZXRDb250cm9sbGVyKCktPmlzQ29udGVudEVkaXRhYmxlKCk7CmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5k ZXggMWUxMjc4ZGIxNGQ1NzdlMjAyMmYwM2E3MTc4ZmQ2MTc3NTAwN2U5Ni4uOGIxMjdkYWI5NTM2 NzVlNDM2OWNiODhiZjAzNmJlMzlmZmUzNDhhZCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDEy LTA2LTEzICBIYXlhdG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hh ZG93XVtFZGl0aW5nXSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBj YXVzZWQgYSBjcmFzaAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9ODg0ODQKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICAqIGVkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5v ZGUtY3Jhc2gtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiBlZGl0aW5nL3NoYWRvdy9k ZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLmh0bWw6IEFkZGVkLgor CiAyMDEyLTA2LTEyICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdlYmtpdC5vcmc+CiAKICAg ICAgICAgW1F0XSBVbnJldmlld2VkIG1vcm5pbmcgZ2FyZGVuaW5nLCBza2lwIG5ldyBmYWlsaW5n IHRlc3RzLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNo YXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3RlZC50eHQgYi9MYXlvdXRU ZXN0cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2Rl LWNyYXNoLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mNDZjZjEwYjU3ZTNiNmI4ODhmYTJiYmI4 MDkwMTQxYjVkOWRjZWY5Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9z aGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3Rl ZC50eHQKQEAgLTAsMCArMSw3IEBACitQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCisK K1RFU1QgQ09NUExFVEUKK1RoaXMgdGVzdHMgdGhlIGRlbGV0aW9uIG9mIHRleHQgaW4gZGlzdHJp YnV0ZWQgbm9kZSBkb2VzIG5vdCBjcmFzaC4gVG8gcnVuIGl0IG91dHNpZGUgb2YgRFJULCB5b3Ug bXVzdCBkZWxldGUgdGV4dCwgJ2ZvbycsIG1hbnVhbGx5LgorCisKKwpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQt bm9kZS1jcmFzaC5odG1sIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJh Y3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmZiNTA0NDBh ZjMxMmNjMjNmY2ZiZTJlMjBlNjk0OTE3Mjc1YjMxYTcKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlv dXRUZXN0cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1u b2RlLWNyYXNoLmh0bWwKQEAgLTAsMCArMSwyMiBAQAorPCFET0NUWVBFIGh0bWw+Cis8aHRtbD4K Kzxib2R5PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvZG9tL3Jlc291cmNlcy9ldmVudC1zZW5k ZXItdXRpbC5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj5UaGlzIHRl c3RzIHRoZSBkZWxldGlvbiBvZiB0ZXh0IGluIGRpc3RyaWJ1dGVkIG5vZGUgZG9lcyBub3QgY3Jh c2guIFRvIHJ1biBpdCBvdXRzaWRlIG9mIERSVCwgeW91IG11c3QgZGVsZXRlIHRleHQsICdmb28n LCBtYW51YWxseS48L3A+Cis8ZGl2IGlkPSJzaGFkb3dob3N0IiBjb250ZW50ZWRpdGFibGU+PGRp dj5mb288L2Rpdj48L2Rpdj4KKzxzY3JpcHQ+CitpZiAod2luZG93LmxheW91dFRlc3RDb250cm9s bGVyKQorICAgIGxheW91dFRlc3RDb250cm9sbGVyLmR1bXBBc1RleHQoKTsKK3ZhciBzaGFkb3dS b290ID0gbmV3IFdlYktpdFNoYWRvd1Jvb3QoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3NoYWRv d2hvc3QnKSk7CitzaGFkb3dSb290LmlubmVySFRNTCA9ICI8Y29udGVudD48L2NvbnRlbnQ+IjsK KwordmFyIHRleHROb2RlID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3NoYWRvd2hvc3QnKS5m aXJzdENoaWxkLmZpcnN0Q2hpbGQ7Cit3aW5kb3cuZ2V0U2VsZWN0aW9uKCkuc2V0QmFzZUFuZEV4 dGVudCh0ZXh0Tm9kZSwgMCwgdGV4dE5vZGUsIDMpOworZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ0Rl bGV0ZScpOworCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKKzwvc2NyaXB0PgorPHNj cmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3Jp cHQ+Cis8L2JvZHk+Cis8L2h0bWw+Cg== 147514 2012-06-14 01:13:29 -0700 2012-06-14 22:04:58 -0700 fix mac build bug-88484-20120614171328.patch text/plain 10601 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwMTYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZWVmOWQ2NmJiMjA3ZmMw NTI3Y2I2NzQ3YzA1NWNjYTY5NTA3NGNiYi4uYTg5MDAyYzQzODEyOTQxNzJlZDA1ZmUzOGY2ZmUz MGU2OTQ0OWM5OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDEyLTA2LTEzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgd2Ug bXV0YXRlIG5vZGVzIHdoaWNoIGFyZSBjaGlsZHJlbiBvZiBhIHNoYWRvdyBob3N0LCBpdCBjYXVz ZXMKKyAgICAgICAgRWxlbWVudFNoYWRvdzo6aW52YWxpZGF0ZURpc3RyaWJ1dGlvbigpLiAgQXMg YSByZXN1bHQsIHNoYWRvdyBob3N0CisgICAgICAgIGlzIGRldGFjaGVkIChhbmQgbGF6eUF0dGFj aGVkKCkpIGFuZCBpdHMgcmVuZGVyZXIgaXMgZ29uZS4gIFRoYXQKKyAgICAgICAgY2F1c2VzIGFz c2VydGlvbiBlcnJvciBzaW5jZSBpc0VkaXRhYmxlUG9zaXRpb24oKSBhc3N1bWVzCisgICAgICAg IGFuY2hvck5vZGUncyBzdHlsZSB3YXMgY29ycmVjdGx5IGNhbGN1bGF0ZWQuCisKKyAgICAgICAg VGhpcyBwYXRjaCBtYWtlcyBpc0VkaXRhYmxlUG9zaXRpb24oKSBjYWxsCisgICAgICAgIGRvY3Vt ZW50LT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKSBzbyB0aGF0IGl0IGRv ZXMKKyAgICAgICAgbm90IHJldHVybiBhIGJvZ3VzIHJlc3VsdC4KKworICAgICAgICBUaGVyZSBp cyBhbiBleGNlcHRpb25hbCBjYWxsZXIgb2YgaXNFZGl0YWJsZVBvc2l0aW9uLAorICAgICAgICBS ZW5kZXJCbG9jazo6cGFpbnRDYXJldCgpLCBmcm9tIHdoZXJlIHdlIGNhbiBub3QgY2FsbAorICAg ICAgICB1cGRhdGVMYXlvdXQoKSBpbiBpc0VkaXRhYmxlUG9zaXRpb24gYmVjYXVzZSBpdCBoaXRz IGFzc2VydGlvbiwKKyAgICAgICAgQVNTRVJUKCFpc1BhaW50aW5nKS4gU28gSSd2ZSBhZGRlZCB0 aGUgdGhpcmQgcGFyYW1ldGVyIHRvCisgICAgICAgIGlzRWRpdGFibGVQb3NpdGlvbiB0byBjb250 cm9sIHN0eWxlIHVwZGF0ZS4KKworICAgICAgICBUZXN0OiBlZGl0aW9uL3NoYWRvdy9kZWxldGUt Y2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLmh0bWwKKworICAgICAgICAqIGVkaXRpbmcv RnJhbWVTZWxlY3Rpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lU2VsZWN0aW9uOjppc0Nv bnRlbnRFZGl0YWJsZSk6CisgICAgICAgICogZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6OlZpc2libGVTZWxlY3Rpb246OmlzQ29udGVudEVkaXRhYmxlKToK KyAgICAgICAgKiBlZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaDoKKyAgICAgICAgKFZpc2libGVT ZWxlY3Rpb24pOgorICAgICAgICAqIGVkaXRpbmcvaHRtbGVkaXRpbmcuY3BwOgorICAgICAgICAo V2ViQ29yZTo6aXNFZGl0YWJsZVBvc2l0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL2h0bWxlZGl0 aW5nLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiByZW5kZXJpbmcvUmVuZGVyQmxv Y2suY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyQmxvY2s6OnBhaW50Q2FyZXQpOgorCiAy MDEyLTA2LTEyICBXZWkgSmFtZXMgIDxqYW1lcy53ZWlAaW50ZWwuY29tPgogCiAgICAgICAgIHdl YmNvcmUgc2hvdWxkIGRlcGVuZCBvbiB3ZWJjb3JlX2FybV9uZW9uIGZvciBvbmx5IGFybSB0YXJn ZXRfYXJjaApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5leHAuaW4gYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgppbmRleCA3MWY2MTk2ZTQyMmNkNzg5Njg5NmU2NmVi NjE5NWVjMmI4MGEwYTBhLi43YmQxYjA2YjJkZTFjNDJmYWNjMzNlYmZmMTQ2M2FjM2I4MGY2ZmYy IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmV4cC5pbgorKysgYi9Tb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLmV4cC5pbgpAQCAtMTE4NSw3ICsxMTg1LDcgQEAgX19aTks3V2ViQ29y ZTE2SFRNTElucHV0RWxlbWVudDE4c2hvdWxkQXV0b2NvbXBsZXRlRXYKIF9fWk5LN1dlYkNvcmUx Nkljb25EYXRhYmFzZUJhc2UxMmRhdGFiYXNlUGF0aEV2CiBfX1pOSzdXZWJDb3JlMTZSZXNvdXJj ZVJlc3BvbnNlMTNuc1VSTFJlc3BvbnNlRXYKIF9fWk5LN1dlYkNvcmUxNlN0eWxlUHJvcGVydHlT ZXQyNWVuc3VyZUNTU1N0eWxlRGVjbGFyYXRpb25FdgotX19aTks3V2ViQ29yZTE2VmlzaWJsZVNl bGVjdGlvbjE3aXNDb250ZW50RWRpdGFibGVFdgorX19aTks3V2ViQ29yZTE2VmlzaWJsZVNlbGVj dGlvbjE3aXNDb250ZW50RWRpdGFibGVFTlNfMTJFVXBkYXRlU3R5bGVFCiBfX1pOSzdXZWJDb3Jl MTZWaXNpYmxlU2VsZWN0aW9uMTd0b05vcm1hbGl6ZWRSYW5nZUV2CiBfX1pOSzdXZWJDb3JlMTZW aXNpYmxlU2VsZWN0aW9uMTlyb290RWRpdGFibGVFbGVtZW50RXYKIF9fWk5LN1dlYkNvcmUxNlZp c2libGVTZWxlY3Rpb24yM2lzQ29udGVudFJpY2hseUVkaXRhYmxlRXYKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVTZWxlY3Rpb24uaCBiL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvRnJhbWVTZWxlY3Rpb24uaAppbmRleCA4ZmM0MmVjY2UwMzYyMDJhN2YwMjg0MGEwZTVk MTM0ZGM2NWRmYjA4Li5hMDJhNjViNDEyY2JlNTU3ZTMwM2I5N2IwM2M4ZjBmNGQ5ZGFkODFlIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0aW9uLmgKKysrIGIv U291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oCkBAIC0xMjksNyArMTI5LDcg QEAgcHVibGljOgogCiAgICAgRWxlbWVudCogcm9vdEVkaXRhYmxlRWxlbWVudCgpIGNvbnN0IHsg cmV0dXJuIG1fc2VsZWN0aW9uLnJvb3RFZGl0YWJsZUVsZW1lbnQoKTsgfQogICAgIEVsZW1lbnQq IHJvb3RFZGl0YWJsZUVsZW1lbnRPckRvY3VtZW50RWxlbWVudCgpIGNvbnN0OwotICAgIGJvb2wg aXNDb250ZW50RWRpdGFibGUoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5pc0NvbnRlbnRF ZGl0YWJsZSgpOyB9CisgICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZShFVXBkYXRlU3R5bGUgdXBk YXRlU3R5bGUgPSBVcGRhdGVTdHlsZSkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uaXNDb250 ZW50RWRpdGFibGUodXBkYXRlU3R5bGUpOyB9CiAgICAgYm9vbCBpc0NvbnRlbnRSaWNobHlFZGl0 YWJsZSgpIGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLmlzQ29udGVudFJpY2hseUVkaXRhYmxl KCk7IH0KICAgICAgCiAgICAgdm9pZCBtb3ZlVG8oY29uc3QgUmFuZ2UqLCBFQWZmaW5pdHksIEVV c2VyVHJpZ2dlcmVkID0gTm90VXNlclRyaWdnZXJlZCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwIGIvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9WaXNpYmxlU2VsZWN0aW9uLmNwcAppbmRleCAxMWI5MDE1NDEyZjExZjg2ODBlMDM1YmM5Nzc4 NjdjY2FkMjhkOTAyLi5lMjZmZTY2NTYyZjA0MWZhZjA1ZjJkMjhiYjYxZTcyY2VlOWYwMGE1IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHAKQEAgLTYwOSw5 ICs2MDksOSBAQCB2b2lkIFZpc2libGVTZWxlY3Rpb246OmFkanVzdFNlbGVjdGlvblRvQXZvaWRD cm9zc2luZ0VkaXRpbmdCb3VuZGFyaWVzKCkKICAgICAgICAgbV9leHRlbnQgPSBtX2Jhc2VJc0Zp cnN0ID8gbV9lbmQgOiBtX3N0YXJ0OwogfQogCi1ib29sIFZpc2libGVTZWxlY3Rpb246OmlzQ29u dGVudEVkaXRhYmxlKCkgY29uc3QKK2Jvb2wgVmlzaWJsZVNlbGVjdGlvbjo6aXNDb250ZW50RWRp dGFibGUoRVVwZGF0ZVN0eWxlIHVwZGF0ZVN0eWxlKSBjb25zdAogewotICAgIHJldHVybiBpc0Vk aXRhYmxlUG9zaXRpb24oc3RhcnQoKSk7CisgICAgcmV0dXJuIGlzRWRpdGFibGVQb3NpdGlvbihz dGFydCgpLCBDb250ZW50SXNFZGl0YWJsZSwgdXBkYXRlU3R5bGUpOwogfQogCiBib29sIFZpc2li bGVTZWxlY3Rpb246OmlzQ29udGVudFJpY2hseUVkaXRhYmxlKCkgY29uc3QKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5oIGIvU291cmNlL1dlYkNv cmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmgKaW5kZXggMjE5OTliYjNjYWQ0YzM0NWExOWFl YzM0ZDY3ZTllNTRjYmJjNmQyMS4uYzE4OTZmM2FlZTdmNGIzOWU2NjY4ZGE5MGM3OGU1MzFkYWNl NDlkOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9u LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmgKQEAgLTI4 LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIlRleHRHcmFudWxhcml0eS5oIgogI2luY2x1ZGUgIlZp c2libGVQb3NpdGlvbi5oIgorI2luY2x1ZGUgImh0bWxlZGl0aW5nLmgiCiAKIG5hbWVzcGFjZSBX ZWJDb3JlIHsKIApAQCAtOTgsNyArOTksNyBAQCBwdWJsaWM6CiAgICAgUGFzc1JlZlB0cjxSYW5n ZT4gdG9Ob3JtYWxpemVkUmFuZ2UoKSBjb25zdDsKICAgICAKICAgICBFbGVtZW50KiByb290RWRp dGFibGVFbGVtZW50KCkgY29uc3Q7Ci0gICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZSgpIGNvbnN0 OworICAgIGJvb2wgaXNDb250ZW50RWRpdGFibGUoRVVwZGF0ZVN0eWxlID0gVXBkYXRlU3R5bGUp IGNvbnN0OwogICAgIGJvb2wgaXNDb250ZW50UmljaGx5RWRpdGFibGUoKSBjb25zdDsKICAgICAv LyBSZXR1cm5zIGEgc2hhZG93IHRyZWUgbm9kZSBmb3IgbGVnYWN5IHNoYWRvdyB0cmVlcywgYSBj aGlsZCBvZiB0aGUKICAgICAvLyBTaGFkb3dSb290IG5vZGUgZm9yIG5ldyBzaGFkb3cgdHJlZXMs IG9yIDAgZm9yIG5vbi1zaGFkb3cgdHJlZXMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL2h0bWxlZGl0aW5nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRp bmcuY3BwCmluZGV4IGUxODBjY2FiZDFiMTYwMWZiOGQxNzA4ZGNiZjJkYmFjZjQ4MGY0NjUuLjFk NzJkZWE3ZDU3YzdhNzM3MTI2MDJiYzNlZjI3ODE5OGY4YzdlNmEgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvaHRtbGVkaXRpbmcuY3BwCkBAIC0xNDUsMTIgKzE0NSwyMSBAQCBOb2RlKiBsb3dlc3RF ZGl0YWJsZUFuY2VzdG9yKE5vZGUqIG5vZGUpCiAgICAgcmV0dXJuIGxvd2VzdFJvb3Q7CiB9CiAK LWJvb2wgaXNFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiBwLCBFZGl0YWJsZVR5cGUg ZWRpdGFibGVUeXBlKQorYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRpb24mIHAs IEVkaXRhYmxlVHlwZSBlZGl0YWJsZVR5cGUsIEVVcGRhdGVTdHlsZSB1cGRhdGVTdHlsZSkKIHsK ICAgICBOb2RlKiBub2RlID0gcC5kZXByZWNhdGVkTm9kZSgpOwogICAgIGlmICghbm9kZSkKICAg ICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICAKKyAgICBzd2l0Y2ggKHVwZGF0ZVN0eWxlKSB7 CisgICAgY2FzZSBVcGRhdGVTdHlsZToKKyAgICAgICAgbm9kZS0+ZG9jdW1lbnQoKS0+dXBkYXRl TGF5b3V0SWdub3JlUGVuZGluZ1N0eWxlc2hlZXRzKCk7CisgICAgICAgIGJyZWFrOworICAgIGNh c2UgRG9Ob3RVcGRhdGVTdHlsZToKKyAgICAgICAgYnJlYWs7CisgICAgZGVmYXVsdDoKKyAgICAg ICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIGJyZWFrOworICAgIH0KICAgICBpZiAo bm9kZS0+cmVuZGVyZXIoKSAmJiBub2RlLT5yZW5kZXJlcigpLT5pc1RhYmxlKCkpCiAgICAgICAg IG5vZGUgPSBub2RlLT5wYXJlbnROb2RlKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxl ZGl0aW5nLmgKaW5kZXggYTgxOWM0OTJjYjA2ZWY4YWM4OWVjOGIzZjMxODYwOGU5YjBlMjJlZC4u YWVhMDIzMWViMWM3OWQ5NWE3NzE4ZjlkZGM1ZjRhZDRmMWJjNDdkZSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2Vk aXRpbmcvaHRtbGVkaXRpbmcuaApAQCAtMTUxLDggKzE1MSwxMiBAQCBpbmxpbmUgUG9zaXRpb24g bGFzdFBvc2l0aW9uSW5PckFmdGVyTm9kZShOb2RlKiBub2RlKQogaW50IGNvbXBhcmVQb3NpdGlv bnMoY29uc3QgUG9zaXRpb24mLCBjb25zdCBQb3NpdGlvbiYpOwogCiAvLyBib29sZWFuIGZ1bmN0 aW9ucyBvbiBQb3NpdGlvbgotICAgIAotYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9z aXRpb24mLCBFZGl0YWJsZVR5cGUgPSBDb250ZW50SXNFZGl0YWJsZSk7CisKK2VudW0gRVVwZGF0 ZVN0eWxlIHsKKyAgICBVcGRhdGVTdHlsZSwKKyAgICBEb05vdFVwZGF0ZVN0eWxlLAorfTsKK2Jv b2wgaXNFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiwgRWRpdGFibGVUeXBlID0gQ29u dGVudElzRWRpdGFibGUsIEVVcGRhdGVTdHlsZSA9IFVwZGF0ZVN0eWxlKTsKIGJvb2wgaXNSaWNo bHlFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiwgRWRpdGFibGVUeXBlID0gQ29udGVu dElzRWRpdGFibGUpOwogYm9vbCBpc0ZpcnN0VmlzaWJsZVBvc2l0aW9uSW5TcGVjaWFsRWxlbWVu dChjb25zdCBQb3NpdGlvbiYpOwogYm9vbCBpc0xhc3RWaXNpYmxlUG9zaXRpb25JblNwZWNpYWxF bGVtZW50KGNvbnN0IFBvc2l0aW9uJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyQmxvY2suY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJs b2NrLmNwcAppbmRleCAxZWE5MGM3NGRmZDIwOGJmNjQzOThhNDdjOWY5OWNiMTY0NTY5YjRkLi4z YzdlODY1MTlkYmY1MWJkMjdiZjI2ZTJlOTI2ZTliNDE0ZDhjYjkwIDEwMDc1NQotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKQEAgLTI4MzYsNyArMjgzNiw3IEBAIHZvaWQgUmVu ZGVyQmxvY2s6OnBhaW50Q2FyZXQoUGFpbnRJbmZvJiBwYWludEluZm8sIGNvbnN0IExheW91dFBv aW50JiBwYWludE9mZnNlCiAgICAgYm9vbCBpc0NvbnRlbnRFZGl0YWJsZTsKICAgICBpZiAodHlw ZSA9PSBDdXJzb3JDYXJldCkgewogICAgICAgICBjYXJldFBhaW50ZXIgPSBmcmFtZSgpLT5zZWxl Y3Rpb24oKS0+Y2FyZXRSZW5kZXJlcigpOwotICAgICAgICBpc0NvbnRlbnRFZGl0YWJsZSA9IGZy YW1lKCktPnNlbGVjdGlvbigpLT5pc0NvbnRlbnRFZGl0YWJsZSgpOworICAgICAgICBpc0NvbnRl bnRFZGl0YWJsZSA9IGZyYW1lKCktPnNlbGVjdGlvbigpLT5pc0NvbnRlbnRFZGl0YWJsZShEb05v dFVwZGF0ZVN0eWxlKTsKICAgICB9IGVsc2UgewogICAgICAgICBjYXJldFBhaW50ZXIgPSBmcmFt ZSgpLT5wYWdlKCktPmRyYWdDYXJldENvbnRyb2xsZXIoKS0+Y2FyZXRSZW5kZXJlcigpOwogICAg ICAgICBpc0NvbnRlbnRFZGl0YWJsZSA9IGZyYW1lKCktPnBhZ2UoKS0+ZHJhZ0NhcmV0Q29udHJv bGxlcigpLT5pc0NvbnRlbnRFZGl0YWJsZSgpOwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hh bmdlTG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDFlMTI3OGRiMTRkNTc3ZTIwMjJm MDNhNzE3OGZkNjE3NzUwMDdlOTYuLjhiMTI3ZGFiOTUzNjc1ZTQzNjljYjg4YmYwMzZiZTM5ZmZl MzQ4YWQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0 cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxMi0wNi0xMyAgSGF5YXRvIEl0byAgPGhh eWF0b0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW1NoYWRvd11bRWRpdGluZ10gRGVsZXRpbmcg Y2hhcmFjdGVyIGluIGRpc3RyaWJ1dGVkIGVsZW1lbnQgY2F1c2VkIGEgY3Jhc2gKKyAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBlZGl0aW5nL3NoYWRvdy9k ZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLWV4cGVjdGVkLnR4dDog QWRkZWQuCisgICAgICAgICogZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlz dHJpYnV0ZWQtbm9kZS1jcmFzaC5odG1sOiBBZGRlZC4KKwogMjAxMi0wNi0xMiAgQ3NhYmEgT3N6 dHJvZ29uw6FjICA8b3NzeUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtRdF0gVW5yZXZpZXdlZCBt b3JuaW5nIGdhcmRlbmluZywgc2tpcCBuZXcgZmFpbGluZyB0ZXN0cy4KZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVk LW5vZGUtY3Jhc2gtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVs ZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3RlZC50eHQKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZjQ2Y2YxMGI1N2UzYjZiODg4ZmEyYmJiODA5MDE0MWI1ZDlkY2VmOQotLS0gL2Rl di9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJz LWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2gtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsNyBAQAor UEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCitUaGlzIHRl c3RzIHRoZSBkZWxldGlvbiBvZiB0ZXh0IGluIGRpc3RyaWJ1dGVkIG5vZGUgZG9lcyBub3QgY3Jh c2guIFRvIHJ1biBpdCBvdXRzaWRlIG9mIERSVCwgeW91IG11c3QgZGVsZXRlIHRleHQsICdmb28n LCBtYW51YWxseS4KKworCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93 L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2guaHRtbCBiL0xheW91 dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5v ZGUtY3Jhc2guaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5mYjUwNDQwYWYzMTJjYzIzZmNmYmUyZTIwZTY5NDkx NzI3NWIzMWE3Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cv ZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC5odG1sCkBAIC0wLDAg KzEsMjIgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0bWw+Cis8Ym9keT4KKzxzY3JpcHQgc3JjPSIu Li8uLi9mYXN0L2RvbS9yZXNvdXJjZXMvZXZlbnQtc2VuZGVyLXV0aWwuanMiPjwvc2NyaXB0Pgor PHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3Nj cmlwdD4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+VGhpcyB0ZXN0cyB0aGUgZGVsZXRpb24gb2YgdGV4 dCBpbiBkaXN0cmlidXRlZCBub2RlIGRvZXMgbm90IGNyYXNoLiBUbyBydW4gaXQgb3V0c2lkZSBv ZiBEUlQsIHlvdSBtdXN0IGRlbGV0ZSB0ZXh0LCAnZm9vJywgbWFudWFsbHkuPC9wPgorPGRpdiBp ZD0ic2hhZG93aG9zdCIgY29udGVudGVkaXRhYmxlPjxkaXY+Zm9vPC9kaXY+PC9kaXY+Cis8c2Ny aXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRUZXN0Q29u dHJvbGxlci5kdW1wQXNUZXh0KCk7Cit2YXIgc2hhZG93Um9vdCA9IG5ldyBXZWJLaXRTaGFkb3dS b290KGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzaGFkb3dob3N0JykpOworc2hhZG93Um9vdC5p bm5lckhUTUwgPSAiPGNvbnRlbnQ+PC9jb250ZW50PiI7CisKK3ZhciB0ZXh0Tm9kZSA9IGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCdzaGFkb3dob3N0JykuZmlyc3RDaGlsZC5maXJzdENoaWxkOwor d2luZG93LmdldFNlbGVjdGlvbigpLnNldEJhc2VBbmRFeHRlbnQodGV4dE5vZGUsIDAsIHRleHRO b2RlLCAzKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCdEZWxldGUnKTsKKwordmFyIHN1Y2Nlc3Nm dWxseVBhcnNlZCA9IHRydWU7Cis8L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pz L3Jlc291cmNlcy9qcy10ZXN0LXBvc3QuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo= 147728 2012-06-14 22:05:04 -0700 2012-06-20 16:54:58 -0700 add rendererIsEditable bug-88484-20120615140503.patch text/plain 9927 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwMzk4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODMwYTVjZTcwNzBkMWFj YWQ5ZDUxZTU2YTQzM2QyZWU2MTc3YTk3YS4uYTNiMmU2NzljZDlhMzg1NjRjZTM1ZGMwYTU1NzQ1 OWFiMWZkYTU4MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQ0IEBACisyMDEyLTA2LTEzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgd2Ug bXV0YXRlIG5vZGVzIHdoaWNoIGFyZSBjaGlsZHJlbiBvZiBhIHNoYWRvdyBob3N0LCBpdCBjYXVz ZXMKKyAgICAgICAgRWxlbWVudFNoYWRvdzo6aW52YWxpZGF0ZURpc3RyaWJ1dGlvbigpLiAgQXMg YSByZXN1bHQsIHNoYWRvdyBob3N0CisgICAgICAgIGlzIGRldGFjaGVkIChhbmQgbGF6eUF0dGFj aGVkKCkpIGFuZCBpdHMgcmVuZGVyZXIgaXMgZ29uZS4gIFRoYXQKKyAgICAgICAgY2F1c2VzIGFz c2VydGlvbiBlcnJvciBzaW5jZSBpc0VkaXRhYmxlUG9zaXRpb24oKSBhc3N1bWVzCisgICAgICAg IGFuY2hvck5vZGUncyBzdHlsZSB3YXMgY29ycmVjdGx5IGNhbGN1bGF0ZWQuCisKKyAgICAgICAg VGhpcyBwYXRjaCBtYWtlcyBpc0VkaXRhYmxlUG9zaXRpb24oKSBjYWxsCisgICAgICAgIGRvY3Vt ZW50LT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKSBzbyB0aGF0IGl0IGRv ZXMKKyAgICAgICAgbm90IHJldHVybiBhIGJvZ3VzIHJlc3VsdC4KKworICAgICAgICBUaGVyZSBp cyBhbiBleGNlcHRpb25hbCBjYWxsZXIgb2YgaXNFZGl0YWJsZVBvc2l0aW9uLAorICAgICAgICBS ZW5kZXJCbG9jazo6cGFpbnRDYXJldCgpLCBmcm9tIHdoZXJlIHdlIGNhbiBub3QgY2FsbAorICAg ICAgICB1cGRhdGVMYXlvdXQoKSBpbiBpc0VkaXRhYmxlUG9zaXRpb24gYmVjYXVzZSBpdCBoaXRz IGFzc2VydGlvbiwKKyAgICAgICAgQVNTRVJUKCFpc1BhaW50aW5nKS4gU28gSSd2ZSBhZGRlZCB0 aGUgdGhpcmQgcGFyYW1ldGVyIHRvCisgICAgICAgIGlzRWRpdGFibGVQb3NpdGlvbiB0byBjb250 cm9sIHVwZGF0aW5nIHRoZSBzdHlsZS4KKworICAgICAgICBUZXN0OiBlZGl0aW9uL3NoYWRvdy9k ZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLmh0bWwKKworICAgICAgICAqIFdl YkNvcmUuZXhwLmluOgorICAgICAgICAqIGVkaXRpbmcvRnJhbWVTZWxlY3Rpb24uaDoKKyAgICAg ICAgKFdlYkNvcmU6OkZyYW1lU2VsZWN0aW9uOjpyZW5kZXJlcklzRWRpdGFibGUpOgorICAgICAg ICAqIGVkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWaXNp YmxlU2VsZWN0aW9uOjppc0NvbnRlbnRFZGl0YWJsZSk6CisgICAgICAgIChXZWJDb3JlKToKKyAg ICAgICAgKFdlYkNvcmU6OlZpc2libGVTZWxlY3Rpb246OnJlbmRlcmVySXNFZGl0YWJsZSk6Cisg ICAgICAgICogZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmg6CisgICAgICAgIChWaXNpYmxlU2Vs ZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5nL2h0bWxlZGl0aW5nLmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OmlzRWRpdGFibGVQb3NpdGlvbik6CisgICAgICAgICogZWRpdGluZy9odG1sZWRpdGlu Zy5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJsb2Nr LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJlbmRlckJsb2NrOjpwYWludENhcmV0KToKKwogMjAx Mi0wNi0xNCAgQWRyaWVubmUgV2Fsa2VyICA8ZW5uZUBnb29nbGUuY29tPgogCiAgICAgICAgIFtj aHJvbWl1bV0gTWFrZSBUaWxlZExheWVyQ2hyb21pdW0gcm9idXN0IHRvIHVuZXhwZWN0ZWQgbnVs bCB0aWxlcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlv bi5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oCmluZGV4IDRkN2Y5 ODc3NTk1YzI2NDMzMmJlZDg4ZjNhNDU4YWQ4MWI3NmQ0MzAuLmM2M2FmODhlZjEzYjE0MjkyMTZj NDdjYmU0OGVjYTE3ODQxZWE3ZjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv RnJhbWVTZWxlY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0 aW9uLmgKQEAgLTEzMCw2ICsxMzAsNyBAQCBwdWJsaWM6CiAKICAgICBFbGVtZW50KiByb290RWRp dGFibGVFbGVtZW50KCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24ucm9vdEVkaXRhYmxlRWxl bWVudCgpOyB9CiAgICAgRWxlbWVudCogcm9vdEVkaXRhYmxlRWxlbWVudE9yRG9jdW1lbnRFbGVt ZW50KCkgY29uc3Q7CisgICAgYm9vbCByZW5kZXJlcklzRWRpdGFibGUoKSBjb25zdCB7IHJldHVy biBtX3NlbGVjdGlvbi5yZW5kZXJlcklzRWRpdGFibGUoKTsgfQogICAgIGJvb2wgaXNDb250ZW50 RWRpdGFibGUoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5pc0NvbnRlbnRFZGl0YWJsZSgp OyB9CiAgICAgYm9vbCBpc0NvbnRlbnRSaWNobHlFZGl0YWJsZSgpIGNvbnN0IHsgcmV0dXJuIG1f c2VsZWN0aW9uLmlzQ29udGVudFJpY2hseUVkaXRhYmxlKCk7IH0KICAgICAgCmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwIGIvU291cmNlL1dl YkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcAppbmRleCAxMWI5MDE1NDEyZjExZjg2 ODBlMDM1YmM5Nzc4NjdjY2FkMjhkOTAyLi43MDJjNWJlYjlkMDU1ZjAyZjc4MzRmMGUxZDY3Yzc0 OTEyOGFkNTg3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxl Y3Rpb24uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlvbi5j cHAKQEAgLTYxMSw3ICs2MTEsMTIgQEAgdm9pZCBWaXNpYmxlU2VsZWN0aW9uOjphZGp1c3RTZWxl Y3Rpb25Ub0F2b2lkQ3Jvc3NpbmdFZGl0aW5nQm91bmRhcmllcygpCiAKIGJvb2wgVmlzaWJsZVNl bGVjdGlvbjo6aXNDb250ZW50RWRpdGFibGUoKSBjb25zdAogewotICAgIHJldHVybiBpc0VkaXRh YmxlUG9zaXRpb24oc3RhcnQoKSk7CisgICAgcmV0dXJuIGlzRWRpdGFibGVQb3NpdGlvbihzdGFy dCgpLCBDb250ZW50SXNFZGl0YWJsZSwgVXBkYXRlU3R5bGUpOworfQorCitib29sIFZpc2libGVT ZWxlY3Rpb246OnJlbmRlcmVySXNFZGl0YWJsZSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIGlzRWRp dGFibGVQb3NpdGlvbihzdGFydCgpLCBDb250ZW50SXNFZGl0YWJsZSwgRG9Ob3RVcGRhdGVTdHls ZSk7CiB9CiAKIGJvb2wgVmlzaWJsZVNlbGVjdGlvbjo6aXNDb250ZW50UmljaGx5RWRpdGFibGUo KSBjb25zdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0 aW9uLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uaAppbmRleCAy MTk5OWJiM2NhZDRjMzQ1YTE5YWVjMzRkNjdlOWU1NGNiYmM2ZDIxLi42ZWZlMGFlYWEzY2M2NWY4 YjY5NmQ2ODEyMzRmYjgzZTExMmI2ZmZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0 aW5nL1Zpc2libGVTZWxlY3Rpb24uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2li bGVTZWxlY3Rpb24uaApAQCAtMjgsNiArMjgsNyBAQAogCiAjaW5jbHVkZSAiVGV4dEdyYW51bGFy aXR5LmgiCiAjaW5jbHVkZSAiVmlzaWJsZVBvc2l0aW9uLmgiCisjaW5jbHVkZSAiaHRtbGVkaXRp bmcuaCIKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC05OSw2ICsxMDAsNyBAQCBwdWJsaWM6 CiAgICAgCiAgICAgRWxlbWVudCogcm9vdEVkaXRhYmxlRWxlbWVudCgpIGNvbnN0OwogICAgIGJv b2wgaXNDb250ZW50RWRpdGFibGUoKSBjb25zdDsKKyAgICBib29sIHJlbmRlcmVySXNFZGl0YWJs ZSgpIGNvbnN0OwogICAgIGJvb2wgaXNDb250ZW50UmljaGx5RWRpdGFibGUoKSBjb25zdDsKICAg ICAvLyBSZXR1cm5zIGEgc2hhZG93IHRyZWUgbm9kZSBmb3IgbGVnYWN5IHNoYWRvdyB0cmVlcywg YSBjaGlsZCBvZiB0aGUKICAgICAvLyBTaGFkb3dSb290IG5vZGUgZm9yIG5ldyBzaGFkb3cgdHJl ZXMsIG9yIDAgZm9yIG5vbi1zaGFkb3cgdHJlZXMuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVk aXRpbmcuY3BwCmluZGV4IGUxODBjY2FiZDFiMTYwMWZiOGQxNzA4ZGNiZjJkYmFjZjQ4MGY0NjUu LjFkNzJkZWE3ZDU3YzdhNzM3MTI2MDJiYzNlZjI3ODE5OGY4YzdlNmEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2VkaXRpbmcvaHRtbGVkaXRpbmcuY3BwCkBAIC0xNDUsMTIgKzE0NSwyMSBAQCBOb2RlKiBsb3dl c3RFZGl0YWJsZUFuY2VzdG9yKE5vZGUqIG5vZGUpCiAgICAgcmV0dXJuIGxvd2VzdFJvb3Q7CiB9 CiAKLWJvb2wgaXNFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiBwLCBFZGl0YWJsZVR5 cGUgZWRpdGFibGVUeXBlKQorYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3QgUG9zaXRpb24m IHAsIEVkaXRhYmxlVHlwZSBlZGl0YWJsZVR5cGUsIEVVcGRhdGVTdHlsZSB1cGRhdGVTdHlsZSkK IHsKICAgICBOb2RlKiBub2RlID0gcC5kZXByZWNhdGVkTm9kZSgpOwogICAgIGlmICghbm9kZSkK ICAgICAgICAgcmV0dXJuIGZhbHNlOwotICAgICAgICAKKyAgICBzd2l0Y2ggKHVwZGF0ZVN0eWxl KSB7CisgICAgY2FzZSBVcGRhdGVTdHlsZToKKyAgICAgICAgbm9kZS0+ZG9jdW1lbnQoKS0+dXBk YXRlTGF5b3V0SWdub3JlUGVuZGluZ1N0eWxlc2hlZXRzKCk7CisgICAgICAgIGJyZWFrOworICAg IGNhc2UgRG9Ob3RVcGRhdGVTdHlsZToKKyAgICAgICAgYnJlYWs7CisgICAgZGVmYXVsdDoKKyAg ICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIGJyZWFrOworICAgIH0KICAgICBp ZiAobm9kZS0+cmVuZGVyZXIoKSAmJiBub2RlLT5yZW5kZXJlcigpLT5pc1RhYmxlKCkpCiAgICAg ICAgIG5vZGUgPSBub2RlLT5wYXJlbnROb2RlKCk7CiAgICAgCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmggYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0 bWxlZGl0aW5nLmgKaW5kZXggYTgxOWM0OTJjYjA2ZWY4YWM4OWVjOGIzZjMxODYwOGU5YjBlMjJl ZC4uYWVhMDIzMWViMWM3OWQ5NWE3NzE4ZjlkZGM1ZjRhZDRmMWJjNDdkZSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L2VkaXRpbmcvaHRtbGVkaXRpbmcuaApAQCAtMTUxLDggKzE1MSwxMiBAQCBpbmxpbmUgUG9zaXRp b24gbGFzdFBvc2l0aW9uSW5PckFmdGVyTm9kZShOb2RlKiBub2RlKQogaW50IGNvbXBhcmVQb3Np dGlvbnMoY29uc3QgUG9zaXRpb24mLCBjb25zdCBQb3NpdGlvbiYpOwogCiAvLyBib29sZWFuIGZ1 bmN0aW9ucyBvbiBQb3NpdGlvbgotICAgIAotYm9vbCBpc0VkaXRhYmxlUG9zaXRpb24oY29uc3Qg UG9zaXRpb24mLCBFZGl0YWJsZVR5cGUgPSBDb250ZW50SXNFZGl0YWJsZSk7CisKK2VudW0gRVVw ZGF0ZVN0eWxlIHsKKyAgICBVcGRhdGVTdHlsZSwKKyAgICBEb05vdFVwZGF0ZVN0eWxlLAorfTsK K2Jvb2wgaXNFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiwgRWRpdGFibGVUeXBlID0g Q29udGVudElzRWRpdGFibGUsIEVVcGRhdGVTdHlsZSA9IFVwZGF0ZVN0eWxlKTsKIGJvb2wgaXNS aWNobHlFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiwgRWRpdGFibGVUeXBlID0gQ29u dGVudElzRWRpdGFibGUpOwogYm9vbCBpc0ZpcnN0VmlzaWJsZVBvc2l0aW9uSW5TcGVjaWFsRWxl bWVudChjb25zdCBQb3NpdGlvbiYpOwogYm9vbCBpc0xhc3RWaXNpYmxlUG9zaXRpb25JblNwZWNp YWxFbGVtZW50KGNvbnN0IFBvc2l0aW9uJik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRl ckJsb2NrLmNwcAppbmRleCA2MmYzMTVlNWEyYTRmOGYwZDIyNGQwMWY5Yzc2MjQyMmQzM2UxN2Rj Li5jYzJhZDY5MGU1YTI2MjJjOTJmY2QyM2MxNDlhZjlkZTM4Yzg3MDE1IDEwMDc1NQotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCisrKyBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKQEAgLTI4MzYsMTAgKzI4MzYsMTAgQEAgdm9p ZCBSZW5kZXJCbG9jazo6cGFpbnRDYXJldChQYWludEluZm8mIHBhaW50SW5mbywgY29uc3QgTGF5 b3V0UG9pbnQmIHBhaW50T2Zmc2UKICAgICBib29sIGlzQ29udGVudEVkaXRhYmxlOwogICAgIGlm ICh0eXBlID09IEN1cnNvckNhcmV0KSB7CiAgICAgICAgIGNhcmV0UGFpbnRlciA9IGZyYW1lKCkt PnNlbGVjdGlvbigpLT5jYXJldFJlbmRlcmVyKCk7Ci0gICAgICAgIGlzQ29udGVudEVkaXRhYmxl ID0gZnJhbWUoKS0+c2VsZWN0aW9uKCktPmlzQ29udGVudEVkaXRhYmxlKCk7CisgICAgICAgIGlz Q29udGVudEVkaXRhYmxlID0gZnJhbWUoKS0+c2VsZWN0aW9uKCktPnJlbmRlcmVySXNFZGl0YWJs ZSgpOwogICAgIH0gZWxzZSB7CiAgICAgICAgIGNhcmV0UGFpbnRlciA9IGZyYW1lKCktPnBhZ2Uo KS0+ZHJhZ0NhcmV0Q29udHJvbGxlcigpLT5jYXJldFJlbmRlcmVyKCk7Ci0gICAgICAgIGlzQ29u dGVudEVkaXRhYmxlID0gZnJhbWUoKS0+cGFnZSgpLT5kcmFnQ2FyZXRDb250cm9sbGVyKCktPmlz Q29udGVudEVkaXRhYmxlKCk7CisgICAgICAgIGlzQ29udGVudEVkaXRhYmxlID0gY2FyZXRQYWlu dGVyID8gY2FyZXRQYWludGVyLT5ub2RlKCktPnJlbmRlcmVySXNFZGl0YWJsZSgpIDogZmFsc2U7 CiAgICAgfQogCiAgICAgaWYgKGNhcmV0UGFpbnRlciA9PSB0aGlzICYmIChpc0NvbnRlbnRFZGl0 YWJsZSB8fCBjYXJldEJyb3dzaW5nKSkgewpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvQ2hhbmdl TG9nIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCmluZGV4IDUxNjMzZWVjYWM0YzRhMTcwMDAwZTM3 ODU1ZDc4NTg2Njk2MDlhNmUuLjAxNjQ4ODViNGI1NjRiZjBlY2M4OTU5MTAyNzgyMzYxZGQzOWUx MmUgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL0NoYW5nZUxvZworKysgYi9MYXlvdXRUZXN0cy9D aGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxMi0wNi0xMyAgSGF5YXRvIEl0byAgPGhheWF0 b0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW1NoYWRvd11bRWRpdGluZ10gRGVsZXRpbmcgY2hh cmFjdGVyIGluIGRpc3RyaWJ1dGVkIGVsZW1lbnQgY2F1c2VkIGEgY3Jhc2gKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0CisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBlZGl0aW5nL3NoYWRvdy9kZWxl dGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJp YnV0ZWQtbm9kZS1jcmFzaC5odG1sOiBBZGRlZC4KKwogMjAxMi0wNi0xNCAgS2VudCBUYW11cmEg IDx0a2VudEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVmFsaWRhdGUgZm9ybSBzdGF0ZSBzdHJp bmdzIGluIEZvcm1Db250cm9sbGVyOjpzZXRTdGF0ZUZvck5ld0Zvcm1FbGVtZW50cygpCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1k aXN0cmlidXRlZC1ub2RlLWNyYXNoLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2VkaXRpbmcv c2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2gtZXhwZWN0 ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmY0NmNmMTBiNTdlM2I2Yjg4OGZhMmJiYjgwOTAxNDFiNWQ5ZGNl ZjkKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUt Y2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLWV4cGVjdGVkLnR4dApAQCAtMCww ICsxLDcgQEAKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVU RQorVGhpcyB0ZXN0cyB0aGUgZGVsZXRpb24gb2YgdGV4dCBpbiBkaXN0cmlidXRlZCBub2RlIGRv ZXMgbm90IGNyYXNoLiBUbyBydW4gaXQgb3V0c2lkZSBvZiBEUlQsIHlvdSBtdXN0IGRlbGV0ZSB0 ZXh0LCAnZm9vJywgbWFudWFsbHkuCisKKworCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0 aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLmh0 bWwgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0 cmlidXRlZC1ub2RlLWNyYXNoLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmI1MDQ0MGFmMzEyY2MyM2ZjZmJl MmUyMGU2OTQ5MTcyNzViMzFhNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2VkaXRp bmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2guaHRt bApAQCAtMCwwICsxLDIyIEBACis8IURPQ1RZUEUgaHRtbD4KKzxodG1sPgorPGJvZHk+Cis8c2Ny aXB0IHNyYz0iLi4vLi4vZmFzdC9kb20vcmVzb3VyY2VzL2V2ZW50LXNlbmRlci11dGlsLmpzIj48 L3NjcmlwdD4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXBy ZS5qcyI+PC9zY3JpcHQ+Cis8cCBpZD0iZGVzY3JpcHRpb24iPlRoaXMgdGVzdHMgdGhlIGRlbGV0 aW9uIG9mIHRleHQgaW4gZGlzdHJpYnV0ZWQgbm9kZSBkb2VzIG5vdCBjcmFzaC4gVG8gcnVuIGl0 IG91dHNpZGUgb2YgRFJULCB5b3UgbXVzdCBkZWxldGUgdGV4dCwgJ2ZvbycsIG1hbnVhbGx5Ljwv cD4KKzxkaXYgaWQ9InNoYWRvd2hvc3QiIGNvbnRlbnRlZGl0YWJsZT48ZGl2PmZvbzwvZGl2Pjwv ZGl2PgorPHNjcmlwdD4KK2lmICh3aW5kb3cubGF5b3V0VGVzdENvbnRyb2xsZXIpCisgICAgbGF5 b3V0VGVzdENvbnRyb2xsZXIuZHVtcEFzVGV4dCgpOwordmFyIHNoYWRvd1Jvb3QgPSBuZXcgV2Vi S2l0U2hhZG93Um9vdChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc2hhZG93aG9zdCcpKTsKK3No YWRvd1Jvb3QuaW5uZXJIVE1MID0gIjxjb250ZW50PjwvY29udGVudD4iOworCit2YXIgdGV4dE5v ZGUgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc2hhZG93aG9zdCcpLmZpcnN0Q2hpbGQuZmly c3RDaGlsZDsKK3dpbmRvdy5nZXRTZWxlY3Rpb24oKS5zZXRCYXNlQW5kRXh0ZW50KHRleHROb2Rl LCAwLCB0ZXh0Tm9kZSwgMyk7Citkb2N1bWVudC5leGVjQ29tbWFuZCgnRGVsZXRlJyk7CisKK3Zh ciBzdWNjZXNzZnVsbHlQYXJzZWQgPSB0cnVlOworPC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4v Li4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4K KzwvaHRtbD4K 148676 2012-06-20 16:34:24 -0700 2012-06-29 00:44:42 -0700 update bug-88484-20120621083423.patch text/plain 9224 hayato U3VidmVyc2lvbiBSZXZpc2lvbjogMTIwODI5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNjNmNjY1YTVmZjBmNzgx YjIyY2VkOWZlZWFlMWYwMGZiOGYwYTM0MS4uMzg3ZGNhYjI0ODJjZWM1NDBhNmI0MDdkYzk1M2Qz Yjc5YmEyMzYxYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQyIEBACisyMDEyLTA2LTEzICBIYXlh dG8gSXRvICA8aGF5YXRvQGNocm9taXVtLm9yZz4KKworICAgICAgICBbU2hhZG93XVtFZGl0aW5n XSBEZWxldGluZyBjaGFyYWN0ZXIgaW4gZGlzdHJpYnV0ZWQgZWxlbWVudCBjYXVzZWQgYSBjcmFz aC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTg4NDg0 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSWYgd2Ug bXV0YXRlIG5vZGVzIHdoaWNoIGFyZSBjaGlsZHJlbiBvZiBhIHNoYWRvdyBob3N0LCBpdCBjYXVz ZXMKKyAgICAgICAgRWxlbWVudFNoYWRvdzo6aW52YWxpZGF0ZURpc3RyaWJ1dGlvbigpLiAgQXMg YSByZXN1bHQsIHNoYWRvdyBob3N0CisgICAgICAgIGlzIGRldGFjaGVkIChhbmQgbGF6eUF0dGFj aGVkKCkpIGFuZCBpdHMgcmVuZGVyZXIgaXMgZ29uZS4gIFRoYXQKKyAgICAgICAgY2F1c2VzIGFz c2VydGlvbiBlcnJvciBzaW5jZSBpc0VkaXRhYmxlUG9zaXRpb24oKSBhc3N1bWVzCisgICAgICAg IGFuY2hvck5vZGUncyBzdHlsZSB3YXMgY29ycmVjdGx5IGNhbGN1bGF0ZWQuCisKKyAgICAgICAg VGhpcyBwYXRjaCBtYWtlcyBpc0VkaXRhYmxlUG9zaXRpb24oKSBjYWxsCisgICAgICAgIGRvY3Vt ZW50LT51cGRhdGVMYXlvdXRJZ25vcmVQZW5kaW5nU3R5bGVzaGVldHMoKSBzbyB0aGF0IGl0IGRv ZXMKKyAgICAgICAgbm90IHJldHVybiBhIGJvZ3VzIHJlc3VsdC4KKworICAgICAgICBUaGVyZSBp cyBhbiBleGNlcHRpb25hbCBjYWxsZXIgb2YgaXNFZGl0YWJsZVBvc2l0aW9uLAorICAgICAgICBS ZW5kZXJCbG9jazo6cGFpbnRDYXJldCgpLCBmcm9tIHdoZXJlIHdlIGNhbiBub3QgY2FsbAorICAg ICAgICB1cGRhdGVMYXlvdXQoKSBpbiBpc0VkaXRhYmxlUG9zaXRpb24gYmVjYXVzZSBpdCBoaXRz IGFzc2VydGlvbiwKKyAgICAgICAgQVNTRVJUKCFpc1BhaW50aW5nKS4gU28gSSd2ZSBhZGRlZCB0 aGUgdGhpcmQgcGFyYW1ldGVyIHRvCisgICAgICAgIGlzRWRpdGFibGVQb3NpdGlvbiB0byBjb250 cm9sIHVwZGF0aW5nIHRoZSBzdHlsZS4KKworICAgICAgICBUZXN0OiBlZGl0aW9uL3NoYWRvdy9k ZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLmh0bWwKKworICAgICAgICAqIGVk aXRpbmcvRnJhbWVTZWxlY3Rpb24uaDoKKyAgICAgICAgKFdlYkNvcmU6OkZyYW1lU2VsZWN0aW9u OjpyZW5kZXJlcklzRWRpdGFibGUpOgorICAgICAgICAqIGVkaXRpbmcvVmlzaWJsZVNlbGVjdGlv bi5jcHA6CisgICAgICAgIChXZWJDb3JlOjpWaXNpYmxlU2VsZWN0aW9uOjpyZW5kZXJlcklzRWRp dGFibGUpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogZWRpdGluZy9WaXNpYmxlU2Vs ZWN0aW9uLmg6CisgICAgICAgIChWaXNpYmxlU2VsZWN0aW9uKToKKyAgICAgICAgKiBlZGl0aW5n L2h0bWxlZGl0aW5nLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OmlzRWRpdGFibGVQb3NpdGlvbik6 CisgICAgICAgICogZWRpdGluZy9odG1sZWRpdGluZy5oOgorICAgICAgICAoV2ViQ29yZSk6Cisg ICAgICAgICogcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlJl bmRlckJsb2NrOjpwYWludENhcmV0KToKKwogMjAxMi0wNi0yMCAgQWxleGVpIEZpbGlwcG92ICA8 YWxleGVpZkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgV2ViIEluc3BlY3RvcjogbWFyayB1c2Vk L2FsbG9jYXRlZCBKUyBoZWFwIG9uIHRoZSBuYXRpdmUgbWVtb3J5IGJhciBjaGFydC4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvRnJhbWVTZWxlY3Rpb24uaCBiL1NvdXJjZS9X ZWJDb3JlL2VkaXRpbmcvRnJhbWVTZWxlY3Rpb24uaAppbmRleCA0ZDdmOTg3NzU5NWMyNjQzMzJi ZWQ4OGYzYTQ1OGFkODFiNzZkNDMwLi5jNjNhZjg4ZWYxM2IxNDI5MjE2YzQ3Y2JlNDhlY2ExNzg0 MWVhN2YyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL0ZyYW1lU2VsZWN0aW9u LmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9GcmFtZVNlbGVjdGlvbi5oCkBAIC0xMzAs NiArMTMwLDcgQEAgcHVibGljOgogCiAgICAgRWxlbWVudCogcm9vdEVkaXRhYmxlRWxlbWVudCgp IGNvbnN0IHsgcmV0dXJuIG1fc2VsZWN0aW9uLnJvb3RFZGl0YWJsZUVsZW1lbnQoKTsgfQogICAg IEVsZW1lbnQqIHJvb3RFZGl0YWJsZUVsZW1lbnRPckRvY3VtZW50RWxlbWVudCgpIGNvbnN0Owor ICAgIGJvb2wgcmVuZGVyZXJJc0VkaXRhYmxlKCkgY29uc3QgeyByZXR1cm4gbV9zZWxlY3Rpb24u cmVuZGVyZXJJc0VkaXRhYmxlKCk7IH0KICAgICBib29sIGlzQ29udGVudEVkaXRhYmxlKCkgY29u c3QgeyByZXR1cm4gbV9zZWxlY3Rpb24uaXNDb250ZW50RWRpdGFibGUoKTsgfQogICAgIGJvb2wg aXNDb250ZW50UmljaGx5RWRpdGFibGUoKSBjb25zdCB7IHJldHVybiBtX3NlbGVjdGlvbi5pc0Nv bnRlbnRSaWNobHlFZGl0YWJsZSgpOyB9CiAgICAgIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcv VmlzaWJsZVNlbGVjdGlvbi5jcHAKaW5kZXggNDgxY2QxMzBhZjFiMjY0YzE4MWYxZmUzZjQ4ZDNk ZTk3NzdkYTg2NS4uOGNkMWRmMDMxZWVkOTRhNTk5NTFkZWRhMDZlZmYxZmYzY2I0ZTRkZCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL1Zpc2libGVTZWxlY3Rpb24uY3BwCkBAIC02MjgsNiAr NjI4LDExIEBAIGJvb2wgVmlzaWJsZVNlbGVjdGlvbjo6aXNDb250ZW50RWRpdGFibGUoKSBjb25z dAogICAgIHJldHVybiBpc0VkaXRhYmxlUG9zaXRpb24oc3RhcnQoKSk7CiB9CiAKK2Jvb2wgVmlz aWJsZVNlbGVjdGlvbjo6cmVuZGVyZXJJc0VkaXRhYmxlKCkgY29uc3QKK3sKKyAgICByZXR1cm4g aXNFZGl0YWJsZVBvc2l0aW9uKHN0YXJ0KCksIENvbnRlbnRJc0VkaXRhYmxlLCBEb05vdFVwZGF0 ZVN0eWxlKTsKK30KKwogYm9vbCBWaXNpYmxlU2VsZWN0aW9uOjppc0NvbnRlbnRSaWNobHlFZGl0 YWJsZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIGlzUmljaGx5RWRpdGFibGVQb3NpdGlvbihzdGFy dCgpKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvVmlzaWJsZVNlbGVjdGlv bi5oIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxlU2VsZWN0aW9uLmgKaW5kZXggOGM4 MTBkYTRkZDE5N2UzMWNmNmE1ZjZmOGI4Yjg4MjYyOTdiYjdlZi4uMjMxMjc2OWJiNDlhODBlYzZi ZTU3YzAxMjA3ZDBjNDFmODBjN2Y1MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvZWRpdGlu Zy9WaXNpYmxlU2VsZWN0aW9uLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9WaXNpYmxl U2VsZWN0aW9uLmgKQEAgLTI4LDYgKzI4LDcgQEAKIAogI2luY2x1ZGUgIlRleHRHcmFudWxhcml0 eS5oIgogI2luY2x1ZGUgIlZpc2libGVQb3NpdGlvbi5oIgorI2luY2x1ZGUgImh0bWxlZGl0aW5n LmgiCiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAtOTksNiArMTAwLDcgQEAgcHVibGljOgog ICAgIAogICAgIEVsZW1lbnQqIHJvb3RFZGl0YWJsZUVsZW1lbnQoKSBjb25zdDsKICAgICBib29s IGlzQ29udGVudEVkaXRhYmxlKCkgY29uc3Q7CisgICAgYm9vbCByZW5kZXJlcklzRWRpdGFibGUo KSBjb25zdDsKICAgICBib29sIGlzQ29udGVudFJpY2hseUVkaXRhYmxlKCkgY29uc3Q7CiAgICAg Ly8gUmV0dXJucyBhIHNoYWRvdyB0cmVlIG5vZGUgZm9yIGxlZ2FjeSBzaGFkb3cgdHJlZXMsIGEg Y2hpbGQgb2YgdGhlCiAgICAgLy8gU2hhZG93Um9vdCBub2RlIGZvciBuZXcgc2hhZG93IHRyZWVz LCBvciAwIGZvciBub24tc2hhZG93IHRyZWVzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv ZWRpdGluZy9odG1sZWRpdGluZy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0 aW5nLmNwcAppbmRleCBlMTgwY2NhYmQxYjE2MDFmYjhkMTcwOGRjYmYyZGJhY2Y0ODBmNDY1Li5l OTU5MTc4ZTM2MjllNjRmZmIxMzhlYWY4NThlMWFlYzA1OGM1MDljIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9lZGl0aW5nL2h0bWxlZGl0aW5nLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9l ZGl0aW5nL2h0bWxlZGl0aW5nLmNwcApAQCAtMTQ1LDEyICsxNDUsMTYgQEAgTm9kZSogbG93ZXN0 RWRpdGFibGVBbmNlc3RvcihOb2RlKiBub2RlKQogICAgIHJldHVybiBsb3dlc3RSb290OwogfQog Ci1ib29sIGlzRWRpdGFibGVQb3NpdGlvbihjb25zdCBQb3NpdGlvbiYgcCwgRWRpdGFibGVUeXBl IGVkaXRhYmxlVHlwZSkKK2Jvb2wgaXNFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiBw LCBFZGl0YWJsZVR5cGUgZWRpdGFibGVUeXBlLCBFVXBkYXRlU3R5bGUgdXBkYXRlU3R5bGUpCiB7 CiAgICAgTm9kZSogbm9kZSA9IHAuZGVwcmVjYXRlZE5vZGUoKTsKICAgICBpZiAoIW5vZGUpCiAg ICAgICAgIHJldHVybiBmYWxzZTsKLSAgICAgICAgCisgICAgaWYgKHVwZGF0ZVN0eWxlID09IFVw ZGF0ZVN0eWxlKQorICAgICAgICBub2RlLT5kb2N1bWVudCgpLT51cGRhdGVMYXlvdXRJZ25vcmVQ ZW5kaW5nU3R5bGVzaGVldHMoKTsKKyAgICBlbHNlCisgICAgICAgIEFTU0VSVCh1cGRhdGVTdHls ZSA9PSBEb05vdFVwZGF0ZVN0eWxlKTsKKwogICAgIGlmIChub2RlLT5yZW5kZXJlcigpICYmIG5v ZGUtPnJlbmRlcmVyKCktPmlzVGFibGUoKSkKICAgICAgICAgbm9kZSA9IG5vZGUtPnBhcmVudE5v ZGUoKTsKICAgICAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRp bmcuaCBiL1NvdXJjZS9XZWJDb3JlL2VkaXRpbmcvaHRtbGVkaXRpbmcuaAppbmRleCBhODE5YzQ5 MmNiMDZlZjhhYzg5ZWM4YjNmMzE4NjA4ZTliMGUyMmVkLi4yOWM5YTc5NjMyMjI3ZGIzMjQ2YTky OGE3M2QzYWUwMDU1NjMyMDQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9lZGl0aW5nL2h0 bWxlZGl0aW5nLmgKKysrIGIvU291cmNlL1dlYkNvcmUvZWRpdGluZy9odG1sZWRpdGluZy5oCkBA IC0xNTEsOCArMTUxLDkgQEAgaW5saW5lIFBvc2l0aW9uIGxhc3RQb3NpdGlvbkluT3JBZnRlck5v ZGUoTm9kZSogbm9kZSkKIGludCBjb21wYXJlUG9zaXRpb25zKGNvbnN0IFBvc2l0aW9uJiwgY29u c3QgUG9zaXRpb24mKTsKIAogLy8gYm9vbGVhbiBmdW5jdGlvbnMgb24gUG9zaXRpb24KLSAgICAK LWJvb2wgaXNFZGl0YWJsZVBvc2l0aW9uKGNvbnN0IFBvc2l0aW9uJiwgRWRpdGFibGVUeXBlID0g Q29udGVudElzRWRpdGFibGUpOworCitlbnVtIEVVcGRhdGVTdHlsZSB7IFVwZGF0ZVN0eWxlLCBE b05vdFVwZGF0ZVN0eWxlIH07Citib29sIGlzRWRpdGFibGVQb3NpdGlvbihjb25zdCBQb3NpdGlv biYsIEVkaXRhYmxlVHlwZSA9IENvbnRlbnRJc0VkaXRhYmxlLCBFVXBkYXRlU3R5bGUgPSBVcGRh dGVTdHlsZSk7CiBib29sIGlzUmljaGx5RWRpdGFibGVQb3NpdGlvbihjb25zdCBQb3NpdGlvbiYs IEVkaXRhYmxlVHlwZSA9IENvbnRlbnRJc0VkaXRhYmxlKTsKIGJvb2wgaXNGaXJzdFZpc2libGVQ b3NpdGlvbkluU3BlY2lhbEVsZW1lbnQoY29uc3QgUG9zaXRpb24mKTsKIGJvb2wgaXNMYXN0Vmlz aWJsZVBvc2l0aW9uSW5TcGVjaWFsRWxlbWVudChjb25zdCBQb3NpdGlvbiYpOwpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJCbG9jay5jcHAKaW5kZXggMTJkMThmZTU5MjhkMGNhYjYzZGNl ZjU4OGM4NjU2MTg2OTYzNmQzZC4uNjkyY2FhNTBhOTMyYzk2NGFjNjBmZDRkMGNlY2IwZjlkMTZj Zjg0MSAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckJsb2NrLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyQmxvY2suY3BwCkBAIC0yODc0 LDcgKzI4NzQsNyBAQCB2b2lkIFJlbmRlckJsb2NrOjpwYWludENhcmV0KFBhaW50SW5mbyYgcGFp bnRJbmZvLCBjb25zdCBMYXlvdXRQb2ludCYgcGFpbnRPZmZzZQogICAgIGJvb2wgaXNDb250ZW50 RWRpdGFibGU7CiAgICAgaWYgKHR5cGUgPT0gQ3Vyc29yQ2FyZXQpIHsKICAgICAgICAgY2FyZXRQ YWludGVyID0gZnJhbWUoKS0+c2VsZWN0aW9uKCktPmNhcmV0UmVuZGVyZXIoKTsKLSAgICAgICAg aXNDb250ZW50RWRpdGFibGUgPSBmcmFtZSgpLT5zZWxlY3Rpb24oKS0+aXNDb250ZW50RWRpdGFi bGUoKTsKKyAgICAgICAgaXNDb250ZW50RWRpdGFibGUgPSBmcmFtZSgpLT5zZWxlY3Rpb24oKS0+ cmVuZGVyZXJJc0VkaXRhYmxlKCk7CiAgICAgfSBlbHNlIHsKICAgICAgICAgY2FyZXRQYWludGVy ID0gZnJhbWUoKS0+cGFnZSgpLT5kcmFnQ2FyZXRDb250cm9sbGVyKCktPmNhcmV0UmVuZGVyZXIo KTsKICAgICAgICAgaXNDb250ZW50RWRpdGFibGUgPSBmcmFtZSgpLT5wYWdlKCktPmRyYWdDYXJl dENvbnRyb2xsZXIoKS0+aXNDb250ZW50RWRpdGFibGUoKTsKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA1OTRkZGVkYjJlNDhk YmJkMTI1M2Y5ZWNkMGIxOTdiMzMyZDJjMzY4Li42ZGZiZjM0YjhlNWFiZjBlZDIwNThiYTBjMWMx ZDM2ZDIzY2IyMjk0IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTItMDYtMTMgIEhheWF0byBJ dG8gIDxoYXlhdG9AY2hyb21pdW0ub3JnPgorCisgICAgICAgIFtTaGFkb3ddW0VkaXRpbmddIERl bGV0aW5nIGNoYXJhY3RlciBpbiBkaXN0cmlidXRlZCBlbGVtZW50IGNhdXNlZCBhIGNyYXNoCisg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04ODQ4NAorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogZWRpdGluZy9z aGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0ZWQtbm9kZS1jcmFzaC1leHBlY3Rl ZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGVkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJz LWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2guaHRtbDogQWRkZWQuCisKIDIwMTItMDYtMjAgIEhh bnMgV2VubmJvcmcgIDxoYW5zQGNocm9taXVtLm9yZz4KIAogICAgICAgICBTcGVlY2ggSmF2YVNj cmlwdCBBUEk6IGFkZCBTcGVlY2hSZWNvZ25pdGlvbi5tYXhBbHRlcm5hdGl2ZXMgYXR0cmlidXRl CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9lZGl0aW5nL3NoYWRvdy9kZWxldGUtY2hhcmFjdGVy cy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL2Vk aXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2gt ZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjVmZDIxM2Y3ZmNkMjFiMjVjYzU1YTM2ZDNlMjc2ZTFh NGIwMjI1MWUKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9lZGl0aW5nL3NoYWRvdy9k ZWxldGUtY2hhcmFjdGVycy1pbi1kaXN0cmlidXRlZC1ub2RlLWNyYXNoLWV4cGVjdGVkLnR4dApA QCAtMCwwICsxLDQgQEAKK1RoaXMgdGVzdHMgdGhlIGRlbGV0aW9uIG9mIHRleHQgaW4gZGlzdHJp YnV0ZWQgbm9kZSBkb2VzIG5vdCBjcmFzaC4gVG8gcnVuIGl0IG91dHNpZGUgb2YgRFJULCB5b3Ug bXVzdCBkZWxldGUgdGV4dCwgJ2ZvbycsIG1hbnVhbGx5LgorCisKK1BBU1MKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1jaGFyYWN0ZXJzLWluLWRpc3RyaWJ1 dGVkLW5vZGUtY3Jhc2guaHRtbCBiL0xheW91dFRlc3RzL2VkaXRpbmcvc2hhZG93L2RlbGV0ZS1j aGFyYWN0ZXJzLWluLWRpc3RyaWJ1dGVkLW5vZGUtY3Jhc2guaHRtbApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4zYjk0 MTYxZTMxNDI3YmI4MmM3YzE3ZmE1NmUzMTU3NDg0MTRiYWMxCi0tLSAvZGV2L251bGwKKysrIGIv TGF5b3V0VGVzdHMvZWRpdGluZy9zaGFkb3cvZGVsZXRlLWNoYXJhY3RlcnMtaW4tZGlzdHJpYnV0 ZWQtbm9kZS1jcmFzaC5odG1sCkBAIC0wLDAgKzEsMTkgQEAKKzwhRE9DVFlQRSBodG1sPgorPGh0 bWw+Cis8Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+VGhpcyB0ZXN0cyB0aGUgZGVsZXRpb24g b2YgdGV4dCBpbiBkaXN0cmlidXRlZCBub2RlIGRvZXMgbm90IGNyYXNoLiBUbyBydW4gaXQgb3V0 c2lkZSBvZiBEUlQsIHlvdSBtdXN0IGRlbGV0ZSB0ZXh0LCAnZm9vJywgbWFudWFsbHkuPC9wPgor PGRpdiBpZD0ic2hhZG93aG9zdCIgY29udGVudGVkaXRhYmxlPjxkaXY+Zm9vPC9kaXY+PC9kaXY+ Cis8c2NyaXB0PgoraWYgKHdpbmRvdy5sYXlvdXRUZXN0Q29udHJvbGxlcikKKyAgICBsYXlvdXRU ZXN0Q29udHJvbGxlci5kdW1wQXNUZXh0KCk7Cit2YXIgc2hhZG93Um9vdCA9IG5ldyBXZWJLaXRT aGFkb3dSb290KGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzaGFkb3dob3N0JykpOworc2hhZG93 Um9vdC5pbm5lckhUTUwgPSAiPGNvbnRlbnQ+PC9jb250ZW50PiI7CisKK3ZhciB0ZXh0Tm9kZSA9 IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzaGFkb3dob3N0JykuZmlyc3RDaGlsZC5maXJzdENo aWxkOword2luZG93LmdldFNlbGVjdGlvbigpLnNldEJhc2VBbmRFeHRlbnQodGV4dE5vZGUsIDAs IHRleHROb2RlLCAzKTsKK2RvY3VtZW50LmV4ZWNDb21tYW5kKCdEZWxldGUnKTsKKworZG9jdW1l bnQud3JpdGUoJ1BBU1MnKTsKKzwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgo=